@logtape/logtape 0.11.0-dev.175 → 0.12.0-dev.181

package/mod.ts

@@ -0,0 +1,54 @@
+export {
+  type Config,
+  ConfigError,
+  configure,
+  configureSync,
+  dispose,
+  disposeSync,
+  getConfig,
+  type LoggerConfig,
+  reset,
+  resetSync,
+} from "./config.ts";
+export { type ContextLocalStorage, withContext } from "./context.ts";
+export {
+  type Filter,
+  type FilterLike,
+  getLevelFilter,
+  toFilter,
+} from "./filter.ts";
+export {
+  type AnsiColor,
+  ansiColorFormatter,
+  type AnsiColorFormatterOptions,
+  type AnsiStyle,
+  type ConsoleFormatter,
+  defaultConsoleFormatter,
+  defaultTextFormatter,
+  type FormattedValues,
+  getAnsiColorFormatter,
+  getJsonLinesFormatter,
+  getTextFormatter,
+  jsonLinesFormatter,
+  type JsonLinesFormatterOptions,
+  type TextFormatter,
+  type TextFormatterOptions,
+} from "./formatter.ts";
+export {
+  compareLogLevel,
+  isLogLevel,
+  type LogLevel,
+  parseLogLevel,
+} from "./level.ts";
+export { getLogger, type Logger } from "./logger.ts";
+export type { LogRecord } from "./record.ts";
+export {
+  type ConsoleSinkOptions,
+  getConsoleSink,
+  getStreamSink,
+  type Sink,
+  type StreamSinkOptions,
+  withFilter,
+} from "./sink.ts";
+
+// cSpell: ignore filesink

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@logtape/logtape",
-  "version": "0.11.0-dev.175+f9a2339c",
+  "version": "0.12.0-dev.181+e4f33b9d",
   "description": "Simple logging library with zero dependencies for Deno/Node.js/Bun/browsers",
   "keywords": [
     "logging",
     "log",
     "logger"
   ],
+  "license": "MIT",
   "author": {
     "name": "Hong Minhee",
     "email": "hong@minhee.org",
@@ -18,36 +19,47 @@
     "url": "git+https://github.com/dahlia/logtape.git",
     "directory": "logtape/"
   },
-  "license": "MIT",
   "bugs": {
     "url": "https://github.com/dahlia/logtape/issues"
   },
-  "main": "./script/mod.js",
-  "module": "./esm/mod.js",
-  "types": "./types/mod.d.ts",
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/mod.d.ts",
-        "default": "./esm/mod.js"
-      },
-      "require": {
-        "types": "./types/mod.d.ts",
-        "default": "./script/mod.js"
-      }
-    }
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs",
+      "types": "./dist/mod.d.ts"
+    },
+    "./package.json": "./package.json"
   },
-  "scripts": {
-    "test": "node test_runner.js"
+  "imports": {
+    "#util": {
+      "node": "./dist/util.node.cjs",
+      "bun": "./dist/util.node.js",
+      "deno": "./dist/util.deno.js",
+      "import": "./dist/util.mjs",
+      "require": "./dist/util.js",
+      "types": "./dist/util.d.mts"
+    }
   },
-  "funding": [
-    "https://github.com/sponsors/dahlia"
-  ],
   "devDependencies": {
-    "@types/node": "^20.9.0",
-    "picocolors": "^1.0.0",
+    "@hongminhee/suite": "^0.6.2",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "@std/async": "npm:@jsr/std__async@^1.0.13",
     "consolemock": "^1.1.0",
-    "@deno/shim-deno": "~0.18.0"
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
   },
-  "_generatedBy": "dnt@dev"
+  "scripts": {
+    "build": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
 }

package/record.ts

@@ -0,0 +1,49 @@
+import type { LogLevel } from "./level.ts";
+
+/**
+ * A log record.
+ */
+export interface LogRecord {
+  /**
+   * The category of the logger that produced the log record.
+   */
+  readonly category: readonly string[];
+
+  /**
+   * The log level.
+   */
+  readonly level: LogLevel;
+
+  /**
+   * The log message.  This is the result of substituting the message template
+   * with the values.  The number of elements in this array is always odd,
+   * with the message template values interleaved between the substitution
+   * values.
+   */
+  readonly message: readonly unknown[];
+
+  /**
+   * The raw log message.  This is the original message template without any
+   * further processing.  It can be either:
+   *
+   * - A string without any substitutions if the log record was created with
+   *   a method call syntax, e.g., "Hello, {name}!" for
+   *   `logger.info("Hello, {name}!", { name })`.
+   * - A template string array if the log record was created with a tagged
+   *   template literal syntax, e.g., `["Hello, ", "!"]` for
+   *   ``logger.info`Hello, ${name}!```.
+   *
+   * @since 0.6.0
+   */
+  readonly rawMessage: string | TemplateStringsArray;
+
+  /**
+   * The timestamp of the log record in milliseconds since the Unix epoch.
+   */
+  readonly timestamp: number;
+
+  /**
+   * The extra properties of the log record.
+   */
+  readonly properties: Record<string, unknown>;
+}

package/sink.test.ts

@@ -0,0 +1,219 @@
+import { suite } from "@hongminhee/suite";
+import { assertEquals } from "@std/assert/equals";
+import { assertThrows } from "@std/assert/throws";
+import makeConsoleMock from "consolemock";
+import { debug, error, fatal, info, warning } from "./fixtures.ts";
+import { defaultTextFormatter } from "./formatter.ts";
+import type { LogLevel } from "./level.ts";
+import type { LogRecord } from "./record.ts";
+import { getConsoleSink, getStreamSink, withFilter } from "./sink.ts";
+
+const test = suite(import.meta);
+
+test("withFilter()", () => {
+  const buffer: LogRecord[] = [];
+  const sink = withFilter(buffer.push.bind(buffer), "warning");
+  sink(debug);
+  sink(info);
+  sink(warning);
+  sink(error);
+  sink(fatal);
+  assertEquals(buffer, [warning, error, fatal]);
+});
+
+interface ConsoleMock extends Console {
+  history(): unknown[];
+}
+
+test("getStreamSink()", async () => {
+  let buffer: string = "";
+  const decoder = new TextDecoder();
+  const sink = getStreamSink(
+    new WritableStream({
+      write(chunk: Uint8Array) {
+        buffer += decoder.decode(chunk);
+        return Promise.resolve();
+      },
+    }),
+  );
+  sink(debug);
+  sink(info);
+  sink(warning);
+  sink(error);
+  sink(fatal);
+  await sink[Symbol.asyncDispose]();
+  assertEquals(
+    buffer,
+    `\
+2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [ERR] my-app·junk: Hello, 123 & 456!
+2023-11-14 22:13:20.000 +00:00 [FTL] my-app·junk: Hello, 123 & 456!
+`,
+  );
+});
+
+test("getConsoleSink()", () => {
+  // @ts-ignore: consolemock is not typed
+  const mock: ConsoleMock = makeConsoleMock();
+  const sink = getConsoleSink({ console: mock });
+  sink(debug);
+  sink(info);
+  sink(warning);
+  sink(error);
+  sink(fatal);
+  assertEquals(mock.history(), [
+    {
+      DEBUG: [
+        "%c22:13:20.000 %cDBG%c %cmy-app·junk %cHello, %o & %o!",
+        "color: gray;",
+        "background-color: gray; color: white;",
+        "background-color: default;",
+        "color: gray;",
+        "color: default;",
+        123,
+        456,
+      ],
+    },
+    {
+      INFO: [
+        "%c22:13:20.000 %cINF%c %cmy-app·junk %cHello, %o & %o!",
+        "color: gray;",
+        "background-color: white; color: black;",
+        "background-color: default;",
+        "color: gray;",
+        "color: default;",
+        123,
+        456,
+      ],
+    },
+    {
+      WARN: [
+        "%c22:13:20.000 %cWRN%c %cmy-app·junk %cHello, %o & %o!",
+        "color: gray;",
+        "background-color: orange; color: black;",
+        "background-color: default;",
+        "color: gray;",
+        "color: default;",
+        123,
+        456,
+      ],
+    },
+    {
+      ERROR: [
+        "%c22:13:20.000 %cERR%c %cmy-app·junk %cHello, %o & %o!",
+        "color: gray;",
+        "background-color: red; color: white;",
+        "background-color: default;",
+        "color: gray;",
+        "color: default;",
+        123,
+        456,
+      ],
+    },
+    {
+      ERROR: [
+        "%c22:13:20.000 %cFTL%c %cmy-app·junk %cHello, %o & %o!",
+        "color: gray;",
+        "background-color: maroon; color: white;",
+        "background-color: default;",
+        "color: gray;",
+        "color: default;",
+        123,
+        456,
+      ],
+    },
+  ]);
+
+  assertThrows(
+    () => sink({ ...info, level: "invalid" as LogLevel }),
+    TypeError,
+    "Invalid log level: invalid.",
+  );
+
+  // @ts-ignore: consolemock is not typed
+  const mock2: ConsoleMock = makeConsoleMock();
+  const sink2 = getConsoleSink({
+    console: mock2,
+    formatter: defaultTextFormatter,
+  });
+  sink2(debug);
+  sink2(info);
+  sink2(warning);
+  sink2(error);
+  sink2(fatal);
+  assertEquals(mock2.history(), [
+    {
+      DEBUG: [
+        "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      INFO: [
+        "2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      WARN: [
+        "2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      ERROR: [
+        "2023-11-14 22:13:20.000 +00:00 [ERR] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      ERROR: [
+        "2023-11-14 22:13:20.000 +00:00 [FTL] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+  ]);
+
+  // @ts-ignore: consolemock is not typed
+  const mock3: ConsoleMock = makeConsoleMock();
+  const sink3 = getConsoleSink({
+    console: mock3,
+    levelMap: {
+      debug: "log",
+      info: "log",
+      warning: "log",
+      error: "log",
+      fatal: "log",
+    },
+    formatter: defaultTextFormatter,
+  });
+  sink3(debug);
+  sink3(info);
+  sink3(warning);
+  sink3(error);
+  sink3(fatal);
+  assertEquals(mock3.history(), [
+    {
+      LOG: [
+        "2023-11-14 22:13:20.000 +00:00 [DBG] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      LOG: [
+        "2023-11-14 22:13:20.000 +00:00 [INF] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      LOG: [
+        "2023-11-14 22:13:20.000 +00:00 [WRN] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      LOG: [
+        "2023-11-14 22:13:20.000 +00:00 [ERR] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+    {
+      LOG: [
+        "2023-11-14 22:13:20.000 +00:00 [FTL] my-app·junk: Hello, 123 & 456!",
+      ],
+    },
+  ]);
+});

package/sink.ts

@@ -0,0 +1,167 @@
+import { type FilterLike, toFilter } from "./filter.ts";
+import {
+  type ConsoleFormatter,
+  defaultConsoleFormatter,
+  defaultTextFormatter,
+  type TextFormatter,
+} from "./formatter.ts";
+import type { LogLevel } from "./level.ts";
+import type { LogRecord } from "./record.ts";
+
+/**
+ * A sink is a function that accepts a log record and prints it somewhere.
+ * Thrown exceptions will be suppressed and then logged to the meta logger,
+ * a {@link Logger} with the category `["logtape", "meta"]`.  (In that case,
+ * the meta log record will not be passed to the sink to avoid infinite
+ * recursion.)
+ *
+ * @param record The log record to sink.
+ */
+export type Sink = (record: LogRecord) => void;
+
+/**
+ * Turns a sink into a filtered sink.  The returned sink only logs records that
+ * pass the filter.
+ *
+ * @example Filter a console sink to only log records with the info level
+ * ```typescript
+ * const sink = withFilter(getConsoleSink(), "info");
+ * ```
+ *
+ * @param sink A sink to be filtered.
+ * @param filter A filter to apply to the sink.  It can be either a filter
+ *               function or a {@link LogLevel} string.
+ * @returns A sink that only logs records that pass the filter.
+ */
+export function withFilter(sink: Sink, filter: FilterLike): Sink {
+  const filterFunc = toFilter(filter);
+  return (record: LogRecord) => {
+    if (filterFunc(record)) sink(record);
+  };
+}
+
+/**
+ * Options for the {@link getStreamSink} function.
+ */
+export interface StreamSinkOptions {
+  /**
+   * The text formatter to use.  Defaults to {@link defaultTextFormatter}.
+   */
+  formatter?: TextFormatter;
+
+  /**
+   * The text encoder to use.  Defaults to an instance of {@link TextEncoder}.
+   */
+  encoder?: { encode(text: string): Uint8Array };
+}
+
+/**
+ * A factory that returns a sink that writes to a {@link WritableStream}.
+ *
+ * Note that the `stream` is of Web Streams API, which is different from
+ * Node.js streams.  You can convert a Node.js stream to a Web Streams API
+ * stream using [`stream.Writable.toWeb()`] method.
+ *
+ * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable
+ *
+ * @example Sink to the standard error in Deno
+ * ```typescript
+ * const stderrSink = getStreamSink(Deno.stderr.writable);
+ * ```
+ *
+ * @example Sink to the standard error in Node.js
+ * ```typescript
+ * import stream from "node:stream";
+ * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));
+ * ```
+ *
+ * @param stream The stream to write to.
+ * @param options The options for the sink.
+ * @returns A sink that writes to the stream.
+ */
+export function getStreamSink(
+  stream: WritableStream,
+  options: StreamSinkOptions = {},
+): Sink & AsyncDisposable {
+  const formatter = options.formatter ?? defaultTextFormatter;
+  const encoder = options.encoder ?? new TextEncoder();
+  const writer = stream.getWriter();
+  let lastPromise = Promise.resolve();
+  const sink: Sink & AsyncDisposable = (record: LogRecord) => {
+    const bytes = encoder.encode(formatter(record));
+    lastPromise = lastPromise
+      .then(() => writer.ready)
+      .then(() => writer.write(bytes));
+  };
+  sink[Symbol.asyncDispose] = async () => {
+    await lastPromise;
+    await writer.close();
+  };
+  return sink;
+}
+
+type ConsoleMethod = "debug" | "info" | "log" | "warn" | "error";
+
+/**
+ * Options for the {@link getConsoleSink} function.
+ */
+export interface ConsoleSinkOptions {
+  /**
+   * The console formatter or text formatter to use.
+   * Defaults to {@link defaultConsoleFormatter}.
+   */
+  formatter?: ConsoleFormatter | TextFormatter;
+
+  /**
+   * The mapping from log levels to console methods.  Defaults to:
+   *
+   * ```typescript
+   * {
+   *   debug: "debug",
+   *   info: "info",
+   *   warning: "warn",
+   *   error: "error",
+   *   fatal: "error",
+   * }
+   * ```
+   * @since 0.9.0
+   */
+  levelMap?: Record<LogLevel, ConsoleMethod>;
+
+  /**
+   * The console to log to.  Defaults to {@link console}.
+   */
+  console?: Console;
+}
+
+/**
+ * A console sink factory that returns a sink that logs to the console.
+ *
+ * @param options The options for the sink.
+ * @returns A sink that logs to the console.
+ */
+export function getConsoleSink(options: ConsoleSinkOptions = {}): Sink {
+  const formatter = options.formatter ?? defaultConsoleFormatter;
+  const levelMap: Record<LogLevel, ConsoleMethod> = {
+    debug: "debug",
+    info: "info",
+    warning: "warn",
+    error: "error",
+    fatal: "error",
+    ...(options.levelMap ?? {}),
+  };
+  const console = options.console ?? globalThis.console;
+  return (record: LogRecord) => {
+    const args = formatter(record);
+    const method = levelMap[record.level];
+    if (method === undefined) {
+      throw new TypeError(`Invalid log level: ${record.level}.`);
+    }
+    if (typeof args === "string") {
+      const msg = args.replace(/\r?\n$/, "");
+      console[method](msg);
+    } else {
+      console[method](...args);
+    }
+  };
+}

package/tsdown.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["mod.ts", "util.ts", "util.deno.ts", "util.node.ts"],
+  dts: {
+    sourcemap: true,
+  },
+  format: ["esm", "cjs"],
+  platform: "neutral",
+  unbundle: true,
+  inputOptions: {
+    onLog(level, log, defaultHandler) {
+      if (
+        level === "warn" && log.code === "UNRESOLVED_IMPORT" &&
+        ["node:async_hooks", "node:util", "consolemock", "#util"].includes(
+          log.exporter ?? "",
+        )
+      ) {
+        return;
+      }
+      defaultHandler(level, log);
+    },
+  },
+});

package/util.deno.ts

@@ -0,0 +1,19 @@
+export interface InspectOptions {
+  colors?: boolean;
+  depth?: number | null;
+  compact?: boolean;
+  [key: string]: unknown;
+}
+
+export function inspect(obj: unknown, options?: InspectOptions): string {
+  if ("Deno" in globalThis) {
+    return Deno.inspect(obj, {
+      colors: options?.colors,
+      depth: options?.depth ?? undefined,
+      compact: options?.compact ?? true,
+    });
+  } else {
+    const indent = options?.compact === true ? undefined : 2;
+    return JSON.stringify(obj, null, indent);
+  }
+}

package/util.node.ts

@@ -0,0 +1,12 @@
+import util from "node:util";
+
+export interface InspectOptions {
+  colors?: boolean;
+  depth?: number | null;
+  compact?: boolean;
+  [key: string]: unknown;
+}
+
+export function inspect(obj: unknown, options?: InspectOptions): string {
+  return util.inspect(obj, options);
+}

package/util.ts

@@ -0,0 +1,11 @@
+export interface InspectOptions {
+  colors?: boolean;
+  depth?: number | null;
+  compact?: boolean;
+  [key: string]: unknown;
+}
+
+export function inspect(obj: unknown, options?: InspectOptions): string {
+  const indent = options?.compact === true ? undefined : 2;
+  return JSON.stringify(obj, null, indent);
+}

package/esm/_dnt.shims.js

@@ -1,57 +0,0 @@
-const dntGlobals = {};
-export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-function createMergeProxy(baseObj, extObj) {
-    return new Proxy(baseObj, {
-        get(_target, prop, _receiver) {
-            if (prop in extObj) {
-                return extObj[prop];
-            }
-            else {
-                return baseObj[prop];
-            }
-        },
-        set(_target, prop, value) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            baseObj[prop] = value;
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            let success = false;
-            if (prop in extObj) {
-                delete extObj[prop];
-                success = true;
-            }
-            if (prop in baseObj) {
-                delete baseObj[prop];
-                success = true;
-            }
-            return success;
-        },
-        ownKeys(_target) {
-            const baseKeys = Reflect.ownKeys(baseObj);
-            const extKeys = Reflect.ownKeys(extObj);
-            const extKeysSet = new Set(extKeys);
-            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
-        },
-        defineProperty(_target, prop, desc) {
-            if (prop in extObj) {
-                delete extObj[prop];
-            }
-            Reflect.defineProperty(baseObj, prop, desc);
-            return true;
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            if (prop in extObj) {
-                return Reflect.getOwnPropertyDescriptor(extObj, prop);
-            }
-            else {
-                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
-            }
-        },
-        has(_target, prop) {
-            return prop in extObj || prop in baseObj;
-        },
-    });
-}