nightingale 16.1.0 → 16.2.0

package/src/formatter-utils/formatObject.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import type { Styles } from "nightingale-types";
+import { formatStyles } from "./formatStyles";
 
 export interface FormatObjectOptions {
   padding?: string;
@@ -62,6 +63,57 @@ const sameRawFormattedValue = (value: string): FormattedValue => ({
   formattedValue: value,
 });
 
+const numericSeparator = "_";
+
+const formatIntegerValue = (integerAsString: string): string => {
+  let result = "";
+  let i = integerAsString.length;
+  const start = integerAsString.startsWith("-") ? 1 : 0;
+  for (; i >= start + 4; i -= 3) {
+    result = `${numericSeparator}${integerAsString.slice(i - 3, i)}${result}`;
+  }
+  return i === integerAsString.length
+    ? integerAsString
+    : `${integerAsString.slice(0, i)}${result}`;
+};
+
+const formatDecimalIntegerValue = (integerAsString: string): string => {
+  let result = "";
+  let i = 0;
+  for (; i < integerAsString.length - 3; i += 3) {
+    result += `${integerAsString.slice(i, i + 3)}${numericSeparator}`;
+  }
+  return i === 0 ? integerAsString : `${result}${integerAsString.slice(i)}`;
+};
+
+const formatNumberValue = (value: number): string => {
+  if (Number.isNaN(value)) {
+    return "NaN";
+  }
+  if (value === Number.POSITIVE_INFINITY) {
+    return "+Infinity";
+  }
+  if (value === Number.NEGATIVE_INFINITY) {
+    return "-Infinity";
+  }
+  if (value === Number.EPSILON) {
+    return "Epsilon";
+  }
+  if (Object.is(value, -0)) {
+    return "-0";
+  }
+  const integer = Math.trunc(value);
+  const integerAsString = integer.toString();
+  if (integer === value) {
+    if (integerAsString.includes("e")) {
+      return integerAsString;
+    }
+    return formatIntegerValue(integerAsString);
+  } else {
+    return `${formatIntegerValue(integerAsString)}.${formatDecimalIntegerValue(String(value).slice(integerAsString.length + 1))}`;
+  }
+};
+
 function internalFormatValue(
   value: unknown,
   styleFn: StyleFn,
@@ -71,30 +123,42 @@ function internalFormatValue(
   const typeofValue = typeof value;
 
   if (!styles) {
-    if (value == null) {
-      styles = ["cyan"];
+    if (value === null) {
+      styles = ["bold"];
     } else {
       switch (typeofValue) {
-        case "undefined":
-          styles = ["cyan"];
+        case "bigint":
+          styles = formatStyles.bigint;
           break;
         case "boolean":
-          styles = ["green"];
+          styles = formatStyles.boolean;
           break;
-        case "number":
-          styles = ["yellow"];
+        case "undefined":
+          styles = formatStyles.undefined;
           break;
-        case "bigint":
-          styles = ["red"];
+        case "number":
+          styles = formatStyles.number;
           break;
         case "string":
-          styles = ["orange"];
+          styles = formatStyles.string;
           break;
         case "symbol":
-          styles = ["magenta"];
+          styles = formatStyles.symbol;
           break;
         case "object":
+          if (value instanceof Date) {
+            styles = formatStyles.date;
+          }
+          if (value instanceof RegExp) {
+            styles = formatStyles.regexp;
+          }
+          if (value instanceof Error) {
+            styles = formatStyles.error;
+          }
+          break;
         case "function":
+          styles = formatStyles.function;
+          break;
         default:
           break;
       }
@@ -106,6 +170,8 @@ function internalFormatValue(
     stringValue = "null";
   } else if (value === undefined) {
     stringValue = "undefined";
+  } else if (typeofValue === "number") {
+    stringValue = formatNumberValue(value as number);
   } else if (typeofValue === "boolean") {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
     stringValue = (value as any).toString() as string;
@@ -156,7 +222,7 @@ function internalFormatValue(
       });
     }
   } else if (typeofValue === "bigint") {
-    stringValue = (value as bigint).toString();
+    stringValue = `[BigInt: ${(value as bigint).toString()}]`;
   } else if (typeofValue === "symbol") {
     stringValue = (value as symbol).toString();
   } else if (value instanceof Set) {
@@ -175,6 +241,12 @@ function internalFormatValue(
     stringValue = "{WeakMap...}";
   } else if (value instanceof WeakSet) {
     stringValue = "{WeakSet...}";
+  } else if (value instanceof Date) {
+    stringValue = `[Date: ${value.toISOString()}]`;
+  } else if (value instanceof RegExp) {
+    stringValue = `[RegExp: ${value.toString()}]`;
+  } else if (typeof value === "function") {
+    stringValue = `[Function: ${value.name}]`;
   } else {
     stringValue = tryStringify(value);
   }
@@ -196,7 +268,7 @@ const internalFormatKey: FormatKey<string> = (
 ): FormattedKey => {
   return {
     stringKey: `${key}: `,
-    formattedKey: `${styleFn(["gray-light", "bold"], `${key}:`)} `,
+    formattedKey: `${styleFn(["dim", "bold"], `${key}:`)} `,
   };
 };
 
@@ -221,7 +293,7 @@ const internalFormatMapKey: FormatKey<unknown> = (
   );
   return {
     stringKey: `${stringValue} => `,
-    formattedKey: `${styleFn(["gray-light", "bold"], `${formattedValue}:`)} `,
+    formattedKey: `${styleFn(["dim", "bold"], `${formattedValue}:`)} `,
   };
 };
 

package/src/formatter-utils/formatRecordToString.ts

@@ -11,9 +11,9 @@ export function formatRecordToString<T extends Metadata>(
   const parts: string[] = [];
 
   if (record.displayName) {
-    parts.push(style(["gray-light"], record.displayName));
+    parts.push(style(["dim"], record.displayName));
   } else if (record.key) {
-    parts.push(style(["gray-light"], record.key));
+    parts.push(style(["dim"], record.key));
   }
 
   if (record.datetime) {

package/src/formatter-utils/formatStyles.ts

@@ -0,0 +1,15 @@
+/* eslint sort-keys: error */
+
+export const formatStyles = {
+  bigint: ["yellow", "bold"],
+  boolean: ["green"],
+  date: ["magenta"],
+  error: ["red"],
+  function: ["blue"],
+  null: ["bold"],
+  number: ["yellow"],
+  regexp: ["magenta"],
+  string: ["orange"],
+  symbol: ["magenta"],
+  undefined: ["dim"],
+};

package/src/formatter-utils/styleToHexColor.ts

@@ -1,7 +1,5 @@
 export const styleToHexColor = {
   orange: "ff5f00",
-  grayLight: "808080",
-  "gray-light": "808080",
 } as const;
 
 export type StyleToHexColor = Readonly<

package/src/formatter-utils/styleToHtmlStyle.ts

@@ -31,6 +31,7 @@ export const styleToHtmlStyleThemeLight = {
   cyan: { open: "color: #00cfd8", close: "color: currentcolor" },
   white: { open: "color: white", close: "color: currentcolor" },
   gray: { open: "color: gray", close: "color: currentcolor" },
+  dim: { open: "color: #808080", close: "color: currentcolor" },
 
   bgBlack: { open: "background: black", close: "background: initial" },
   bgRed: { open: "background: #ff0020", close: "background: initial" },
@@ -45,14 +46,6 @@ export const styleToHtmlStyleThemeLight = {
     open: `color: #${styleToHexColor.orange}`,
     close: "color: currentcolor",
   },
-  grayLight: {
-    open: `color: #${styleToHexColor.grayLight}`,
-    close: "color: currentcolor",
-  },
-  "gray-light": {
-    open: `color: #${styleToHexColor.grayLight}`,
-    close: "color: currentcolor",
-  },
 } as const;
 
 export type StyleToHtmlStyle = Readonly<

package/src/formatters/ANSIFormatter.test.ts

@@ -22,6 +22,6 @@ test("format simple message", () => {
       datetime: new Date(2000, 1, 1, 1, 1, 1),
     }).replace(/\u001B/g, "ESC"),
   ).toBe(
-    "ESC[38;5;244mtestESC[39m ESC[1mESC[90m01:01:01ESC[39mESC[22m ESC[90m• testESC[39m",
+    "ESC[2mtestESC[22m ESC[1mESC[90m01:01:01ESC[39mESC[22m ESC[90m• testESC[39m",
   );
 });

package/src/formatters/ANSIFormatter.ts

@@ -22,6 +22,7 @@ const ansiStyles: AnsiStyles = {
   cyan: ansi.cyan,
   white: ansi.white,
   gray: ansi.gray,
+  dim: ansi.dim,
 
   bgBlack: ansi.bgBlack,
   bgRed: ansi.bgRed,
@@ -40,10 +41,6 @@ const ansiStyles: AnsiStyles = {
     open: ansi.color.ansi256(ansi.hexToAnsi256(styleToHexColor.orange)),
     close: ansi.color.close,
   },
-  "gray-light": {
-    open: ansi.color.ansi256(ansi.hexToAnsi256(styleToHexColor["gray-light"])),
-    close: ansi.color.close,
-  },
 };
 
 export function style(styles: Styles, string: string): string {

package/src/index.ts

@@ -17,6 +17,7 @@ export { BrowserConsoleHandler } from "./handlers/BrowserConsoleHandler";
 export { ConsoleHandler } from "./handlers/ConsoleHandler";
 export { ConsoleCLIHandler } from "./handlers/ConsoleCLIHandler";
 export { LoggerCLI } from "./loggers/LoggerCLI";
+export { formatStyles } from "./formatter-utils/formatStyles";
 
 /**
  * listen to uncaughtException and unhandledRejection