package.json

@@ -1,6 +1,6 @@
 {
    "name": "@hibas123/logging",
-   "version": "2.3.0",
+   "version": "2.2.2",
    "description": "",
    "main": "out/index.js",
    "types": "out/index.d.ts",

src/base.ts

@@ -42,7 +42,6 @@ export interface LoggingBaseOptions {
    console: boolean;
 }
 
-const adapterCache = new WeakMap<Adapter, number>();
 export class LoggingBase {
    private _formatMap: FormatConfig = new DefaultFormatConfig();
 
@@ -111,12 +110,8 @@ export class LoggingBase {
    addAdapter(adapter: Adapter) {
       if (!this.adapter.has(adapter)) {
          this.adapter.add(adapter);
-
-         let cached = adapterCache.get(adapter) || 0;
-         adapterCache.set(adapter, cached + 1);
-
          let prms = Promise.resolve(
-            adapter.init(this.messageObservable.getPublicApi())
+            adapter.init(this.messageObservable.getPublicApi(), this._name)
          );
          this.adapter_init.push(prms);
       }
@@ -134,29 +129,10 @@ export class LoggingBase {
       }
    }
 
-   private $closed = false;
-
    public close() {
-      if (this.$closed) return;
+      this.adapter.forEach((adapter) =>
-      this.$closed = true;
+         adapter.close ? adapter.close() : undefined
-
+      );
-      this.adapter.forEach((adapter) => {
-         let cached = adapterCache.get(adapter);
-
-         if (cached) {
-            cached--;
-            if (cached <= 0) {
-               adapterCache.delete(adapter);
-               adapter.close();
-            } else adapterCache.set(adapter, cached);
-         }
-
-         adapter.close ? adapter.close() : undefined;
-      });
-
-      this.adapter = undefined;
-
-      this.messageObservable.close();
    }
 
    public waitForSetup() {
@@ -258,8 +234,6 @@ export class LoggingBase {
       message: any[],
       caller?: { file: string; line: number }
    ) {
-      if (this.$closed) return;
-
       let date = new Date().toISOString().replace(/T/, " ").replace(/\..+/, "");
 
       let file_raw = caller || getCallerFile();

src/consolewriter.ts

@@ -1,11 +1,19 @@
 import { ObservableInterface } from "@hibas123/utils";
 import { Colors } from "./index";
 import {
+<<<<<<< HEAD
+  Adapter,
+  Message,
+  FormattedLine,
+  TerminalFormats,
+  FormatTypes
+=======
    Adapter,
    Message,
    FormattedLine,
    TerminalFormats,
    FormatTypes,
+>>>>>>> facb7e7b403e1dfaa8790426259e6effb0618efb
 } from "./types";
 
 const browser = typeof window !== "undefined";
@@ -15,7 +23,11 @@ export class ConsoleAdapter implements Adapter {
     observable.subscribe(this.onMessage.bind(this));
   }
 
+<<<<<<< HEAD
   flush() {}
+=======
+   flush() {}
+>>>>>>> facb7e7b403e1dfaa8790426259e6effb0618efb
 
   // TODO: Check if required!
   // private escape(text: string): string {
@@ -136,7 +148,7 @@ export class ConsoleAdapter implements Adapter {
     if (browser) {
       let formats: string[] = [];
       let text = lines
-            .map((line) => {
+        .map(line => {
           let [t, fmts] = this.formatLine(line);
           formats.push(...fmts);
           return prefix + t;
@@ -145,7 +157,7 @@ export class ConsoleAdapter implements Adapter {
       // console.log(formats);
       console.log(text, ...formats);
     } else {
-         lines.forEach((line) => {
+      lines.forEach(line => {
         let [text] = this.formatLine(line);
         console.log(prefix + text);
       });

src/index.ts

@@ -1,11 +1,6 @@
 import { LoggingBase } from "./base";
 export { ConsoleAdapter } from "./consolewriter";
-export {
+export { LoggingBase, LoggingBaseOptions, removeColors, withColor } from "./base";
-   LoggingBase,
-   LoggingBaseOptions,
-   removeColors,
-   withColor,
-} from "./base";
 export {
     Adapter,
     LoggingTypes,
@@ -17,7 +12,7 @@ export {
     Colors,
     Format,
     FormatTypes,
-   TerminalFormats,
+    TerminalFormats
 } from "./types";
 
 export { ObservableInterface } from "@hibas123/utils";

src/inspect.ts

@@ -1,3 +1,4 @@
+
 /**
  * Module exports.
  */
@@ -25,7 +26,7 @@ export default function inspect(obj: any, opts: Partial<InspectOptions>) {
         depth: undefined,
         colors: undefined,
         showHidden: undefined,
-      customInspect: undefined,
+        customInspect: undefined
     };
     // legacy...
     if (arguments.length >= 3) ctx.depth = arguments[2];
@@ -48,32 +49,32 @@ export default function inspect(obj: any, opts: Partial<InspectOptions>) {
 
 // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
 inspect.colors = {
-   bold: [1, 22],
+    'bold': [1, 22],
-   italic: [3, 23],
+    'italic': [3, 23],
-   underline: [4, 24],
+    'underline': [4, 24],
-   inverse: [7, 27],
+    'inverse': [7, 27],
-   white: [37, 39],
+    'white': [37, 39],
-   grey: [90, 39],
+    'grey': [90, 39],
-   black: [30, 39],
+    'black': [30, 39],
-   blue: [34, 39],
+    'blue': [34, 39],
-   cyan: [36, 39],
+    'cyan': [36, 39],
-   green: [32, 39],
+    'green': [32, 39],
-   magenta: [35, 39],
+    'magenta': [35, 39],
-   red: [31, 39],
+    'red': [31, 39],
-   yellow: [33, 39],
+    'yellow': [33, 39]
 };
 
 // Don't use 'blue' not visible on cmd.exe
 inspect.styles = {
-   special: "cyan",
+    'special': 'cyan',
-   number: "yellow",
+    'number': 'yellow',
-   boolean: "yellow",
+    'boolean': 'yellow',
-   undefined: "grey",
+    'undefined': 'grey',
-   null: "bold",
+    'null': 'bold',
-   string: "green",
+    'string': 'green',
-   date: "magenta",
+    'date': 'magenta',
     // "name": intentionally not styling
-   regexp: "red",
+    'regexp': 'red'
 };
 
 function stylizeNoColor(str, styleType) {
@@ -81,7 +82,7 @@ function stylizeNoColor(str, styleType) {
 }
 
 function isBoolean(arg) {
-   return typeof arg === "boolean";
+    return typeof arg === 'boolean';
 }
 
 function isUndefined(arg) {
@@ -92,30 +93,23 @@ function stylizeWithColor(str, styleType) {
     var style = inspect.styles[styleType];
 
     if (style) {
-      return (
+        return '\u001b[' + inspect.colors[style][0] + 'm' + str +
-         "\u001b[" +
+            '\u001b[' + inspect.colors[style][1] + 'm';
-         inspect.colors[style][0] +
-         "m" +
-         str +
-         "\u001b[" +
-         inspect.colors[style][1] +
-         "m"
-      );
     } else {
         return str;
     }
 }
 
 function isFunction(arg) {
-   return typeof arg === "function";
+    return typeof arg === 'function';
 }
 
 function isString(arg) {
-   return typeof arg === "string";
+    return typeof arg === 'string';
 }
 
 function isNumber(arg) {
-   return typeof arg === "number";
+    return typeof arg === 'number';
 }
 
 function isNull(arg) {
@@ -127,22 +121,20 @@ function hasOwn(obj, prop) {
 }
 
 function isRegExp(re) {
-   return isObject(re) && objectToString(re) === "[object RegExp]";
+    return isObject(re) && objectToString(re) === '[object RegExp]';
 }
 
 function isObject(arg) {
-   return typeof arg === "object" && arg !== null;
+    return typeof arg === 'object' && arg !== null;
 }
 
 function isError(e) {
-   return (
+    return isObject(e) &&
-      isObject(e) &&
+        (objectToString(e) === '[object Error]' || e instanceof Error);
-      (objectToString(e) === "[object Error]" || e instanceof Error)
-   );
 }
 
 function isDate(d) {
-   return isObject(d) && objectToString(d) === "[object Date]";
+    return isObject(d) && objectToString(d) === '[object Date]';
 }
 
 function objectToString(o) {
@@ -163,46 +155,35 @@ function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
     var output = [];
     for (var i = 0, l = value.length; i < l; ++i) {
         if (hasOwn(value, String(i))) {
-         output.push(
+            output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
-            formatProperty(
+                String(i), true));
-               ctx,
-               value,
-               recurseTimes,
-               visibleKeys,
-               String(i),
-               true
-            )
-         );
         } else {
-         output.push("");
+            output.push('');
         }
     }
     keys.forEach(function (key) {
         if (!key.match(/^\d+$/)) {
-         output.push(
+            output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
-            formatProperty(ctx, value, recurseTimes, visibleKeys, key, true)
+                key, true));
-         );
         }
     });
     return output;
 }
 
 function formatError(value) {
-   return "[" + Error.prototype.toString.call(value) + "]";
+    return '[' + Error.prototype.toString.call(value) + ']';
 }
 
 function formatValue(ctx, value, recurseTimes) {
     // Provide a hook for user-specified inspect functions.
     // Check that value is an object with an inspect function on it
-   if (
+    if (ctx.customInspect &&
-      ctx.customInspect &&
         value &&
         isFunction(value.inspect) &&
         // Filter out the util module, it's inspect function is special
         value.inspect !== inspect &&
         // Also filter out any prototype objects using the circular check.
-      !(value.constructor && value.constructor.prototype === value)
+        !(value.constructor && value.constructor.prototype === value)) {
-   ) {
         var ret = value.inspect(recurseTimes, ctx);
         if (!isString(ret)) {
             ret = formatValue(ctx, ret, recurseTimes);
@@ -230,59 +211,55 @@ function formatValue(ctx, value, recurseTimes) {
 
     // IE doesn't make error fields non-enumerable
     // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
-   if (
+    if (isError(value)
-      isError(value) &&
+        && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
-      (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)
-   ) {
         return formatError(value);
     }
 
     // Some type of object without properties can be shortcutted.
     if (keys.length === 0) {
         if (isFunction(value)) {
-         var name = value.name ? ": " + value.name : "";
+            var name = value.name ? ': ' + value.name : '';
-         return ctx.stylize("[Function" + name + "]", "special");
+            return ctx.stylize('[Function' + name + ']', 'special');
         }
         if (isRegExp(value)) {
-         return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+            return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
         }
         if (isDate(value)) {
-         return ctx.stylize(Date.prototype.toString.call(value), "date");
+            return ctx.stylize(Date.prototype.toString.call(value), 'date');
         }
         if (isError(value)) {
             return formatError(value);
         }
     }
 
-   var base = "",
+    var base = '', array = false, braces = ['{', '}'];
-      array = false,
-      braces = ["{", "}"];
 
     // Make Array say that they are Array
     if (Array.isArray(value)) {
         array = true;
-      braces = ["[", "]"];
+        braces = ['[', ']'];
     }
 
     // Make functions say that they are functions
     if (isFunction(value)) {
-      var n = value.name ? ": " + value.name : "";
+        var n = value.name ? ': ' + value.name : '';
-      base = " [Function" + n + "]";
+        base = ' [Function' + n + ']';
     }
 
     // Make RegExps say that they are RegExps
     if (isRegExp(value)) {
-      base = " " + RegExp.prototype.toString.call(value);
+        base = ' ' + RegExp.prototype.toString.call(value);
     }
 
     // Make dates with properties first say the date
     if (isDate(value)) {
-      base = " " + Date.prototype.toUTCString.call(value);
+        base = ' ' + Date.prototype.toUTCString.call(value);
     }
 
     // Make error with message first say the error
     if (isError(value)) {
-      base = " " + formatError(value);
+        base = ' ' + formatError(value);
     }
 
     if (keys.length === 0 && (!array || value.length == 0)) {
@@ -291,9 +268,9 @@ function formatValue(ctx, value, recurseTimes) {
 
     if (recurseTimes < 0) {
         if (isRegExp(value)) {
-         return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+            return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
         } else {
-         return ctx.stylize("[Object]", "special");
+            return ctx.stylize('[Object]', 'special');
         }
     }
 
@@ -304,14 +281,7 @@ function formatValue(ctx, value, recurseTimes) {
         output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
     } else {
         output = keys.map(function (key) {
-         return formatProperty(
+            return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
-            ctx,
-            value,
-            recurseTimes,
-            visibleKeys,
-            key,
-            array
-         );
         });
     }
 
@@ -341,17 +311,17 @@ function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
     }
     if (desc.get) {
         if (desc.set) {
-         str = ctx.stylize("[Getter/Setter]", "special");
+            str = ctx.stylize('[Getter/Setter]', 'special');
         } else {
-         str = ctx.stylize("[Getter]", "special");
+            str = ctx.stylize('[Getter]', 'special');
         }
     } else {
         if (desc.set) {
-         str = ctx.stylize("[Setter]", "special");
+            str = ctx.stylize('[Setter]', 'special');
         }
     }
     if (!hasOwn(visibleKeys, key)) {
-      name = "[" + key + "]";
+        name = '[' + key + ']';
     }
     if (!str) {
         if (ctx.seen.indexOf(desc.value) < 0) {
@@ -360,88 +330,76 @@ function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
             } else {
                 str = formatValue(ctx, desc.value, recurseTimes - 1);
             }
-         if (str.indexOf("\n") > -1) {
+            if (str.indexOf('\n') > -1) {
                 if (array) {
-               str = str
+                    str = str.split('\n').map(function (line) {
-                  .split("\n")
+                        return '  ' + line;
-                  .map(function (line) {
+                    }).join('\n').substr(2);
-                     return "  " + line;
-                  })
-                  .join("\n")
-                  .substr(2);
                 } else {
-               str =
+                    str = '\n' + str.split('\n').map(function (line) {
-                  "\n" +
+                        return '   ' + line;
-                  str
+                    }).join('\n');
-                     .split("\n")
-                     .map(function (line) {
-                        return "   " + line;
-                     })
-                     .join("\n");
                 }
             }
         } else {
-         str = ctx.stylize("[Circular]", "special");
+            str = ctx.stylize('[Circular]', 'special');
         }
     }
     if (isUndefined(name)) {
         if (array && key.match(/^\d+$/)) {
             return str;
         }
-      name = JSON.stringify("" + key);
+        name = JSON.stringify('' + key);
         if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
             name = name.substr(1, name.length - 2);
-         name = ctx.stylize(name, "name");
+            name = ctx.stylize(name, 'name');
         } else {
-         name = name
+            name = name.replace(/'/g, "\\'")
-            .replace(/'/g, "\\'")
                 .replace(/\\"/g, '"')
                 .replace(/(^"|"$)/g, "'");
-         name = ctx.stylize(name, "string");
+            name = ctx.stylize(name, 'string');
         }
     }
 
-   return name + ": " + str;
+    return name + ': ' + str;
 }
 
 function formatPrimitive(ctx, value) {
-   if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
+    if (isUndefined(value))
+        return ctx.stylize('undefined', 'undefined');
     if (isString(value)) {
-      var simple =
+        var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
-         "'" +
-         JSON.stringify(value)
-            .replace(/^"|"$/g, "")
             .replace(/'/g, "\\'")
-            .replace(/\\"/g, '"') +
+            .replace(/\\"/g, '"') + '\'';
-         "'";
+        return ctx.stylize(simple, 'string');
-      return ctx.stylize(simple, "string");
     }
-   if (isNumber(value)) return ctx.stylize("" + value, "number");
+    if (isNumber(value))
-   if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
+        return ctx.stylize('' + value, 'number');
+    if (isBoolean(value))
+        return ctx.stylize('' + value, 'boolean');
     // For some reason typeof null is "object", so special case here.
-   if (isNull(value)) return ctx.stylize("null", "null");
+    if (isNull(value))
+        return ctx.stylize('null', 'null');
 }
 
 function reduceToSingleString(output, base, braces) {
     var numLinesEst = 0;
     var length = output.reduce(function (prev, cur) {
         numLinesEst++;
-      if (cur.indexOf("\n") >= 0) numLinesEst++;
+        if (cur.indexOf('\n') >= 0) numLinesEst++;
-      return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+        return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
     }, 0);
 
     if (length > 60) {
-      return (
+        return braces[0] +
-         braces[0] +
+            (base === '' ? '' : base + '\n ') +
-         (base === "" ? "" : base + "\n ") +
+            ' ' +
-         " " +
+            output.join(',\n  ') +
-         output.join(",\n  ") +
+            ' ' +
-         " " +
+            braces[1];
-         braces[1]
-      );
     }
 
-   return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+    return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
 }
 
 function _extend<T extends Y, Y>(origin: T, add: Y) {

src/types.ts

@@ -4,9 +4,10 @@ export enum LoggingTypes {
     Debug,
     Log,
     Warning,
-   Error,
+    Error
 }
 
+
 export const TerminalFormats = {
     Reset: "\x1b[0m",
     Bold: "\x1b[1m",
@@ -31,14 +32,15 @@ export const TerminalFormats = {
     BgBlue: "\x1b[44m",
     BgMagenta: "\x1b[45m",
     BgCyan: "\x1b[46m",
-   BgWhite: "\x1b[47m",
+    BgWhite: "\x1b[47m"
-};
+}
+
 
 export enum FormatTypes {
     COLOR,
     BOLD,
     UNDERSCORE,
-   BLINK,
+    BLINK
 }
 
 export enum Colors {
@@ -49,7 +51,7 @@ export enum Colors {
     BLUE,
     MAGENTA,
     CYAN,
-   WHITE,
+    WHITE
 }
 
 export interface FormatConfig {
@@ -65,12 +67,12 @@ export interface FormatConfig {
 function colorFormat(color: Colors) {
     return {
         type: FormatTypes.COLOR,
-      color,
+        color
-   };
+    }
 }
 
 const boldFormat = {
-   type: FormatTypes.BOLD,
+    type: FormatTypes.BOLD
 };
 
 export class DefaultFormatConfig implements FormatConfig {
@@ -99,27 +101,19 @@ export interface Message {
     type: LoggingTypes;
     name?: string;
     text: {
-      raw: string[];
+        raw: string[],
-      formatted: FormattedLine[];
+        formatted: FormattedLine[]
     };
     date: Date;
     file: string;
 }
 
 export interface Adapter {
-   /**
+    init(observable: ObservableInterface<Message>, name?: string): void | Promise<void>;
-    * This function initialises the Adapter. It might be called multiple times, when added to multiple instances
-    * @param observable An observable to subscribe to messages
-    */
-   init(observable: ObservableInterface<Message>): void | Promise<void>;
 
     flush(sync: true): void;
     flush(sync: false): void | Promise<void>;
 
-   /**
+
-    * When a close function is available, it will be called when no logging instance references it anymore.
-    *
-    * WARNING: The adapter might be reinitialised, when it is added to a new Logging instance
-    */
     close?(): void;
 }