Running everything through prettier

src/consolewriter.ts

@@ -1,19 +1,11 @@
 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";
@@ -23,11 +15,7 @@ export class ConsoleAdapter implements Adapter {
       observable.subscribe(this.onMessage.bind(this));
    }
 
-<<<<<<< HEAD
    flush() {}
-=======
-   flush() {}
->>>>>>> facb7e7b403e1dfaa8790426259e6effb0618efb
 
    // TODO: Check if required!
    // private escape(text: string): string {
@@ -148,7 +136,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;
@@ -157,7 +145,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,6 +1,11 @@
 import { LoggingBase } from "./base";
 export { ConsoleAdapter } from "./consolewriter";
-export { LoggingBase, LoggingBaseOptions, removeColors, withColor } from "./base";
+export {
+   LoggingBase,
+   LoggingBaseOptions,
+   removeColors,
+   withColor,
+} from "./base";
 export {
    Adapter,
    LoggingTypes,
@@ -12,7 +17,7 @@ export {
    Colors,
    Format,
    FormatTypes,
-    TerminalFormats
+   TerminalFormats,
 } from "./types";
 
 export { ObservableInterface } from "@hibas123/utils";

src/inspect.ts

@@ -1,4 +1,3 @@
-
 /**
  * Module exports.
  */
@@ -26,7 +25,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];
@@ -49,32 +48,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) {
@@ -82,7 +81,7 @@ function stylizeNoColor(str, styleType) {
 }
 
 function isBoolean(arg) {
-    return typeof arg === 'boolean';
+   return typeof arg === "boolean";
 }
 
 function isUndefined(arg) {
@@ -93,23 +92,30 @@ function stylizeWithColor(str, styleType) {
    var style = inspect.styles[styleType];
 
    if (style) {
-        return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+      return (
-            '\u001b[' + inspect.colors[style][1] + 'm';
+         "\u001b[" +
+         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) {
@@ -121,20 +127,22 @@ 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 isObject(e) &&
+   return (
-        (objectToString(e) === '[object Error]' || e instanceof Error);
+      isObject(e) &&
+      (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) {
@@ -155,35 +163,46 @@ 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(formatProperty(ctx, value, recurseTimes, visibleKeys,
+         output.push(
-                String(i), true));
+            formatProperty(
+               ctx,
+               value,
+               recurseTimes,
+               visibleKeys,
+               String(i),
+               true
+            )
+         );
       } else {
-            output.push('');
+         output.push("");
       }
    }
    keys.forEach(function (key) {
       if (!key.match(/^\d+$/)) {
-            output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+         output.push(
-                key, true));
+            formatProperty(ctx, value, recurseTimes, visibleKeys, 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 (ctx.customInspect &&
+   if (
+      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);
@@ -211,55 +230,59 @@ 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 (isError(value)
+   if (
-        && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+      isError(value) &&
+      (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 = '', array = false, braces = ['{', '}'];
+   var base = "",
+      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)) {
@@ -268,9 +291,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");
       }
    }
 
@@ -281,7 +304,14 @@ function formatValue(ctx, value, recurseTimes) {
       output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
    } else {
       output = keys.map(function (key) {
-            return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+         return formatProperty(
+            ctx,
+            value,
+            recurseTimes,
+            visibleKeys,
+            key,
+            array
+         );
       });
    }
 
@@ -311,17 +341,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) {
@@ -330,76 +360,88 @@ 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.split('\n').map(function (line) {
+               str = str
-                        return '  ' + line;
+                  .split("\n")
-                    }).join('\n').substr(2);
+                  .map(function (line) {
+                     return "  " + line;
+                  })
+                  .join("\n")
+                  .substr(2);
             } else {
-                    str = '\n' + str.split('\n').map(function (line) {
+               str =
-                        return '   ' + line;
+                  "\n" +
-                    }).join('\n');
+                  str
+                     .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.replace(/'/g, "\\'")
+         name = name
+            .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))
+   if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
-        return ctx.stylize('undefined', 'undefined');
    if (isString(value)) {
-        var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+      var simple =
+         "'" +
+         JSON.stringify(value)
+            .replace(/^"|"$/g, "")
             .replace(/'/g, "\\'")
-            .replace(/\\"/g, '"') + '\'';
+            .replace(/\\"/g, '"') +
-        return ctx.stylize(simple, 'string');
+         "'";
+      return ctx.stylize(simple, "string");
    }
-    if (isNumber(value))
+   if (isNumber(value)) return ctx.stylize("" + value, "number");
-        return ctx.stylize('' + value, 'number');
+   if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
-    if (isBoolean(value))
-        return ctx.stylize('' + value, 'boolean');
    // For some reason typeof null is "object", so special case here.
-    if (isNull(value))
+   if (isNull(value)) return ctx.stylize("null", "null");
-        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 braces[0] +
+      return (
-            (base === '' ? '' : base + '\n ') +
+         braces[0] +
-            ' ' +
+         (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,10 +4,9 @@ export enum LoggingTypes {
    Debug,
    Log,
    Warning,
-    Error
+   Error,
 }
 
-
 export const TerminalFormats = {
    Reset: "\x1b[0m",
    Bold: "\x1b[1m",
@@ -32,15 +31,14 @@ 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 {
@@ -51,7 +49,7 @@ export enum Colors {
    BLUE,
    MAGENTA,
    CYAN,
-    WHITE
+   WHITE,
 }
 
 export interface FormatConfig {
@@ -67,12 +65,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 {
@@ -101,19 +99,21 @@ 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>;
+   init(
+      observable: ObservableInterface<Message>,
+      name?: string
+   ): void | Promise<void>;
 
    flush(sync: true): void;
    flush(sync: false): void | Promise<void>;
 
-
    close?(): void;
 }