nightingale 14.2.1 → 16.0.0

package/src/formatter-utils/formatObject.test.ts

@@ -0,0 +1,153 @@
+import type { Styles } from "nightingale-types";
+import { formatObject } from "./formatObject";
+
+test("empty object should return empty string", () => {
+  expect(formatObject({})).toBe("");
+});
+
+const styleFn = (styles: Styles, value: string): string =>
+  styles && styles.length > 0
+    ? `[styles:${styles.join(",")}]${value}[/styles]`
+    : value;
+
+const noStyleFn = (styles: Styles, value: string): string => value;
+
+test("simple object", () => {
+  expect(formatObject({ a: 1 }, styleFn)).toBe(
+    "{ [styles:gray-light,bold]a:[/styles] [styles:yellow]1[/styles] }",
+  );
+});
+
+test("simple without prototype", () => {
+  expect(
+    formatObject(
+      Object.assign(Object.create(null) as Record<string, number>, { a: 1 }),
+      styleFn,
+    ),
+  ).toBe("{ [styles:gray-light,bold]a:[/styles] [styles:yellow]1[/styles] }");
+});
+
+test("long object", () => {
+  expect(
+    formatObject(
+      {
+        obj: {
+          a: 10_000_000_000_000_000_000,
+          b: 10_000_000_000_000_000_000,
+          c: 10_000_000_000_000_000_000,
+          d: 10_000_000_000_000_000_000,
+          e: 10_000_000_000_000_000_000,
+          f: 10_000_000_000_000_000_000,
+        },
+      },
+      noStyleFn,
+    ),
+  ).toBe(
+    "{\n  obj: { a: 10000000000000000000, b: 10000000000000000000, c: 10000000000000000000, d: 10000000000000000000, e: 10000000000000000000, f: 10000000000000000000 },\n}",
+  );
+});
+
+test("multiple values", () => {
+  expect(
+    formatObject(
+      {
+        // eslint-disable-next-line object-shorthand
+        undefined: undefined,
+        null: null,
+        number: 1,
+        string: "s",
+        bigInt: BigInt(1),
+        symbol: Symbol("symbol"),
+      },
+      styleFn,
+    ),
+  ).toBe(
+    '{ [styles:gray-light,bold]undefined:[/styles] [styles:cyan]undefined[/styles][styles:gray],[/styles] [styles:gray-light,bold]null:[/styles] [styles:cyan]null[/styles][styles:gray],[/styles] [styles:gray-light,bold]number:[/styles] [styles:yellow]1[/styles][styles:gray],[/styles] [styles:gray-light,bold]string:[/styles] [styles:orange]"s"[/styles][styles:gray],[/styles] [styles:gray-light,bold]bigInt:[/styles] [styles:red]1[/styles][styles:gray],[/styles] [styles:gray-light,bold]symbol:[/styles] [styles:magenta]Symbol(symbol)[/styles] }',
+  );
+});
+
+test("simple embeded empty object", () => {
+  expect(formatObject({ a: {} }, noStyleFn)).toBe("{ a: {} }");
+});
+
+test("simple embeded object", () => {
+  expect(formatObject({ a: { b: 1 } }, noStyleFn)).toBe("{ a: { b: 1 } }");
+});
+
+test("simple recursive object", () => {
+  const a: { a: any } = { a: 1 };
+  a.a = a;
+  expect(a.a).toBe(a);
+  expect(formatObject({ a }, noStyleFn)).toBe(
+    "{ a: { a: {Circular Object} } }",
+  );
+});
+
+test("empty map", () => {
+  expect(formatObject({ a: new Map() }, noStyleFn)).toBe("{ a: Map {} }");
+});
+
+test("simple map", () => {
+  expect(
+    formatObject(
+      {
+        a: new Map<any, any>([
+          ["key1", "value1"],
+          [{ b: 1 }, "value2"],
+        ]),
+      },
+      noStyleFn,
+    ),
+  ).toBe('{ a: Map { "key1": "value1", { b: 1 }: "value2" } }');
+});
+
+test("empty array", () => {
+  expect(formatObject({ a: [] }, noStyleFn)).toBe("{ a: [] }");
+});
+
+test("simple array", () => {
+  expect(formatObject({ a: [1, "2", 3, 4, 5] }, noStyleFn)).toBe(
+    '{ a: [1, "2", 3, 4, 5] }',
+  );
+});
+
+test("object in array", () => {
+  const obj = { a: 1, b: 2 };
+  expect(formatObject({ a: [obj] }, noStyleFn)).toBe("{ a: [{ a: 1, b: 2 }] }");
+});
+
+test("objects in array", () => {
+  const obj = { a: 1, b: 2 };
+  expect(formatObject({ a: [obj, obj] }, noStyleFn)).toBe(
+    "{ a: [{ a: 1, b: 2 }, { a: 1, b: 2 }] }",
+  );
+});
+
+test("objects with breaking lines in array", () => {
+  const obj = {
+    a: 10_000_000_000_000_000_000,
+    b: 10_000_000_000_000_000_000,
+    c: 10_000_000_000_000_000_000,
+    d: 10_000_000_000_000_000_000,
+    e: 10_000_000_000_000_000_000,
+    f: 10_000_000_000_000_000_000,
+  };
+  expect(formatObject({ a: [obj, obj] }, noStyleFn)).toBe(
+    `{
+  a: [
+    { a: 10000000000000000000, b: 10000000000000000000, c: 10000000000000000000, d: 10000000000000000000, e: 10000000000000000000, f: 10000000000000000000 },
+    { a: 10000000000000000000, b: 10000000000000000000, c: 10000000000000000000, d: 10000000000000000000, e: 10000000000000000000, f: 10000000000000000000 },
+  ],
+}`,
+  );
+});
+
+test("empty set", () => {
+  expect(formatObject({ a: new Set() }, noStyleFn)).toBe("{ a: Set [] }");
+});
+
+test("simple set", () => {
+  expect(formatObject({ a: new Set(["value1", "value2"]) }, noStyleFn)).toBe(
+    '{ a: Set [ "value1", "value2" ] }',
+  );
+});

package/src/formatter-utils/formatObject.ts

@@ -0,0 +1,462 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import type { Styles } from "nightingale-types";
+
+export interface FormatObjectOptions {
+  padding?: string;
+  maxDepth?: number;
+}
+
+export type StyleFn = (styles: Styles, value: string) => string;
+
+export type ObjectStyles<Keys extends string = string> = Record<Keys, Styles>;
+
+const noStyleFn: StyleFn = (styles: Styles, value: string): string => value;
+
+interface InternalFormatParams {
+  padding: string;
+  depth: number;
+  maxDepth: number;
+  objects: Set<unknown>;
+}
+
+interface FormattedKey {
+  stringKey: string;
+  formattedKey: string;
+}
+
+type FormatKey<Key> = (
+  key: Key,
+  styleFn: StyleFn,
+  internalFormatParams: InternalFormatParams,
+) => FormattedKey;
+
+interface Value<Key> {
+  key: Key;
+  value: unknown;
+}
+
+interface FormattedValue {
+  stringValue: string;
+  formattedValue: string;
+}
+
+type Values<Key> = Value<Key>[];
+
+interface InternalFormatIteratorParams<Key> {
+  prefix: string;
+  suffix: string;
+  formatKey: FormatKey<Key>;
+  prefixSuffixSpace?: string;
+}
+
+function tryStringify(arg: unknown): string {
+  try {
+    return JSON.stringify(arg).replace(/\\n/g, "\n");
+  } catch {
+    return "[Circular]";
+  }
+}
+
+const sameRawFormattedValue = (value: string): FormattedValue => ({
+  stringValue: value,
+  formattedValue: value,
+});
+
+function internalFormatValue(
+  value: unknown,
+  styleFn: StyleFn,
+  styles: Styles,
+  { padding, depth, maxDepth, objects }: InternalFormatParams,
+): FormattedValue {
+  const typeofValue = typeof value;
+
+  if (!styles) {
+    if (value == null) {
+      styles = ["cyan"];
+    } else {
+      switch (typeofValue) {
+        case "undefined":
+          styles = ["cyan"];
+          break;
+        case "boolean":
+          styles = ["green"];
+          break;
+        case "number":
+          styles = ["yellow"];
+          break;
+        case "bigint":
+          styles = ["red"];
+          break;
+        case "string":
+          styles = ["orange"];
+          break;
+        case "symbol":
+          styles = ["magenta"];
+          break;
+        case "object":
+        case "function":
+        default:
+          break;
+      }
+    }
+  }
+
+  let stringValue: string;
+  if (value === null) {
+    stringValue = "null";
+  } else if (value === undefined) {
+    stringValue = "undefined";
+  } 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;
+  } else if ((value as () => unknown).constructor === Object) {
+    if (depth >= maxDepth) {
+      stringValue = "{Object...}";
+    } else {
+      return internalFormatObject(
+        value as Record<string, unknown>,
+        styleFn,
+        undefined,
+        {
+          padding,
+          depth: depth + 1,
+          maxDepth,
+          objects,
+        },
+      );
+    }
+  } else if (Array.isArray(value)) {
+    if (depth >= maxDepth) {
+      stringValue = "[Array...]";
+    } else {
+      return internalFormatArray(value, styleFn, {
+        padding,
+        depth: depth + 1,
+        maxDepth,
+        objects,
+      });
+    }
+  } else if (value instanceof Error) {
+    const stack = value.stack;
+    stringValue =
+      stack?.startsWith(value.message) ||
+      stack?.startsWith(`${value.name}: ${value.message}`)
+        ? stack
+        : `${value.message}\n${stack || ""}`;
+  } else if (value instanceof Map) {
+    const name = value.constructor.name;
+    if (depth >= maxDepth) {
+      stringValue = `{${name}...}`;
+    } else {
+      return internalFormatMap(name, value, styleFn, {
+        padding,
+        depth: depth + 1,
+        maxDepth,
+        objects,
+      });
+    }
+  } else if (typeofValue === "bigint") {
+    stringValue = (value as bigint).toString();
+  } else if (typeofValue === "symbol") {
+    stringValue = (value as symbol).toString();
+  } else if (value instanceof Set) {
+    const name = value.constructor.name;
+    if (depth >= maxDepth) {
+      stringValue = `{${name}...}`;
+    } else {
+      return internalFormatSet(name, value, styleFn, {
+        padding,
+        depth: depth + 1,
+        maxDepth,
+        objects,
+      });
+    }
+  } else if (value instanceof WeakMap) {
+    stringValue = "{WeakMap...}";
+  } else if (value instanceof WeakSet) {
+    stringValue = "{WeakSet...}";
+  } else {
+    stringValue = tryStringify(value);
+  }
+
+  const formattedValue = styleFn(styles, stringValue);
+
+  return {
+    stringValue,
+    formattedValue,
+  };
+}
+
+const separator = ",";
+
+const internalFormatKey: FormatKey<string> = (
+  key: string,
+  styleFn: StyleFn,
+  internalFormatParams: InternalFormatParams,
+): FormattedKey => {
+  return {
+    stringKey: `${key}: `,
+    formattedKey: `${styleFn(["gray-light", "bold"], `${key}:`)} `,
+  };
+};
+
+const internalNoKey: FormatKey<undefined> = (
+  key: string | undefined,
+  styleFn: StyleFn,
+  internalFormatParams: InternalFormatParams,
+): FormattedKey => {
+  return { stringKey: "", formattedKey: "" };
+};
+
+const internalFormatMapKey: FormatKey<unknown> = (
+  key: unknown,
+  styleFn: StyleFn,
+  internalFormatParams: InternalFormatParams,
+): FormattedKey => {
+  const { stringValue, formattedValue } = internalFormatValue(
+    key,
+    noStyleFn,
+    undefined,
+    internalFormatParams,
+  );
+  return {
+    stringKey: `${stringValue} => `,
+    formattedKey: `${styleFn(["gray-light", "bold"], `${formattedValue}:`)} `,
+  };
+};
+
+const internalFormatIterator = <Key>(
+  values: Values<Key>,
+  styleFn: StyleFn,
+  objectStyles: ObjectStyles | undefined,
+  { padding, depth, maxDepth, objects }: InternalFormatParams,
+  {
+    prefix,
+    suffix,
+    prefixSuffixSpace = " ",
+    formatKey,
+  }: InternalFormatIteratorParams<Key>,
+): FormattedValue => {
+  let breakLine = false;
+  const formattedSeparator = (): string => styleFn(["gray"], separator);
+
+  const valuesMaxIndex = values.length - 1;
+  const formattedValues: FormattedValue[] = values.map(
+    ({ key, value }, index: number) => {
+      const nextDepth = depth + 1;
+      const internalFormatParams = {
+        padding,
+        depth: nextDepth,
+        maxDepth,
+        objects,
+      };
+
+      // key must be formatted before value (browser-formatter needs order)
+      const { stringKey, formattedKey } = formatKey(
+        key,
+        styleFn,
+        internalFormatParams,
+      );
+
+      let { stringValue, formattedValue } = internalFormatValue(
+        value,
+        styleFn,
+        key && objectStyles
+          ? objectStyles[key as unknown as string]
+          : undefined,
+        internalFormatParams,
+      );
+
+      if (
+        stringValue &&
+        (stringValue.length > 80 || stringValue.includes("\n"))
+      ) {
+        breakLine = true;
+        stringValue = stringValue.replace(/\n/g, `\n${padding}`);
+        formattedValue = formattedValue.replace(/\n/g, `\n${padding}`);
+      }
+
+      return {
+        stringValue:
+          stringKey + stringValue + (index === valuesMaxIndex ? "" : separator),
+        formattedValue:
+          formattedKey +
+          formattedValue +
+          (index === valuesMaxIndex ? "" : formattedSeparator()),
+        // note: we need to format the separator for each values for browser-formatter
+      };
+    },
+  );
+
+  return {
+    stringValue:
+      prefix +
+      formattedValues
+        .map(
+          breakLine
+            ? (v) => `\n${padding}${v.stringValue}`
+            : (fv) => fv.stringValue,
+        )
+        .join(breakLine ? "\n" : " ") +
+      suffix,
+    formattedValue: `${prefix}${
+      breakLine ? "" : prefixSuffixSpace
+    }${formattedValues
+      .map(
+        breakLine
+          ? (v) => `\n${padding}${v.formattedValue}`
+          : (v) => v.formattedValue,
+      )
+      .join(breakLine ? "" : " ")}${
+      breakLine ? ",\n" : prefixSuffixSpace
+    }${suffix}`,
+  };
+};
+
+function internalFormatObject(
+  object: Record<string, unknown>,
+  styleFn: StyleFn,
+  objectStyles: ObjectStyles | undefined,
+  { padding, depth, maxDepth, objects }: InternalFormatParams,
+): FormattedValue {
+  if (objects.has(object)) {
+    return sameRawFormattedValue("{Circular Object}");
+  }
+
+  const keys: string[] = Object.keys(object);
+  if (keys.length === 0) {
+    return sameRawFormattedValue("{}");
+  }
+
+  objects.add(object);
+
+  const result = internalFormatIterator(
+    keys.map((key) => ({ key, value: object[key] })),
+    styleFn,
+    objectStyles,
+    { padding, depth, maxDepth, objects },
+    { prefix: "{", suffix: "}", formatKey: internalFormatKey },
+  );
+
+  objects.delete(object);
+
+  return result;
+}
+
+function internalFormatMap(
+  name: string,
+  map: Map<unknown, unknown>,
+  styleFn: StyleFn,
+  { padding, depth, maxDepth, objects }: InternalFormatParams,
+): FormattedValue {
+  if (objects.has(map)) {
+    return sameRawFormattedValue(`{Circular ${name}}`);
+  }
+
+  const keys = [...map.keys()];
+  if (keys.length === 0) {
+    return sameRawFormattedValue(`${name} {}`);
+  }
+
+  objects.add(map);
+
+  const result = internalFormatIterator(
+    keys.map((key) => ({ key, value: map.get(key) })),
+    styleFn,
+    undefined,
+    { padding, depth, maxDepth, objects },
+    { prefix: `${name} {`, suffix: "}", formatKey: internalFormatMapKey },
+  );
+
+  objects.delete(map);
+
+  return result;
+}
+
+function internalFormatArray(
+  array: unknown[],
+  styleFn: StyleFn,
+  { padding, depth, maxDepth, objects }: InternalFormatParams,
+): FormattedValue {
+  if (objects.has(array)) {
+    return sameRawFormattedValue("{Circular Array}");
+  }
+
+  if (array.length === 0) {
+    return sameRawFormattedValue("[]");
+  }
+
+  objects.add(array);
+
+  const result = internalFormatIterator(
+    array.map((value) => ({ key: undefined, value })),
+    styleFn,
+    undefined,
+    { padding, depth, maxDepth, objects },
+    {
+      prefix: "[",
+      suffix: "]",
+      prefixSuffixSpace: "",
+      formatKey: internalNoKey,
+    },
+  );
+
+  objects.delete(array);
+
+  return result;
+}
+
+function internalFormatSet(
+  name: string,
+  set: Set<unknown>,
+  styleFn: StyleFn,
+  { padding, depth, maxDepth, objects }: InternalFormatParams,
+): FormattedValue {
+  if (objects.has(set)) {
+    return sameRawFormattedValue(`{Circular ${name}}`);
+  }
+
+  const values = [...set.values()];
+  if (values.length === 0) {
+    return sameRawFormattedValue(`${name} []`);
+  }
+
+  objects.add(set);
+
+  const result = internalFormatIterator(
+    values.map((value) => ({ key: undefined, value })),
+    styleFn,
+    undefined,
+    { padding, depth, maxDepth, objects },
+    { prefix: `${name} [`, suffix: "]", formatKey: internalNoKey },
+  );
+
+  objects.delete(set);
+
+  return result;
+}
+
+export function formatObject(
+  object: Record<string, unknown>,
+  styleFn: StyleFn = noStyleFn,
+  objectStyles?: ObjectStyles,
+  { padding = "  ", maxDepth = 10 }: FormatObjectOptions = {},
+): string {
+  const { formattedValue: result } = internalFormatObject(
+    object,
+    styleFn,
+    objectStyles,
+    {
+      padding,
+      maxDepth,
+      depth: 0,
+      objects: new Set(),
+    },
+  );
+
+  if (result === "{}") {
+    return "";
+  }
+
+  return result;
+}

package/src/formatter-utils/formatRecordToString.ts

@@ -0,0 +1,67 @@
+import type { LogRecord, Metadata } from "nightingale-types";
+import type { ObjectStyles, StyleFn } from "./formatObject";
+import { formatObject } from "./formatObject";
+import { levelToStyles } from "./levelToStyles";
+import { levelToSymbol } from "./levelToSymbol";
+
+export function formatRecordToString<T extends Metadata>(
+  record: LogRecord<T>,
+  style: StyleFn,
+): string {
+  const parts: string[] = [];
+
+  if (record.displayName) {
+    parts.push(style(["gray-light"], record.displayName));
+  } else if (record.key) {
+    parts.push(style(["gray-light"], record.key));
+  }
+
+  if (record.datetime) {
+    parts.push(
+      style(["gray", "bold"], record.datetime.toTimeString().split(" ", 2)[0]!),
+    );
+    /* new Date().toFormat('HH24:MI:SS') */
+  }
+
+  let message: string = record.symbol || levelToSymbol[record.level] || "";
+  const styles = record.styles || levelToStyles[record.level];
+
+  if (record.message) {
+    if (message) {
+      message += ` ${record.message}`;
+    } else {
+      message = record.message;
+    }
+  }
+
+  if (message) {
+    if (styles) {
+      message = style(styles, message);
+    }
+    parts.push(message);
+  }
+
+  const formatRecordObject = (
+    key: string,
+    object: Record<string, unknown> | undefined,
+    objectStyles: ObjectStyles | undefined,
+  ): void => {
+    if (!object) {
+      return;
+    }
+
+    const stringObject = formatObject(object, style, objectStyles);
+
+    if (!stringObject) {
+      return;
+    }
+
+    parts.push(stringObject);
+  };
+
+  formatRecordObject("metadata", record.metadata, record.metadataStyles);
+  formatRecordObject("extra", record.extra, undefined);
+  formatRecordObject("context", record.context, undefined);
+
+  return parts.join(" ");
+}

package/src/formatter-utils/index.test.ts

@@ -0,0 +1,33 @@
+import {
+  formatObject,
+  formatRecordToString,
+  levelToStyles,
+  levelToSymbol,
+  styleToHexColor,
+  styleToHtmlStyleThemeDark,
+  styleToHtmlStyleThemeLight,
+} from ".";
+
+describe("test exports", () => {
+  test("levelToStyles", () => {
+    expect(typeof levelToStyles).toBe("object");
+  });
+  test("levelToSymbol", () => {
+    expect(typeof levelToSymbol).toBe("object");
+  });
+  test("styleToHtmlStyleThemeLight", () => {
+    expect(typeof styleToHtmlStyleThemeLight).toBe("object");
+  });
+  test("styleToHtmlStyleThemeDark", () => {
+    expect(typeof styleToHtmlStyleThemeDark).toBe("object");
+  });
+  test("styleToHexColor", () => {
+    expect(typeof styleToHexColor).toBe("object");
+  });
+  test("formatObject", () => {
+    expect(typeof formatObject).toBe("function");
+  });
+  test("formatRecordToString", () => {
+    expect(typeof formatRecordToString).toBe("function");
+  });
+});