nightingale 14.2.1 → 16.0.0

package/src/formatter-utils/index.ts

@@ -0,0 +1,20 @@
+import type { LogRecord, Metadata } from "nightingale-types";
+
+export { levelToStyles } from "./levelToStyles";
+export { levelToSymbol } from "./levelToSymbol";
+export {
+  styleToHtmlStyleThemeDark,
+  styleToHtmlStyleThemeLight,
+} from "./styleToHtmlStyle";
+export type { StyleToHtmlStyle } from "./styleToHtmlStyle";
+export { styleToHexColor } from "./styleToHexColor";
+export { formatObject } from "./formatObject";
+export { formatRecordToString } from "./formatRecordToString";
+
+export interface NightingaleFormatter {
+  format: <T extends Metadata>(record: LogRecord<T>) => string;
+}
+
+export interface StringArrayNightingaleFormatter {
+  format: <T extends Metadata>(record: LogRecord<T>) => string[];
+}

package/src/formatter-utils/levelToStyles.ts

@@ -0,0 +1,14 @@
+import { Level } from "nightingale-levels";
+
+export type LevelToStyles = Readonly<Record<number, string[]>>;
+
+export const levelToStyles: LevelToStyles = {
+  [Level.TRACE]: ["gray"],
+  [Level.DEBUG]: ["gray"],
+  // [Level.INFO]: ['gray'],
+  [Level.WARN]: ["yellow"],
+  [Level.ERROR]: ["red", "bold"],
+  [Level.CRITICAL]: ["red", "bold"],
+  [Level.FATAL]: ["bgRed", "white"],
+  [Level.EMERGENCY]: ["bgRed", "white"],
+};

package/src/formatter-utils/levelToSymbol.ts

@@ -0,0 +1,14 @@
+import { Level } from "nightingale-levels";
+
+export type LevelToSymbol = Readonly<Record<number, string>>;
+
+export const levelToSymbol: LevelToSymbol = {
+  [Level.TRACE]: "•",
+  [Level.DEBUG]: "•",
+  [Level.INFO]: "→",
+  [Level.WARN]: "⚠",
+  [Level.ERROR]: "✖",
+  [Level.CRITICAL]: "!",
+  [Level.FATAL]: "‼",
+  [Level.EMERGENCY]: "‼",
+};

package/src/formatter-utils/styleToHexColor.ts

@@ -0,0 +1,9 @@
+export const styleToHexColor = {
+  orange: "ff5f00",
+  grayLight: "808080",
+  "gray-light": "808080",
+} as const;
+
+export type StyleToHexColor = Readonly<
+  Record<keyof typeof styleToHexColor, string>
+>;

package/src/formatter-utils/styleToHtmlStyle.ts

@@ -0,0 +1,69 @@
+import { styleToHexColor } from "./styleToHexColor";
+
+export interface HtmlStyle {
+  readonly open: string;
+  readonly close: string;
+}
+
+export const styleToHtmlStyleThemeLight = {
+  // text style
+  bold: { open: "font-weight: bold", close: "font-weight: normal" },
+  italic: { open: "font-style: italic", close: "font-style: normal" },
+  underline: {
+    open: "text-decoration: underline",
+    close: "text-decoration: none",
+  },
+  inverse: {
+    open: "unicode-bidi: bidi-override; direction: rtl",
+    close: "unicode-bidi: normal; direction: ltr",
+  },
+  strikethrough: {
+    open: "text-decoration: line-through",
+    close: "text-decoration: none",
+  },
+
+  black: { open: "color: black", close: "color: currentcolor" },
+  red: { open: "color: #ff0020", close: "color: currentcolor" },
+  green: { open: "color: #00b317", close: "color: currentcolor" },
+  yellow: { open: "color: #ffcc00", close: "color: currentcolor" },
+  blue: { open: "color: #00a0ff", close: "color: currentcolor" },
+  magenta: { open: "color: #ff00a0", close: "color: currentcolor" },
+  cyan: { open: "color: #00cfd8", close: "color: currentcolor" },
+  white: { open: "color: white", close: "color: currentcolor" },
+  gray: { open: "color: gray", close: "color: currentcolor" },
+
+  bgBlack: { open: "background: black", close: "background: initial" },
+  bgRed: { open: "background: #ff0020", close: "background: initial" },
+  bgGreen: { open: "background: #00b317", close: "background: initial" },
+  bgYellow: { open: "background: #ffcc00", close: "background: initial" },
+  bgBlue: { open: "background: #00a0ff", close: "background: initial" },
+  bgMagenta: { open: "background: #ff00a0", close: "background: initial" },
+  bgCyan: { open: "background: #00cfd8", close: "background: initial" },
+  bgWhite: { open: "background: white", close: "background: initial" },
+
+  orange: {
+    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<
+  Record<keyof typeof styleToHtmlStyleThemeLight, HtmlStyle>
+>;
+
+export const styleToHtmlStyleThemeDark: StyleToHtmlStyle = {
+  ...styleToHtmlStyleThemeLight,
+  black: styleToHtmlStyleThemeLight.white,
+  bgBlack: styleToHtmlStyleThemeLight.bgWhite,
+  white: styleToHtmlStyleThemeLight.black,
+  bgWhite: styleToHtmlStyleThemeLight.bgBlack,
+  gray: { open: "color: lightgray", close: "color: currentcolor" },
+};

package/src/formatters/ANSIFormatter.test.ts

@@ -0,0 +1,27 @@
+/* eslint-disable no-control-regex */
+import { ANSIFormatter, style } from "./ANSIFormatter";
+
+test("style: blue bold color", () => {
+  expect(style(["blue", "bold"], "test").replace(/\u001B/g, "ESC")).toBe(
+    "ESC[1mESC[34mtestESC[39mESC[22m",
+  );
+});
+
+test("style: ansi256 color", () => {
+  expect(style(["orange"], "test").replace(/\u001B/g, "ESC")).toBe(
+    "ESC[38;5;208mtestESC[39m",
+  );
+});
+
+test("format simple message", () => {
+  expect(
+    ANSIFormatter.format({
+      key: "test",
+      level: 100,
+      message: "test",
+      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",
+  );
+});

package/src/formatters/ANSIFormatter.ts

@@ -0,0 +1,68 @@
+import ansi from "ansi-styles";
+import type { NightingaleFormatter } from "nightingale";
+import type { Styles } from "nightingale-types";
+import { formatRecordToString, styleToHexColor } from "../formatter-utils";
+
+export type { Styles } from "nightingale-types";
+
+interface CodePair {
+  open: string;
+  close: string;
+}
+
+type AnsiStyles = Record<string, CodePair | undefined>;
+
+const ansiStyles: AnsiStyles = {
+  black: ansi.black,
+  red: ansi.red,
+  green: ansi.green,
+  yellow: ansi.yellow,
+  blue: ansi.blue,
+  magenta: ansi.magenta,
+  cyan: ansi.cyan,
+  white: ansi.white,
+  gray: ansi.gray,
+
+  bgBlack: ansi.bgBlack,
+  bgRed: ansi.bgRed,
+  bgGreen: ansi.bgGreen,
+  bgYellow: ansi.bgYellow,
+  bgBlue: ansi.bgBlue,
+  bgMagenta: ansi.bgMagenta,
+  bgCyan: ansi.bgCyan,
+  bgWhite: ansi.bgWhite,
+
+  bold: ansi.bold,
+  underline: ansi.underline,
+
+  // http://www.calmar.ws/vim/256-xterm-24bit-rgb-color-chart.html
+  orange: {
+    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 {
+  if (!styles || styles.length === 0 || !string) {
+    return string;
+  }
+
+  // eslint-disable-next-line unicorn/no-array-reduce
+  return styles.reduce((styledString: string, styleName: string) => {
+    const codePair: CodePair | undefined = ansiStyles[styleName];
+
+    if (!codePair) {
+      throw new Error(`Unknown style: ${styleName}`);
+    }
+
+    return codePair.open + styledString + codePair.close;
+  }, string);
+}
+
+export const ANSIFormatter: NightingaleFormatter = {
+  format: (record) => formatRecordToString(record, style),
+};

package/src/formatters/BrowserConsoleFormatter.test.ts

@@ -0,0 +1,59 @@
+import type { StyleToHtmlStyle } from "nightingale";
+import { Level } from "nightingale-levels";
+import { styleToHtmlStyleThemeLight } from "../formatter-utils";
+import { BrowserConsoleFormatter, style } from "./BrowserConsoleFormatter";
+
+const styleToHtmlStyle: StyleToHtmlStyle = styleToHtmlStyleThemeLight;
+const formatterWithLightTheme = new BrowserConsoleFormatter("light");
+const formatterWithDarkTheme = new BrowserConsoleFormatter("dark");
+
+test("style: blue bold color", () => {
+  const args: string[] = [];
+  expect(style(styleToHtmlStyle, args)(["blue", "bold"], "test")).toBe(
+    "%ctest%c",
+  );
+  expect(args).toEqual([
+    "color: #00a0ff; font-weight: bold",
+    "color: currentcolor; font-weight: normal",
+  ]);
+});
+
+test("format simple message, with light theme", () => {
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "test",
+    metadata: {},
+    extra: {},
+  };
+
+  const [string, ...args] = formatterWithLightTheme.format(record);
+  expect(string).toBe("%crecord.key%c %c01:00:00%c → test");
+  expect(args).toEqual([
+    "color: #808080",
+    "color: currentcolor",
+    "color: gray; font-weight: bold",
+    "color: currentcolor; font-weight: normal",
+  ]);
+});
+
+test("format simple message, with dark theme", () => {
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "test",
+    metadata: {},
+    extra: {},
+  };
+
+  const [string, ...args] = formatterWithDarkTheme.format(record);
+  expect(string).toBe("%crecord.key%c %c01:00:00%c → test");
+  expect(args).toEqual([
+    "color: #808080",
+    "color: currentcolor",
+    "color: lightgray; font-weight: bold",
+    "color: currentcolor; font-weight: normal",
+  ]);
+});

package/src/formatters/BrowserConsoleFormatter.ts

@@ -0,0 +1,45 @@
+import type { StyleToHtmlStyle } from "nightingale";
+import type { LogRecord, Metadata, Styles } from "nightingale-types";
+import {
+  formatRecordToString,
+  styleToHtmlStyleThemeDark,
+  styleToHtmlStyleThemeLight,
+} from "../formatter-utils";
+import type { StringArrayNightingaleFormatter } from "../formatter-utils";
+
+export const style =
+  (styleToHtmlStyle: StyleToHtmlStyle, args: string[]) =>
+  (styles: Styles, string: string): string => {
+    if (!styles || styles.length === 0 || !string) {
+      return string;
+    }
+
+    const htmlStyles = styles.map(
+      (styleName) => styleToHtmlStyle[styleName as keyof StyleToHtmlStyle],
+    );
+
+    args.push(
+      htmlStyles.map((s) => s.open).join("; "),
+      htmlStyles.map((s) => s.close).join("; "),
+    );
+    return `%c${string}%c`;
+  };
+
+export class BrowserConsoleFormatter
+  implements StringArrayNightingaleFormatter
+{
+  styleToHtmlStyle: StyleToHtmlStyle;
+  constructor(theme: "dark" | "light" = "light") {
+    this.styleToHtmlStyle =
+      theme === "dark" ? styleToHtmlStyleThemeDark : styleToHtmlStyleThemeLight;
+  }
+
+  format<T extends Metadata>(record: LogRecord<T>): string[] {
+    const args: string[] = [];
+    const string = formatRecordToString(
+      record,
+      style(this.styleToHtmlStyle, args),
+    );
+    return [string, ...args];
+  }
+}

package/src/formatters/HTMLFormatter.test.ts

@@ -0,0 +1,23 @@
+import { Level } from "nightingale-levels";
+import { HTMLFormatter, style } from "./HTMLFormatter";
+
+test("blue bold color", () => {
+  expect(style(["blue", "bold"], "test")).toBe(
+    '<span style="color: #00a0ff; font-weight: bold">test</span>',
+  );
+});
+
+test("format simple message", () => {
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "record.message",
+    metadata: {},
+    extra: {},
+  };
+
+  expect(HTMLFormatter.format(record)).toBe(
+    '<span style="color: #808080">record.key</span> <span style="color: gray; font-weight: bold">01:00:00</span> → record.message',
+  );
+});

package/src/formatters/HTMLFormatter.ts

@@ -0,0 +1,28 @@
+import type { Styles } from "nightingale-types";
+import type {
+  NightingaleFormatter,
+  StyleToHtmlStyle,
+} from "../formatter-utils";
+import {
+  formatRecordToString,
+  styleToHtmlStyleThemeLight,
+} from "../formatter-utils";
+
+export function style(styles: Styles, string: string): string {
+  if (!styles || styles.length === 0 || !string) {
+    return string;
+  }
+
+  return `<span style="${styles
+    .map(
+      (styleName) =>
+        styleToHtmlStyleThemeLight[styleName as keyof StyleToHtmlStyle].open,
+    )
+    .join("; ")}">${string}</span>`;
+}
+
+export const HTMLFormatter: NightingaleFormatter = {
+  format(record) {
+    return formatRecordToString(record, style);
+  },
+};

package/src/formatters/JSONFormatter.test.ts

@@ -0,0 +1,62 @@
+import { Level } from "nightingale-levels";
+import { JSONFormatter } from "./JSONFormatter";
+
+test("format record", () => {
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "record.message",
+    metadata: {},
+    extra: {},
+  };
+
+  expect(JSONFormatter.format(record)).toBe(JSON.stringify(record));
+});
+
+test("format error", () => {
+  const error = new Error("test message");
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "record.message",
+    metadata: {
+      error,
+    },
+    extra: {},
+  };
+
+  expect(JSONFormatter.format(record)).toBe(
+    JSON.stringify({
+      ...record,
+      metadata: { error: { message: "test message", stack: error.stack } },
+    }),
+  );
+});
+
+test("format map", () => {
+  const map = new Map<unknown, unknown>([
+    [1, "value1"],
+    ["2", "value2"],
+    ["3", 3],
+    [{}, "ignore value"],
+  ]);
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "record.message",
+    metadata: {
+      map,
+    },
+    extra: {},
+  };
+
+  expect(JSONFormatter.format(record)).toBe(
+    JSON.stringify({
+      ...record,
+      metadata: { map: { "1": "value1", "2": "value2", "3": 3 } },
+    }),
+  );
+});

package/src/formatters/JSONFormatter.ts

@@ -0,0 +1,62 @@
+import type { NightingaleFormatter } from "../formatter-utils";
+
+function map2object(map: Map<unknown, unknown>): unknown {
+  const object: Record<string, unknown> = {};
+
+  map.forEach((value, key) => {
+    if (typeof key === "object") {
+      // ignore key
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    object[String(key)] = value;
+  });
+
+  return object;
+}
+
+function stringify(value: unknown, space?: number | string): string {
+  return JSON.stringify(
+    value,
+    (key, objectValue) => {
+      if (objectValue instanceof Map) {
+        return map2object(objectValue);
+      }
+      if (objectValue instanceof Error) {
+        return {
+          message: objectValue.message,
+          stack: objectValue.stack,
+        };
+      }
+
+      return objectValue as unknown;
+    },
+    space,
+  );
+}
+
+export const JSONFormatter: NightingaleFormatter = {
+  format(record) {
+    return stringify({
+      key: record.key,
+      level: record.level,
+      datetime: record.datetime,
+      message: record.message,
+      metadata: record.metadata,
+      extra: record.extra,
+    });
+  },
+};
+
+export const JSONCLIFormatter: NightingaleFormatter = {
+  format(record) {
+    return stringify({
+      key: record.key,
+      time: record.datetime.toTimeString().split(" ", 2)[0]!,
+      message: record.message,
+      ...record.metadata,
+      ...record.extra,
+    });
+  },
+};

package/src/formatters/MarkdownFormatter.test.ts

@@ -0,0 +1,19 @@
+import { Level } from "nightingale-levels";
+import { MarkdownFormatter, style } from "./MarkdownFormatter";
+
+test("style: blue bold color", () => {
+  expect(style(["blue", "bold"], "test")).toBe("*test*");
+});
+
+test("format simple message", () => {
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "test",
+    metadata: {},
+    extra: {},
+  };
+
+  expect(MarkdownFormatter.format(record)).toBe("record.key *01:00:00* → test");
+});

package/src/formatters/MarkdownFormatter.ts

@@ -0,0 +1,31 @@
+import type { Styles } from "nightingale-types";
+import type { NightingaleFormatter } from "../formatter-utils";
+import { formatRecordToString } from "../formatter-utils";
+
+export function style(styles: Styles, string: string): string {
+  if (!styles || styles.length === 0 || !string) {
+    return string;
+  }
+
+  // eslint-disable-next-line unicorn/no-array-reduce
+  return styles.reduce((part, styleName) => {
+    switch (styleName) {
+      case "bold":
+        return `*${part}*`;
+      case "italic":
+        return `_${part}_`;
+      case "strikethrough":
+        return `~${part}~`;
+
+      // no default
+    }
+
+    return part;
+  }, string);
+}
+
+export const MarkdownFormatter: NightingaleFormatter = {
+  format(record) {
+    return formatRecordToString(record, style);
+  },
+};

package/src/formatters/RawFormatter.test.ts

@@ -0,0 +1,21 @@
+import { Level } from "nightingale-levels";
+import { RawFormatter, style } from "./RawFormatter";
+
+test("style: blue bold color", () => {
+  expect(style(["blue", "bold"], "test")).toBe("test");
+});
+
+test("format simple message", () => {
+  const record = {
+    key: "record.key",
+    level: Level.INFO,
+    datetime: new Date(2000, 1, 1, 1, 0, 0),
+    message: "record.message",
+    metadata: {},
+    extra: {},
+  };
+
+  expect(RawFormatter.format(record)).toBe(
+    "record.key 01:00:00 → record.message",
+  );
+});

package/src/formatters/RawFormatter.ts

@@ -0,0 +1,13 @@
+import type { Styles } from "nightingale-types";
+import type { NightingaleFormatter } from "../formatter-utils";
+import { formatRecordToString } from "../formatter-utils";
+
+export function style(styles: Styles, value: string): string {
+  return value;
+}
+
+export const RawFormatter: NightingaleFormatter = {
+  format(record) {
+    return formatRecordToString(record, style);
+  },
+};

package/src/handlers/BrowserConsoleHandler.ts

@@ -0,0 +1,78 @@
+import type {
+  Handle,
+  Handler,
+  IsHandling,
+  Level,
+  LogRecord,
+  Metadata,
+} from "nightingale-types";
+import { createFindDebugLevel } from "../debug/debug";
+import { BrowserConsoleFormatter } from "../formatters/BrowserConsoleFormatter";
+import { consoleOutput } from "../outputs/consoleOutput";
+
+export function getDebugString(): string {
+  const querystring = document.location.search;
+  const debugFromLocalStorage =
+    // eslint-disable-next-line unicorn/prefer-global-this, @typescript-eslint/no-unnecessary-condition
+    window.localStorage?.getItem("debug") || "";
+
+  if (!querystring) {
+    return debugFromLocalStorage;
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/URLUtils/search#Get_the_value_of_a_single_search_param
+  const debugFromQueryString = decodeURI(
+    querystring.replace(
+      // eslint-disable-next-line prefer-regex-literals, regexp/no-super-linear-backtracking
+      new RegExp("^(?:.*[&?]DEBUG(?:=([^&]*))?)?.*$", "i"),
+      "$1",
+    ),
+  );
+
+  return (
+    (debugFromLocalStorage ? `${debugFromLocalStorage},` : "") +
+    debugFromQueryString
+  );
+}
+
+// debug string can change any time (localStorage), so we need a new object each time.
+const findDebugLevel = (minLevel: Level, key: string): Level =>
+  createFindDebugLevel(getDebugString())(minLevel, key);
+
+type Theme = "dark" | "light";
+
+const getDefaultTheme = (): Theme => {
+  try {
+    const configInLocalStorage = localStorage.getItem("NIGHTINGALE_THEME");
+    if (configInLocalStorage && configInLocalStorage === "dark") {
+      return configInLocalStorage;
+    }
+  } catch {}
+  return "light";
+};
+
+const createHandler = (theme: Theme = getDefaultTheme()): Handle => {
+  const browserConsoleFormatter = new BrowserConsoleFormatter(theme);
+  return <T extends Metadata>(record: LogRecord<T>) => {
+    consoleOutput(browserConsoleFormatter.format(record), record);
+  };
+};
+
+export interface BrowserConsoleHandlerOptions {
+  theme?: Theme;
+}
+
+export class BrowserConsoleHandler implements Handler {
+  minLevel: Level = 0;
+
+  handle: Handle;
+
+  isHandling: IsHandling;
+
+  constructor(minLevel: Level, options: BrowserConsoleHandlerOptions = {}) {
+    this.isHandling = (level: Level, key: string) =>
+      level >= findDebugLevel(minLevel, key);
+
+    this.handle = createHandler(options.theme);
+  }
+}