@rdfx/logger 0.0.52

package/dist/ConsoleLogger.d.ts

@@ -0,0 +1,24 @@
+import type { Context } from "./Context.js";
+import type { Level } from "./Level.js";
+import type { LogFunction } from "./LogFunction.js";
+import type { Logger } from "./Logger.js";
+export declare const boundConsoleMethods: {
+    [level in Level]: (...data: unknown[]) => void;
+};
+export declare const levelNumbers: {
+    [level in Level]: number;
+};
+export declare class ConsoleLogger<ContextT extends Context = Context> implements Logger<ContextT> {
+    readonly level: Level;
+    readonly context: Context;
+    constructor(level?: Level, context?: Context);
+    child(context: Context): Logger;
+    debug: LogFunction<ContextT>;
+    error: LogFunction<ContextT>;
+    info: LogFunction<ContextT>;
+    isLevelEnabled(level: Level): boolean;
+    trace: LogFunction<ContextT>;
+    warn: LogFunction<ContextT>;
+    private log;
+}
+//# sourceMappingURL=ConsoleLogger.d.ts.map

package/dist/ConsoleLogger.js

@@ -0,0 +1,65 @@
+export const boundConsoleMethods = {
+    debug: console.debug.bind(console),
+    error: console.error.bind(console),
+    info: console.info.bind(console),
+    trace: console.trace.bind(console),
+    warn: console.warn.bind(console),
+};
+export const levelNumbers = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+};
+export class ConsoleLogger {
+    level;
+    context;
+    constructor(level = "warn", context = {}) {
+        this.level = level;
+        this.context = context;
+    }
+    child(context) {
+        return new ConsoleLogger(this.level, { ...this.context, context });
+    }
+    debug = (contextOrMessage, messageOrArg, ...args) => {
+        return this.log(boundConsoleMethods.debug, "debug", contextOrMessage, messageOrArg, ...args);
+    };
+    error = (contextOrMessage, messageOrArg, ...args) => {
+        return this.log(boundConsoleMethods.error, "error", contextOrMessage, messageOrArg, ...args);
+    };
+    info = (contextOrMessage, messageOrArg, ...args) => {
+        return this.log(boundConsoleMethods.info, "info", contextOrMessage, messageOrArg, ...args);
+    };
+    isLevelEnabled(level) {
+        return levelNumbers[this.level] <= levelNumbers[level];
+    }
+    trace = (contextOrMessage, messageOrArg, ...args) => {
+        return this.log(boundConsoleMethods.trace, "trace", contextOrMessage, messageOrArg, ...args);
+    };
+    warn = (contextOrMessage, messageOrArg, ...args) => {
+        return this.log(boundConsoleMethods.warn, "warn", contextOrMessage, messageOrArg, ...args);
+    };
+    log(consoleMethod, level, contextOrMessage, messageOrArg, ...args) {
+        if (!this.isLevelEnabled(level)) {
+            return;
+        }
+        const hasSecondArg = messageOrArg !== undefined || args.length > 0;
+        const tailArgs = hasSecondArg ? [messageOrArg, ...args] : [];
+        if (typeof contextOrMessage === "object" && contextOrMessage !== null) {
+            const context = contextOrMessage;
+            const mergedContext = { ...this.context, ...context };
+            if (Object.keys(mergedContext).length > 0) {
+                consoleMethod(mergedContext, ...tailArgs);
+            }
+            else if (hasSecondArg) {
+                consoleMethod(...tailArgs);
+            }
+        }
+        else {
+            const message = contextOrMessage;
+            consoleMethod(message, ...tailArgs);
+        }
+    }
+}
+//# sourceMappingURL=ConsoleLogger.js.map

package/dist/Context.d.ts

@@ -0,0 +1,2 @@
+export type Context = Record<string, unknown>;
+//# sourceMappingURL=Context.d.ts.map

package/dist/Context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Context.js.map

package/dist/Level.d.ts

@@ -0,0 +1,2 @@
+export type Level = "debug" | "error" | "info" | "trace" | "warn";
+//# sourceMappingURL=Level.d.ts.map

package/dist/Level.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Level.js.map

package/dist/LogFunction.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "./Context.js";
+export interface LogFunction<ContextT extends Context> {
+    <MessageT extends string = string>(message: MessageT, ...args: ParseLogFunctionArgs<MessageT>): void;
+    <T, MessageT extends string = string>(obj: [T] extends [object] ? T & ContextT : T, message?: T extends string ? never : MessageT, ...args: ParseLogFunctionArgs<MessageT> | []): void;
+    <T, MessageT extends string = string>(obj: [T] extends [object] ? T & ContextT : T, message?: T extends string ? never : MessageT, ...args: ParseLogFunctionArgs<MessageT> extends [unknown, ...unknown[]] ? ParseLogFunctionArgs<MessageT> : unknown[]): void;
+}
+type ParseLogFunctionArgs<T, Acc extends unknown[] = []> = T extends `${infer _}%${infer Placeholder}${infer Rest}` ? Placeholder extends PlaceholderSpecifier ? ParseLogFunctionArgs<Rest, [...Acc, PlaceholderTypeMapping<Placeholder>]> : ParseLogFunctionArgs<Rest, Acc> : Acc;
+type PlaceholderSpecifier = "d" | "s" | "j" | "o" | "O";
+type PlaceholderTypeMapping<T extends PlaceholderSpecifier> = T extends "d" ? number : T extends "s" ? unknown : T extends "j" | "o" | "O" ? // biome-ignore lint/complexity/noBannedTypes: Don't change pino code that works
+{} | null : never;
+export {};
+//# sourceMappingURL=LogFunction.d.ts.map

package/dist/LogFunction.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LogFunction.js.map

package/dist/Logger.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from "./Context.js";
+import type { Level } from "./Level.js";
+import type { LogFunction } from "./LogFunction.js";
+export interface Logger<ContextT extends Context = Context> {
+    child(context: ContextT): Logger<ContextT>;
+    debug: LogFunction<ContextT>;
+    error: LogFunction<ContextT>;
+    info: LogFunction<ContextT>;
+    isLevelEnabled(level: Level): boolean;
+    trace: LogFunction<ContextT>;
+    warn: LogFunction<ContextT>;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/Logger.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Logger.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./ConsoleLogger.js";
+export * from "./Context.js";
+export * from "./Level.js";
+export * from "./LogFunction.js";
+export * from "./Logger.js";
+export * from "./nopLogger.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./ConsoleLogger.js";
+export * from "./Context.js";
+export * from "./Level.js";
+export * from "./LogFunction.js";
+export * from "./Logger.js";
+export * from "./nopLogger.js";
+//# sourceMappingURL=index.js.map

package/dist/nopLogger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from "./Logger.js";
+export declare const nopLogger: Logger;
+//# sourceMappingURL=nopLogger.d.ts.map

package/dist/nopLogger.js

@@ -0,0 +1,14 @@
+export const nopLogger = {
+    child: () => {
+        return nopLogger;
+    },
+    debug: () => { },
+    error: () => { },
+    info: () => { },
+    isLevelEnabled: () => {
+        return false;
+    },
+    trace: () => { },
+    warn: () => { },
+};
+//# sourceMappingURL=nopLogger.js.map

package/package.json

@@ -0,0 +1,30 @@
+{
+  "dependencies": {},
+  "devDependencies": {
+    "pino": "~10.3.1"
+  },
+  "files": [
+    "LICENSE",
+    "dist/*.d.ts",
+    "dist/*.js"
+  ],
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "name": "@rdfx/logger",
+  "packageManager": "npm@11.11.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/rdfx.git"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "rimraf dist",
+    "depcheck": "depcheck --ignores=\"@tsconfig/*,vitest,vitest-fetch-mock\" .",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run packages/logger/__tests__"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "0.0.52"
+}