@emdzej/bimmerz-logger 0.1.0

package/dist/sinks/null.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../src/sinks/null.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,wBAAgB,QAAQ,IAAI,IAAI,CAM/B"}

package/dist/sinks/null.js

@@ -0,0 +1,15 @@
+/**
+ * Null sink — drops every record. Use in tests so logging code
+ * doesn't pollute the test runner output, or in production code
+ * paths where you want to disable logging entirely without going
+ * through `silent` level (e.g. a "verbose" CLI flag that controls
+ * level but a separate "quiet" flag that controls the sink).
+ */
+export function nullSink() {
+    return {
+        write() {
+            /* no-op */
+        },
+    };
+}
+//# sourceMappingURL=null.js.map

package/dist/sinks/null.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/sinks/null.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,UAAU,QAAQ;IACtB,OAAO;QACL,KAAK;YACH,WAAW;QACb,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/sinks/pino.d.ts

@@ -0,0 +1,37 @@
+/**
+ * pino-backed sink — Node-only entry point. Exposed under the
+ * subpath `@emdzej/bimmerz-logger/sinks/pino` so web bundles
+ * tree-shake out pino entirely. Apps that want JSON logs, file
+ * destinations, or pino-pretty render through this.
+ *
+ * Maps each `LogRecord` onto a single pino call, preserving the
+ * level, bindings, message, and category (carried as the
+ * `category` field in the pino object). We re-create the pino
+ * instance on every config-applying call rather than caching one —
+ * cheap, and keeps the API simple ("here's pino's options, build
+ * me a sink").
+ */
+import pino from 'pino';
+import type { Sink } from '../types.js';
+export interface PinoSinkOptions {
+    /**
+     * Render through pino-pretty when set. Node-only; ignored if
+     * `destination` is also set (pino-pretty + file requires its
+     * own transport stack).
+     */
+    pretty?: boolean;
+    /** Write to a file path instead of stdout. */
+    destination?: string;
+    /**
+     * Optional name attached to every record as `name` — pino's
+     * convention. Defaults to "bimmerz".
+     */
+    name?: string;
+    /**
+     * Any extra pino options. Merged AFTER the ones we set, so
+     * callers can override anything.
+     */
+    pinoOptions?: pino.LoggerOptions;
+}
+export declare function pinoSink(opts?: PinoSinkOptions): Sink;
+//# sourceMappingURL=pino.d.ts.map

package/dist/sinks/pino.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.d.ts","sourceRoot":"","sources":["../../src/sinks/pino.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,KAAK,EAAa,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC;CAClC;AAED,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,IAAI,CAsBzD"}

package/dist/sinks/pino.js

@@ -0,0 +1,39 @@
+/**
+ * pino-backed sink — Node-only entry point. Exposed under the
+ * subpath `@emdzej/bimmerz-logger/sinks/pino` so web bundles
+ * tree-shake out pino entirely. Apps that want JSON logs, file
+ * destinations, or pino-pretty render through this.
+ *
+ * Maps each `LogRecord` onto a single pino call, preserving the
+ * level, bindings, message, and category (carried as the
+ * `category` field in the pino object). We re-create the pino
+ * instance on every config-applying call rather than caching one —
+ * cheap, and keeps the API simple ("here's pino's options, build
+ * me a sink").
+ */
+import pino from 'pino';
+export function pinoSink(opts = {}) {
+    const transport = opts.destination
+        ? { target: 'pino/file', options: { destination: opts.destination } }
+        : opts.pretty
+            ? { target: 'pino-pretty', options: { colorize: true } }
+            : undefined;
+    const logger = pino({
+        name: opts.name ?? 'bimmerz',
+        // We do our own threshold filtering upstream; pino should
+        // accept everything and just format. Avoids double-checking
+        // the level threshold.
+        level: 'trace',
+        transport,
+        ...opts.pinoOptions,
+    });
+    return {
+        write(record) {
+            const bindings = { ...record.bindings };
+            if (record.category)
+                bindings.category = record.category;
+            logger[record.level](bindings, record.msg);
+        },
+    };
+}
+//# sourceMappingURL=pino.js.map

package/dist/sinks/pino.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.js","sourceRoot":"","sources":["../../src/sinks/pino.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,IAAI,MAAM,MAAM,CAAC;AAwBxB,MAAM,UAAU,QAAQ,CAAC,OAAwB,EAAE;IACjD,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW;QAChC,CAAC,CAAC,EAAE,MAAM,EAAE,WAAoB,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE;QAC9E,CAAC,CAAC,IAAI,CAAC,MAAM;YACX,CAAC,CAAC,EAAE,MAAM,EAAE,aAAsB,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE;YACjE,CAAC,CAAC,SAAS,CAAC;IAChB,MAAM,MAAM,GAAG,IAAI,CAAC;QAClB,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS;QAC5B,0DAA0D;QAC1D,4DAA4D;QAC5D,uBAAuB;QACvB,KAAK,EAAE,OAAO;QACd,SAAS;QACT,GAAG,IAAI,CAAC,WAAW;KACpB,CAAC,CAAC;IACH,OAAO;QACL,KAAK,CAAC,MAAiB;YACrB,MAAM,QAAQ,GAAG,EAAE,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YACxC,IAAI,MAAM,CAAC,QAAQ;gBAAE,QAAQ,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YACzD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7C,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Public types for `@emdzej/bimmerz-logger`. Apps and packages
+ * consume these — concrete implementations stay private to this
+ * package so we can swap them out without breaking call sites.
+ */
+/**
+ * Severity ordering. `silent` blocks every line; `trace` lets
+ * everything through. Same names + ordering as pino so call-site
+ * idioms transfer 1:1.
+ */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent';
+/**
+ * Free-form key/value context that rides alongside the message.
+ * Each call passes its own bag; `Logger.child(bindings)` adds
+ * permanent bindings that merge with every subsequent call.
+ *
+ * Values are intentionally `unknown` — callers can pass primitives,
+ * objects, arrays, errors. Sinks decide how to render.
+ */
+export type LogBindings = Record<string, unknown>;
+/**
+ * One decoded log call, before any sink-side formatting.
+ *
+ * Sinks receive these and turn them into whatever the destination
+ * needs — JSON lines for pino/file, formatted strings for the
+ * browser console, structured objects for an in-memory ring.
+ */
+export interface LogRecord {
+    /** Severity of this line (always above the effective threshold). */
+    level: LogLevel;
+    /**
+     * Dot-separated category the logger was created with, or `null`
+     * if the call came from the root logger (`getLogger()`).
+     */
+    category: string | null;
+    /**
+     * Merged bindings — `child()` permanent bindings plus any
+     * per-call bindings. May be `{}` but is never null.
+     */
+    bindings: LogBindings;
+    /** Human-readable message. */
+    msg: string;
+    /** `Date.now()` at the moment of the log call. */
+    time: number;
+}
+/**
+ * Destination for log records. Implementations are pluggable —
+ * console sink for browsers, pino sink for Node, ring-buffer sink
+ * for "Download log" UI features, etc. Compose multiple via
+ * `multiSink(a, b, …)`.
+ *
+ * `write` is sync because every consumer we have today writes
+ * synchronously (console.*, process.stdout, in-memory). If we
+ * ever need async sinks (network shipping, IndexedDB) we'll
+ * widen this.
+ */
+export interface Sink {
+    write(record: LogRecord): void;
+}
+/**
+ * Logger handle handed out by `getLogger()`. Pino-shape API so
+ * existing call sites need no rewrites — but with `level` as a
+ * read-only getter (it reflects the live category-resolved
+ * threshold, not a per-instance mutable field). Use
+ * `configureLogger()` to change levels at runtime.
+ */
+export interface Logger {
+    /** Currently-effective level for this logger's category. Read-only. */
+    readonly level: LogLevel;
+    trace(msg: string): void;
+    trace(bindings: LogBindings, msg: string): void;
+    debug(msg: string): void;
+    debug(bindings: LogBindings, msg: string): void;
+    info(msg: string): void;
+    info(bindings: LogBindings, msg: string): void;
+    warn(msg: string): void;
+    warn(bindings: LogBindings, msg: string): void;
+    error(msg: string): void;
+    error(bindings: LogBindings, msg: string): void;
+    fatal(msg: string): void;
+    fatal(bindings: LogBindings, msg: string): void;
+    /**
+     * Spawn a child logger that carries `bindings` on every call.
+     * Inherits the parent's category — the child's effective level
+     * still tracks the central config for that category.
+     */
+    child(bindings: LogBindings): Logger;
+}
+/**
+ * Central logger configuration. Apply via `configureLogger()`; the
+ * call is sticky and merges with the existing config. All loggers
+ * — including those handed out before the call — pick up the
+ * new settings immediately.
+ */
+export interface LoggerConfig {
+    /**
+     * Default threshold when no `categories` entry matches. Applied
+     * to the root logger and to any category that has no rule.
+     */
+    level: LogLevel;
+    /**
+     * Per-category thresholds. Keys are dot-separated category
+     * paths; lookup walks up the path so a rule for `EDIABASX`
+     * applies to `EDIABASX.parser` and `EDIABASX.parser.lexer`
+     * unless a more specific rule wins.
+     *
+     * Example:
+     * ```
+     * { EDIABASX: 'debug', 'EDIABASX.parser': 'trace', INPAX: 'info' }
+     * ```
+     * — every `INPAX*` category at info; every `EDIABASX*` at debug
+     * except `EDIABASX.parser*` which is at trace.
+     */
+    categories?: Record<string, LogLevel>;
+    /**
+     * Where formatted records are written. Defaults to `consoleSink()`
+     * when omitted — works in both Node and browser, no dependencies.
+     */
+    sink?: Sink;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAChB,OAAO,GACP,OAAO,GACP,MAAM,GACN,MAAM,GACN,OAAO,GACP,OAAO,GACP,QAAQ,CAAC;AAEb;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,oEAAoE;IACpE,KAAK,EAAE,QAAQ,CAAC;IAChB;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;OAGG;IACH,QAAQ,EAAE,WAAW,CAAC;IACtB,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,IAAI;IACnB,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IACrB,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IAEzB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/C,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/C,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhD;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAAC;CACtC;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,KAAK,EAAE,QAAQ,CAAC;IAEhB;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAEtC;;;OAGG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;CACb"}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Public types for `@emdzej/bimmerz-logger`. Apps and packages
+ * consume these — concrete implementations stay private to this
+ * package so we can swap them out without breaking call sites.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@emdzej/bimmerz-logger",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Shared structured logger for the bimmerz family — pino-shape API, hierarchical categories, runtime-mutable config, pluggable sinks. No env reads, isomorphic (Node + browser), tree-shake-friendly.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./sinks/pino": {
+      "types": "./dist/sinks/pino.d.ts",
+      "import": "./dist/sinks/pino.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "pino": "^9.0.0",
+    "pino-pretty": "^11.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.1",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/emdzej/bimmerz.git",
+    "directory": "packages/logger"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo *.tsbuildinfo"
+  }
+}