@decohere/scribe 0.0.1-dev.4 → 0.0.1-dev.40

package/commonjs/src/console.adapter.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ConsoleAdapter", {
+    enumerable: true,
+    get: function() {
+        return ConsoleAdapter;
+    }
+});
+const _loggeradapter = require("./logger.adapter.js");
+const _types = require("./types.js");
+class ConsoleAdapter extends _loggeradapter.LogAdapter {
+    configuredLevels;
+    configuredLogLevel = _types.DefaultLogLevel;
+    configuredLogLevelValue = _types.LogLevels.info;
+    constructor(_options = {}){
+        super();
+    }
+    configure(scribeOptions) {
+        // Get merged log levels (default + custom) using parent class method
+        this.configuredLevels = this.getLogLevels(scribeOptions);
+        const logLevelStr = scribeOptions.logLevel ?? _types.DefaultLogLevel;
+        this.configuredLogLevel = logLevelStr;
+        this.configuredLogLevelValue = this.configuredLevels[logLevelStr] ?? _types.LogLevels.info;
+    }
+    getLogger(name) {
+        const loggerName = name || "default";
+        return this.createConsoleLogger(loggerName);
+    }
+    createConsoleLogger(name) {
+        // Use the levels configured during the configure() call
+        const allLevels = this.configuredLevels;
+        const currentLevel = this.configuredLogLevel;
+        const threshold = this.configuredLogLevelValue;
+        const baseLogger = {
+            get currentLevel () {
+                return currentLevel;
+            },
+            get logLevels () {
+                return allLevels;
+            }
+        };
+        const logFunction = (level)=>(msg, ...args)=>{
+                const timestamp = new Date().toISOString();
+                let message;
+                if (typeof msg === "object") {
+                    message = msg instanceof Error ? (0, _loggeradapter.formatError)(msg) : JSON.stringify(msg);
+                } else {
+                    message = String(msg);
+                }
+                const logLine = `[${timestamp}] ${level.toUpperCase()} [${name}]: ${message}`;
+                if (args.length > 0) {
+                    console.log(logLine, ...args);
+                } else {
+                    console.log(logLine);
+                }
+            };
+        const noop = ()=>{};
+        // Start with base logger and isLevelEnabled method
+        const logger = Object.assign(baseLogger, {
+            isLevelEnabled: (level)=>(allLevels[level] ?? 0) >= threshold
+        });
+        // Dynamically add all log level methods (default + custom)
+        // Levels below the configured threshold are patched to noop
+        for (const [levelName, levelValue] of Object.entries(allLevels)){
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic logger level creation requires any
+            logger[levelName] = levelValue >= threshold ? logFunction(levelName) : noop;
+        }
+        return logger;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2NvbnNvbGUuYWRhcHRlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBmb3JtYXRFcnJvciwgTG9nQWRhcHRlciB9IGZyb20gXCIuL2xvZ2dlci5hZGFwdGVyLmpzXCI7XG5pbXBvcnQgdHlwZSB7IEJhc2VMb2dnZXIsIExvZ2dlciB9IGZyb20gXCIuL2xvZ2dlci50eXBlLmpzXCI7XG5pbXBvcnQge1xuXHREZWZhdWx0TG9nTGV2ZWwsXG5cdHR5cGUgTG9nQWRhcHRlck9wdGlvbnMsXG5cdExvZ0xldmVscyxcblx0dHlwZSBTY3JpYmVPcHRpb25zLFxufSBmcm9tIFwiLi90eXBlcy5qc1wiO1xuXG5leHBvcnQgdHlwZSBDb25zb2xlQWRhcHRlck9wdGlvbnMgPSB7fSAmIExvZ0FkYXB0ZXJPcHRpb25zO1xuXG5leHBvcnQgY2xhc3MgQ29uc29sZUFkYXB0ZXIgZXh0ZW5kcyBMb2dBZGFwdGVyIHtcblx0cHJpdmF0ZSBjb25maWd1cmVkTGV2ZWxzOiBSZWNvcmQ8c3RyaW5nLCBudW1iZXI+O1xuXHRwcml2YXRlIGNvbmZpZ3VyZWRMb2dMZXZlbDogc3RyaW5nID0gRGVmYXVsdExvZ0xldmVsO1xuXHRwcml2YXRlIGNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlOiBudW1iZXIgPSBMb2dMZXZlbHMuaW5mbztcblxuXHRwdWJsaWMgY29uc3RydWN0b3IoX29wdGlvbnM6IENvbnNvbGVBZGFwdGVyT3B0aW9ucyA9IHt9KSB7XG5cdFx0c3VwZXIoKTtcblx0fVxuXG5cdHB1YmxpYyBjb25maWd1cmU8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdHNjcmliZU9wdGlvbnM6IFNjcmliZU9wdGlvbnM8VCwgQ3VzdG9tT25seT4sXG5cdCkge1xuXHRcdC8vIEdldCBtZXJnZWQgbG9nIGxldmVscyAoZGVmYXVsdCArIGN1c3RvbSkgdXNpbmcgcGFyZW50IGNsYXNzIG1ldGhvZFxuXHRcdHRoaXMuY29uZmlndXJlZExldmVscyA9IHRoaXMuZ2V0TG9nTGV2ZWxzKHNjcmliZU9wdGlvbnMpO1xuXHRcdGNvbnN0IGxvZ0xldmVsU3RyID0gc2NyaWJlT3B0aW9ucy5sb2dMZXZlbCA/PyBEZWZhdWx0TG9nTGV2ZWw7XG5cdFx0dGhpcy5jb25maWd1cmVkTG9nTGV2ZWwgPSBsb2dMZXZlbFN0cjtcblx0XHR0aGlzLmNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlID0gdGhpcy5jb25maWd1cmVkTGV2ZWxzW2xvZ0xldmVsU3RyXSA/PyBMb2dMZXZlbHMuaW5mbztcblx0fVxuXG5cdHB1YmxpYyBnZXRMb2dnZXI8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdG5hbWU/OiBzdHJpbmcsXG5cdCk6IExvZ2dlcjxULCBDdXN0b21Pbmx5PiB7XG5cdFx0Y29uc3QgbG9nZ2VyTmFtZSA9IG5hbWUgfHwgXCJkZWZhdWx0XCI7XG5cdFx0cmV0dXJuIHRoaXMuY3JlYXRlQ29uc29sZUxvZ2dlcjxULCBDdXN0b21Pbmx5Pihsb2dnZXJOYW1lKTtcblx0fVxuXG5cdHByaXZhdGUgY3JlYXRlQ29uc29sZUxvZ2dlcjxcblx0XHRUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsXG5cdFx0Q3VzdG9tT25seSBleHRlbmRzIHRydWUgfCBmYWxzZSA9IGZhbHNlLFxuXHQ+KG5hbWU6IHN0cmluZyk6IExvZ2dlcjxULCBDdXN0b21Pbmx5PiB7XG5cdFx0Ly8gVXNlIHRoZSBsZXZlbHMgY29uZmlndXJlZCBkdXJpbmcgdGhlIGNvbmZpZ3VyZSgpIGNhbGxcblx0XHRjb25zdCBhbGxMZXZlbHMgPSB0aGlzLmNvbmZpZ3VyZWRMZXZlbHM7XG5cdFx0Y29uc3QgY3VycmVudExldmVsID0gdGhpcy5jb25maWd1cmVkTG9nTGV2ZWw7XG5cdFx0Y29uc3QgdGhyZXNob2xkID0gdGhpcy5jb25maWd1cmVkTG9nTGV2ZWxWYWx1ZTtcblxuXHRcdGNvbnN0IGJhc2VMb2dnZXI6IEJhc2VMb2dnZXIgPSB7XG5cdFx0XHRnZXQgY3VycmVudExldmVsKCkge1xuXHRcdFx0XHRyZXR1cm4gY3VycmVudExldmVsO1xuXHRcdFx0fSxcblx0XHRcdGdldCBsb2dMZXZlbHMoKSB7XG5cdFx0XHRcdHJldHVybiBhbGxMZXZlbHM7XG5cdFx0XHR9LFxuXHRcdH07XG5cblx0XHRjb25zdCBsb2dGdW5jdGlvbiA9XG5cdFx0XHQobGV2ZWw6IHN0cmluZykgPT5cblx0XHRcdChtc2c6IHN0cmluZyB8IG51bWJlciB8IG9iamVjdCwgLi4uYXJnczogdW5rbm93bltdKSA9PiB7XG5cdFx0XHRcdGNvbnN0IHRpbWVzdGFtcCA9IG5ldyBEYXRlKCkudG9JU09TdHJpbmcoKTtcblx0XHRcdFx0bGV0IG1lc3NhZ2U6IHN0cmluZztcblxuXHRcdFx0XHRpZiAodHlwZW9mIG1zZyA9PT0gXCJvYmplY3RcIikge1xuXHRcdFx0XHRcdG1lc3NhZ2UgPSBtc2cgaW5zdGFuY2VvZiBFcnJvciA/IGZvcm1hdEVycm9yKG1zZykgOiBKU09OLnN0cmluZ2lmeShtc2cpO1xuXHRcdFx0XHR9IGVsc2Uge1xuXHRcdFx0XHRcdG1lc3NhZ2UgPSBTdHJpbmcobXNnKTtcblx0XHRcdFx0fVxuXG5cdFx0XHRcdGNvbnN0IGxvZ0xpbmUgPSBgWyR7dGltZXN0YW1wfV0gJHtsZXZlbC50b1VwcGVyQ2FzZSgpfSBbJHtuYW1lfV06ICR7bWVzc2FnZX1gO1xuXG5cdFx0XHRcdGlmIChhcmdzLmxlbmd0aCA+IDApIHtcblx0XHRcdFx0XHRjb25zb2xlLmxvZyhsb2dMaW5lLCAuLi5hcmdzKTtcblx0XHRcdFx0fSBlbHNlIHtcblx0XHRcdFx0XHRjb25zb2xlLmxvZyhsb2dMaW5lKTtcblx0XHRcdFx0fVxuXHRcdFx0fTtcblxuXHRcdGNvbnN0IG5vb3AgPSAoKSA9PiB7fTtcblxuXHRcdC8vIFN0YXJ0IHdpdGggYmFzZSBsb2dnZXIgYW5kIGlzTGV2ZWxFbmFibGVkIG1ldGhvZFxuXHRcdGNvbnN0IGxvZ2dlciA9IE9iamVjdC5hc3NpZ24oYmFzZUxvZ2dlciwge1xuXHRcdFx0aXNMZXZlbEVuYWJsZWQ6IChsZXZlbDogc3RyaW5nKSA9PiAoYWxsTGV2ZWxzW2xldmVsXSA/PyAwKSA+PSB0aHJlc2hvbGQsXG5cdFx0fSk7XG5cblx0XHQvLyBEeW5hbWljYWxseSBhZGQgYWxsIGxvZyBsZXZlbCBtZXRob2RzIChkZWZhdWx0ICsgY3VzdG9tKVxuXHRcdC8vIExldmVscyBiZWxvdyB0aGUgY29uZmlndXJlZCB0aHJlc2hvbGQgYXJlIHBhdGNoZWQgdG8gbm9vcFxuXHRcdGZvciAoY29uc3QgW2xldmVsTmFtZSwgbGV2ZWxWYWx1ZV0gb2YgT2JqZWN0LmVudHJpZXMoYWxsTGV2ZWxzKSkge1xuXHRcdFx0Ly8gYmlvbWUtaWdub3JlIGxpbnQvc3VzcGljaW91cy9ub0V4cGxpY2l0QW55OiBEeW5hbWljIGxvZ2dlciBsZXZlbCBjcmVhdGlvbiByZXF1aXJlcyBhbnlcblx0XHRcdChsb2dnZXIgYXMgYW55KVtsZXZlbE5hbWVdID0gbGV2ZWxWYWx1ZSA+PSB0aHJlc2hvbGQgPyBsb2dGdW5jdGlvbihsZXZlbE5hbWUpIDogbm9vcDtcblx0XHR9XG5cblx0XHRyZXR1cm4gbG9nZ2VyIGFzIExvZ2dlcjxULCBDdXN0b21Pbmx5Pjtcblx0fVxufVxuIl0sIm5hbWVzIjpbIkNvbnNvbGVBZGFwdGVyIiwiTG9nQWRhcHRlciIsImNvbmZpZ3VyZWRMZXZlbHMiLCJjb25maWd1cmVkTG9nTGV2ZWwiLCJEZWZhdWx0TG9nTGV2ZWwiLCJjb25maWd1cmVkTG9nTGV2ZWxWYWx1ZSIsIkxvZ0xldmVscyIsImluZm8iLCJfb3B0aW9ucyIsImNvbmZpZ3VyZSIsInNjcmliZU9wdGlvbnMiLCJnZXRMb2dMZXZlbHMiLCJsb2dMZXZlbFN0ciIsImxvZ0xldmVsIiwiZ2V0TG9nZ2VyIiwibmFtZSIsImxvZ2dlck5hbWUiLCJjcmVhdGVDb25zb2xlTG9nZ2VyIiwiYWxsTGV2ZWxzIiwiY3VycmVudExldmVsIiwidGhyZXNob2xkIiwiYmFzZUxvZ2dlciIsImxvZ0xldmVscyIsImxvZ0Z1bmN0aW9uIiwibGV2ZWwiLCJtc2ciLCJhcmdzIiwidGltZXN0YW1wIiwiRGF0ZSIsInRvSVNPU3RyaW5nIiwibWVzc2FnZSIsIkVycm9yIiwiZm9ybWF0RXJyb3IiLCJKU09OIiwic3RyaW5naWZ5IiwiU3RyaW5nIiwibG9nTGluZSIsInRvVXBwZXJDYXNlIiwibGVuZ3RoIiwiY29uc29sZSIsImxvZyIsIm5vb3AiLCJsb2dnZXIiLCJPYmplY3QiLCJhc3NpZ24iLCJpc0xldmVsRW5hYmxlZCIsImxldmVsTmFtZSIsImxldmVsVmFsdWUiLCJlbnRyaWVzIl0sIm1hcHBpbmdzIjoiOzs7OytCQVdhQTs7O2VBQUFBOzs7K0JBWDJCO3VCQU9qQztBQUlBLE1BQU1BLHVCQUF1QkMseUJBQVU7SUFDckNDLGlCQUF5QztJQUN6Q0MscUJBQTZCQyxzQkFBZSxDQUFDO0lBQzdDQywwQkFBa0NDLGdCQUFTLENBQUNDLElBQUksQ0FBQztJQUV6RCxZQUFtQkMsV0FBa0MsQ0FBQyxDQUFDLENBQUU7UUFDeEQsS0FBSztJQUNOO0lBRU9DLFVBQ05DLGFBQTJDLEVBQzFDO1FBQ0QscUVBQXFFO1FBQ3JFLElBQUksQ0FBQ1IsZ0JBQWdCLEdBQUcsSUFBSSxDQUFDUyxZQUFZLENBQUNEO1FBQzFDLE1BQU1FLGNBQWNGLGNBQWNHLFFBQVEsSUFBSVQsc0JBQWU7UUFDN0QsSUFBSSxDQUFDRCxrQkFBa0IsR0FBR1M7UUFDMUIsSUFBSSxDQUFDUCx1QkFBdUIsR0FBRyxJQUFJLENBQUNILGdCQUFnQixDQUFDVSxZQUFZLElBQUlOLGdCQUFTLENBQUNDLElBQUk7SUFDcEY7SUFFT08sVUFDTkMsSUFBYSxFQUNXO1FBQ3hCLE1BQU1DLGFBQWFELFFBQVE7UUFDM0IsT0FBTyxJQUFJLENBQUNFLG1CQUFtQixDQUFnQkQ7SUFDaEQ7SUFFUUMsb0JBR05GLElBQVksRUFBeUI7UUFDdEMsd0RBQXdEO1FBQ3hELE1BQU1HLFlBQVksSUFBSSxDQUFDaEIsZ0JBQWdCO1FBQ3ZDLE1BQU1pQixlQUFlLElBQUksQ0FBQ2hCLGtCQUFrQjtRQUM1QyxNQUFNaUIsWUFBWSxJQUFJLENBQUNmLHVCQUF1QjtRQUU5QyxNQUFNZ0IsYUFBeUI7WUFDOUIsSUFBSUYsZ0JBQWU7Z0JBQ2xCLE9BQU9BO1lBQ1I7WUFDQSxJQUFJRyxhQUFZO2dCQUNmLE9BQU9KO1lBQ1I7UUFDRDtRQUVBLE1BQU1LLGNBQ0wsQ0FBQ0MsUUFDRCxDQUFDQyxLQUErQixHQUFHQztnQkFDbEMsTUFBTUMsWUFBWSxJQUFJQyxPQUFPQyxXQUFXO2dCQUN4QyxJQUFJQztnQkFFSixJQUFJLE9BQU9MLFFBQVEsVUFBVTtvQkFDNUJLLFVBQVVMLGVBQWVNLFFBQVFDLElBQUFBLDBCQUFXLEVBQUNQLE9BQU9RLEtBQUtDLFNBQVMsQ0FBQ1Q7Z0JBQ3BFLE9BQU87b0JBQ05LLFVBQVVLLE9BQU9WO2dCQUNsQjtnQkFFQSxNQUFNVyxVQUFVLENBQUMsQ0FBQyxFQUFFVCxVQUFVLEVBQUUsRUFBRUgsTUFBTWEsV0FBVyxHQUFHLEVBQUUsRUFBRXRCLEtBQUssR0FBRyxFQUFFZSxTQUFTO2dCQUU3RSxJQUFJSixLQUFLWSxNQUFNLEdBQUcsR0FBRztvQkFDcEJDLFFBQVFDLEdBQUcsQ0FBQ0osWUFBWVY7Z0JBQ3pCLE9BQU87b0JBQ05hLFFBQVFDLEdBQUcsQ0FBQ0o7Z0JBQ2I7WUFDRDtRQUVELE1BQU1LLE9BQU8sS0FBTztRQUVwQixtREFBbUQ7UUFDbkQsTUFBTUMsU0FBU0MsT0FBT0MsTUFBTSxDQUFDdkIsWUFBWTtZQUN4Q3dCLGdCQUFnQixDQUFDckIsUUFBa0IsQUFBQ04sQ0FBQUEsU0FBUyxDQUFDTSxNQUFNLElBQUksQ0FBQSxLQUFNSjtRQUMvRDtRQUVBLDJEQUEyRDtRQUMzRCw0REFBNEQ7UUFDNUQsS0FBSyxNQUFNLENBQUMwQixXQUFXQyxXQUFXLElBQUlKLE9BQU9LLE9BQU8sQ0FBQzlCLFdBQVk7WUFDaEUseUZBQXlGO1lBQ3hGd0IsTUFBYyxDQUFDSSxVQUFVLEdBQUdDLGNBQWMzQixZQUFZRyxZQUFZdUIsYUFBYUw7UUFDakY7UUFFQSxPQUFPQztJQUNSO0FBQ0QifQ==

package/commonjs/src/env.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getLogLevelFromArgv () {
+        return getLogLevelFromArgv;
+    },
+    get getLogLevelFromEnv () {
+        return getLogLevelFromEnv;
+    },
+    get isValidLogLevel () {
+        return isValidLogLevel;
+    },
+    get resolveLogLevel () {
+        return resolveLogLevel;
+    }
+});
+/**
+ * Environment variable names checked in order of precedence.
+ * The first non-empty value found is used.
+ */ const ENV_VAR_NAMES = [
+    "LOG_LEVEL",
+    "SCRIBE_LOG_LEVEL",
+    "LOGGING_LEVEL"
+];
+const VALID_LEVELS = [
+    "fatal",
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace"
+];
+function getLogLevelFromEnv() {
+    for (const name of ENV_VAR_NAMES){
+        const value = process.env[name]?.trim().toLowerCase();
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
+function getLogLevelFromArgv(argv) {
+    for(let index = 0; index < argv.length; index += 1){
+        const arg = argv[index];
+        if (arg === "--log-level" || arg === "-l") {
+            return argv[index + 1];
+        }
+        if (arg.startsWith("--log-level=")) {
+            return arg.slice("--log-level=".length);
+        }
+    }
+    return undefined;
+}
+function isValidLogLevel(level) {
+    return VALID_LEVELS.includes(level);
+}
+function resolveLogLevel(arg) {
+    if (typeof arg === "string") {
+        if (isValidLogLevel(arg)) {
+            return arg;
+        }
+        const envLogLevel = getLogLevelFromEnv();
+        if (envLogLevel != null && isValidLogLevel(envLogLevel)) {
+            return envLogLevel;
+        }
+        return null;
+    }
+    if (arg == null) {
+        const envLogLevel = getLogLevelFromEnv();
+        if (envLogLevel != null && isValidLogLevel(envLogLevel)) {
+            return envLogLevel;
+        }
+        return null;
+    }
+    const { explicitLogLevel, envLogLevel, defaultLogLevel } = arg;
+    if (explicitLogLevel != null && isValidLogLevel(explicitLogLevel)) {
+        return explicitLogLevel;
+    }
+    const resolvedEnvLogLevel = envLogLevel ?? getLogLevelFromEnv();
+    if (resolvedEnvLogLevel != null && isValidLogLevel(resolvedEnvLogLevel)) {
+        return resolvedEnvLogLevel;
+    }
+    return defaultLogLevel;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/errors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LoggingConfigurationError", {
+    enumerable: true,
+    get: function() {
+        return LoggingConfigurationError;
+    }
+});
+class LoggingConfigurationError extends Error {
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2Vycm9ycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgTG9nZ2luZ0NvbmZpZ3VyYXRpb25FcnJvciBleHRlbmRzIEVycm9yIHt9XG4iXSwibmFtZXMiOlsiTG9nZ2luZ0NvbmZpZ3VyYXRpb25FcnJvciIsIkVycm9yIl0sIm1hcHBpbmdzIjoiOzs7OytCQUFhQTs7O2VBQUFBOzs7QUFBTixNQUFNQSxrQ0FBa0NDO0FBQU8ifQ==

package/commonjs/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./console.adapter.js"), exports);
+_export_star(require("./env.js"), exports);
+_export_star(require("./errors.js"), exports);
+_export_star(require("./logger.adapter.js"), exports);
+_export_star(require("./logger.factory.js"), exports);
+_export_star(require("./logger.type.js"), exports);
+_export_star(require("./types.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnNvbGUuYWRhcHRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW52LmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnMuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvZ2dlci5hZGFwdGVyLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnZXIuZmFjdG9yeS5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbG9nZ2VyLnR5cGUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQTtxQkFDQSJ9

package/commonjs/src/logger.adapter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get LogAdapter () {
+        return LogAdapter;
+    },
+    get formatError () {
+        return formatError;
+    }
+});
+const _types = require("./types.js");
+function formatError(err) {
+    return err.stack ?? err.message;
+}
+class LogAdapter {
+    flush(cb) {
+        cb?.();
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: Generic utility method needs flexible typing
+    getLogLevels(options) {
+        const { customOnly, customLevels } = options;
+        if (customOnly) {
+            return customLevels;
+        }
+        const levels = this.getUniqueLevels(_types.LogLevels, customLevels);
+        return Object.fromEntries(levels);
+    }
+    getUniqueLevels(defaultLevels, customLevels) {
+        const defaultEntries = Object.entries(defaultLevels ?? {});
+        const customEntries = Object.entries(customLevels ?? {});
+        const defaultNotInCustom = defaultEntries.filter(([dk])=>customEntries.findIndex(([ck])=>ck === dk) === -1);
+        const unique = defaultNotInCustom.concat(customEntries);
+        return unique;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/logger.factory.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "scribe", {
+    enumerable: true,
+    get: function() {
+        return scribe;
+    }
+});
+const _consoleadapter = require("./console.adapter.js");
+const _env = require("./env.js");
+const _errors = require("./errors.js");
+const _types = require("./types.js");
+class scribe {
+    loggerProvider;
+    static instance = new scribe();
+    static logger(name, customLevels) {
+        return scribe.instance.getLogger(name, customLevels);
+    }
+    static configure(configOptions) {
+        scribe.instance = new scribe();
+        return scribe.instance.configure(configOptions);
+    }
+    static get extend() {
+        return scribe.instance;
+    }
+    static flush(cb) {
+        scribe.instance.loggerProvider.flush(cb);
+    }
+    constructor(){
+        // Initialize with default console adapter
+        this.loggerProvider = new _consoleadapter.ConsoleAdapter();
+        const defaultOptions = this.mergeDefaults();
+        this.loggerProvider.configure(defaultOptions);
+    }
+    configure(configOptions) {
+        const { adapter, options } = configOptions;
+        this.loggerProvider = adapter;
+        const defaultsAndOptions = this.mergeDefaults(options);
+        adapter.configure(defaultsAndOptions);
+        return (name)=>adapter.getLogger(name);
+    }
+    getLogger(name, customLevels) {
+        // If custom levels are provided, we need to reconfigure the adapter
+        if (customLevels) {
+            const currentOptions = this.mergeDefaults({
+                customLevels
+            });
+            this.loggerProvider.configure(currentOptions);
+        }
+        const logger = this.loggerProvider.getLogger(name);
+        this.supportsLevels(customLevels, logger);
+        return logger;
+    }
+    supportsLevels(customLevels, logger) {
+        if (!customLevels) {
+            return;
+        }
+        const missingLevel = Object.entries(customLevels).find((key)=>!logger.logLevels[key.at(0).toString()]);
+        if (missingLevel != null) {
+            throw new _errors.LoggingConfigurationError(`Current logger was not configured for custom level ${missingLevel}, valid levels are: ${JSON.stringify(logger.logLevels)}`);
+        }
+        return {
+            missingLevel
+        };
+    }
+    mergeDefaults(options) {
+        const logLevel = (0, _env.resolveLogLevel)(options?.logLevel) ?? _types.DefaultLogLevel;
+        return {
+            logLevel,
+            redactions: _types.DefaultRedactions,
+            ...options
+        };
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2xvZ2dlci5mYWN0b3J5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnNvbGVBZGFwdGVyIH0gZnJvbSBcIi4vY29uc29sZS5hZGFwdGVyLmpzXCI7XG5pbXBvcnQgeyByZXNvbHZlTG9nTGV2ZWwgfSBmcm9tIFwiLi9lbnYuanNcIjtcbmltcG9ydCB7IExvZ2dpbmdDb25maWd1cmF0aW9uRXJyb3IgfSBmcm9tIFwiLi9lcnJvcnMuanNcIjtcbmltcG9ydCB0eXBlIHsgTG9nZ2VyQWRhcHRlciB9IGZyb20gXCIuL2xvZ2dlci5hZGFwdGVyLmpzXCI7XG5pbXBvcnQgdHlwZSB7IExvZ2dlciB9IGZyb20gXCIuL2xvZ2dlci50eXBlLmpzXCI7XG5pbXBvcnQgeyBEZWZhdWx0TG9nTGV2ZWwsIERlZmF1bHRSZWRhY3Rpb25zLCB0eXBlIFNjcmliZU9wdGlvbnMgfSBmcm9tIFwiLi90eXBlcy5qc1wiO1xuXG50eXBlIExvZ2dlckZhY3RvcnlPcHRpb25zPFxuXHRUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsXG5cdEN1c3RvbU9ubHkgZXh0ZW5kcyB0cnVlIHwgZmFsc2UgPSBmYWxzZSxcbj4gPSB7XG5cdG9wdGlvbnM/OiBTY3JpYmVPcHRpb25zPFQsIEN1c3RvbU9ubHk+O1xuXHRhZGFwdGVyOiBMb2dnZXJBZGFwdGVyO1xufTtcblxuZXhwb3J0IGNsYXNzIHNjcmliZSB7XG5cdHByaXZhdGUgbG9nZ2VyUHJvdmlkZXI6IExvZ2dlckFkYXB0ZXI7XG5cdHByaXZhdGUgc3RhdGljIGluc3RhbmNlOiBzY3JpYmUgPSBuZXcgc2NyaWJlKCk7XG5cblx0cHVibGljIHN0YXRpYyBsb2dnZXI8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdG5hbWU/OiBzdHJpbmcsXG5cdFx0Y3VzdG9tTGV2ZWxzPzoge1xuXHRcdFx0W2xldmVsIGluIFRdOiBudW1iZXI7XG5cdFx0fSxcblx0KTogTG9nZ2VyPFQsIEN1c3RvbU9ubHk+IHtcblx0XHRyZXR1cm4gc2NyaWJlLmluc3RhbmNlLmdldExvZ2dlcjxULCBDdXN0b21Pbmx5PihuYW1lLCBjdXN0b21MZXZlbHMpIGFzIExvZ2dlcjxcblx0XHRcdFQsXG5cdFx0XHRDdXN0b21Pbmx5XG5cdFx0Pjtcblx0fVxuXG5cdHB1YmxpYyBzdGF0aWMgY29uZmlndXJlPFQgZXh0ZW5kcyBzdHJpbmcgPSBuZXZlciwgQ3VzdG9tT25seSBleHRlbmRzIHRydWUgfCBmYWxzZSA9IGZhbHNlPihcblx0XHRjb25maWdPcHRpb25zOiBMb2dnZXJGYWN0b3J5T3B0aW9uczxULCBDdXN0b21Pbmx5Pixcblx0KSB7XG5cdFx0c2NyaWJlLmluc3RhbmNlID0gbmV3IHNjcmliZSgpO1xuXHRcdHJldHVybiBzY3JpYmUuaW5zdGFuY2UuY29uZmlndXJlPFQsIEN1c3RvbU9ubHk+KGNvbmZpZ09wdGlvbnMpO1xuXHR9XG5cblx0cHVibGljIHN0YXRpYyBnZXQgZXh0ZW5kKCkge1xuXHRcdHJldHVybiBzY3JpYmUuaW5zdGFuY2U7XG5cdH1cblxuXHRwdWJsaWMgc3RhdGljIGZsdXNoKGNiPzogKCkgPT4gdm9pZCk6IHZvaWQge1xuXHRcdHNjcmliZS5pbnN0YW5jZS5sb2dnZXJQcm92aWRlci5mbHVzaChjYik7XG5cdH1cblxuXHRwdWJsaWMgY29uc3RydWN0b3IoKSB7XG5cdFx0Ly8gSW5pdGlhbGl6ZSB3aXRoIGRlZmF1bHQgY29uc29sZSBhZGFwdGVyXG5cdFx0dGhpcy5sb2dnZXJQcm92aWRlciA9IG5ldyBDb25zb2xlQWRhcHRlcigpO1xuXHRcdGNvbnN0IGRlZmF1bHRPcHRpb25zID0gdGhpcy5tZXJnZURlZmF1bHRzKCk7XG5cdFx0dGhpcy5sb2dnZXJQcm92aWRlci5jb25maWd1cmUoZGVmYXVsdE9wdGlvbnMpO1xuXHR9XG5cblx0cHVibGljIGNvbmZpZ3VyZTxUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsIEN1c3RvbU9ubHkgZXh0ZW5kcyB0cnVlIHwgZmFsc2UgPSBmYWxzZT4oXG5cdFx0Y29uZmlnT3B0aW9uczogTG9nZ2VyRmFjdG9yeU9wdGlvbnM8VCwgQ3VzdG9tT25seT4sXG5cdCk6IChuYW1lPzogc3RyaW5nKSA9PiBMb2dnZXI8VCwgQ3VzdG9tT25seT4ge1xuXHRcdGNvbnN0IHsgYWRhcHRlciwgb3B0aW9ucyB9ID0gY29uZmlnT3B0aW9ucztcblx0XHR0aGlzLmxvZ2dlclByb3ZpZGVyID0gYWRhcHRlcjtcblx0XHRjb25zdCBkZWZhdWx0c0FuZE9wdGlvbnMgPSB0aGlzLm1lcmdlRGVmYXVsdHM8VCwgQ3VzdG9tT25seT4ob3B0aW9ucyk7XG5cdFx0YWRhcHRlci5jb25maWd1cmUoZGVmYXVsdHNBbmRPcHRpb25zKTtcblx0XHRyZXR1cm4gKG5hbWU/OiBzdHJpbmcpID0+IGFkYXB0ZXIuZ2V0TG9nZ2VyKG5hbWUpIGFzIExvZ2dlcjxULCBDdXN0b21Pbmx5Pjtcblx0fVxuXG5cdHB1YmxpYyBnZXRMb2dnZXI8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdG5hbWU/OiBzdHJpbmcsXG5cdFx0Y3VzdG9tTGV2ZWxzPzoge1xuXHRcdFx0W2xldmVsIGluIFRdOiBudW1iZXI7XG5cdFx0fSxcblx0KTogTG9nZ2VyPFQsIEN1c3RvbU9ubHk+IHtcblx0XHQvLyBJZiBjdXN0b20gbGV2ZWxzIGFyZSBwcm92aWRlZCwgd2UgbmVlZCB0byByZWNvbmZpZ3VyZSB0aGUgYWRhcHRlclxuXHRcdGlmIChjdXN0b21MZXZlbHMpIHtcblx0XHRcdGNvbnN0IGN1cnJlbnRPcHRpb25zID0gdGhpcy5tZXJnZURlZmF1bHRzKHsgY3VzdG9tTGV2ZWxzIH0pO1xuXHRcdFx0dGhpcy5sb2dnZXJQcm92aWRlci5jb25maWd1cmUoY3VycmVudE9wdGlvbnMpO1xuXHRcdH1cblxuXHRcdGNvbnN0IGxvZ2dlciA9IHRoaXMubG9nZ2VyUHJvdmlkZXIuZ2V0TG9nZ2VyKG5hbWUpIGFzIExvZ2dlcjxULCBDdXN0b21Pbmx5Pjtcblx0XHR0aGlzLnN1cHBvcnRzTGV2ZWxzKGN1c3RvbUxldmVscywgbG9nZ2VyKTtcblx0XHRyZXR1cm4gbG9nZ2VyO1xuXHR9XG5cblx0cHJpdmF0ZSBzdXBwb3J0c0xldmVsczxUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsIEN1c3RvbU9ubHkgZXh0ZW5kcyB0cnVlID0gdW5kZWZpbmVkPihcblx0XHRjdXN0b21MZXZlbHM6IHtcblx0XHRcdFtsZXZlbCBpbiBUXTogbnVtYmVyO1xuXHRcdH0sXG5cdFx0bG9nZ2VyOiBMb2dnZXI8VCwgQ3VzdG9tT25seT4sXG5cdCkge1xuXHRcdGlmICghY3VzdG9tTGV2ZWxzKSB7XG5cdFx0XHRyZXR1cm47XG5cdFx0fVxuXG5cdFx0Y29uc3QgbWlzc2luZ0xldmVsID0gT2JqZWN0LmVudHJpZXMoY3VzdG9tTGV2ZWxzKS5maW5kKFxuXHRcdFx0KGtleSkgPT4gIWxvZ2dlci5sb2dMZXZlbHNba2V5LmF0KDApLnRvU3RyaW5nKCldLFxuXHRcdCk7XG5cblx0XHRpZiAobWlzc2luZ0xldmVsICE9IG51bGwpIHtcblx0XHRcdHRocm93IG5ldyBMb2dnaW5nQ29uZmlndXJhdGlvbkVycm9yKFxuXHRcdFx0XHRgQ3VycmVudCBsb2dnZXIgd2FzIG5vdCBjb25maWd1cmVkIGZvciBjdXN0b20gbGV2ZWwgJHttaXNzaW5nTGV2ZWx9LCB2YWxpZCBsZXZlbHMgYXJlOiAke0pTT04uc3RyaW5naWZ5KGxvZ2dlci5sb2dMZXZlbHMpfWAsXG5cdFx0XHQpO1xuXHRcdH1cblx0XHRyZXR1cm4geyBtaXNzaW5nTGV2ZWwgfTtcblx0fVxuXG5cdHByaXZhdGUgbWVyZ2VEZWZhdWx0czxUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsIEN1c3RvbU9ubHkgZXh0ZW5kcyB0cnVlIHwgZmFsc2UgPSBmYWxzZT4oXG5cdFx0b3B0aW9ucz86IFNjcmliZU9wdGlvbnM8VCwgQ3VzdG9tT25seT4sXG5cdCk6IFNjcmliZU9wdGlvbnM8VCwgQ3VzdG9tT25seT4ge1xuXHRcdGNvbnN0IGxvZ0xldmVsID0gcmVzb2x2ZUxvZ0xldmVsKG9wdGlvbnM/LmxvZ0xldmVsKSA/PyBEZWZhdWx0TG9nTGV2ZWw7XG5cdFx0cmV0dXJuIHsgbG9nTGV2ZWwsIHJlZGFjdGlvbnM6IERlZmF1bHRSZWRhY3Rpb25zLCAuLi5vcHRpb25zIH07XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJzY3JpYmUiLCJsb2dnZXJQcm92aWRlciIsImluc3RhbmNlIiwibG9nZ2VyIiwibmFtZSIsImN1c3RvbUxldmVscyIsImdldExvZ2dlciIsImNvbmZpZ3VyZSIsImNvbmZpZ09wdGlvbnMiLCJleHRlbmQiLCJmbHVzaCIsImNiIiwiQ29uc29sZUFkYXB0ZXIiLCJkZWZhdWx0T3B0aW9ucyIsIm1lcmdlRGVmYXVsdHMiLCJhZGFwdGVyIiwib3B0aW9ucyIsImRlZmF1bHRzQW5kT3B0aW9ucyIsImN1cnJlbnRPcHRpb25zIiwic3VwcG9ydHNMZXZlbHMiLCJtaXNzaW5nTGV2ZWwiLCJPYmplY3QiLCJlbnRyaWVzIiwiZmluZCIsImtleSIsImxvZ0xldmVscyIsImF0IiwidG9TdHJpbmciLCJMb2dnaW5nQ29uZmlndXJhdGlvbkVycm9yIiwiSlNPTiIsInN0cmluZ2lmeSIsImxvZ0xldmVsIiwicmVzb2x2ZUxvZ0xldmVsIiwiRGVmYXVsdExvZ0xldmVsIiwicmVkYWN0aW9ucyIsIkRlZmF1bHRSZWRhY3Rpb25zIl0sIm1hcHBpbmdzIjoiOzs7OytCQWVhQTs7O2VBQUFBOzs7Z0NBZmtCO3FCQUNDO3dCQUNVO3VCQUc2QjtBQVVoRSxNQUFNQTtJQUNKQyxlQUE4QjtJQUN0QyxPQUFlQyxXQUFtQixJQUFJRixTQUFTO0lBRS9DLE9BQWNHLE9BQ2JDLElBQWEsRUFDYkMsWUFFQyxFQUN1QjtRQUN4QixPQUFPTCxPQUFPRSxRQUFRLENBQUNJLFNBQVMsQ0FBZ0JGLE1BQU1DO0lBSXZEO0lBRUEsT0FBY0UsVUFDYkMsYUFBa0QsRUFDakQ7UUFDRFIsT0FBT0UsUUFBUSxHQUFHLElBQUlGO1FBQ3RCLE9BQU9BLE9BQU9FLFFBQVEsQ0FBQ0ssU0FBUyxDQUFnQkM7SUFDakQ7SUFFQSxXQUFrQkMsU0FBUztRQUMxQixPQUFPVCxPQUFPRSxRQUFRO0lBQ3ZCO0lBRUEsT0FBY1EsTUFBTUMsRUFBZSxFQUFRO1FBQzFDWCxPQUFPRSxRQUFRLENBQUNELGNBQWMsQ0FBQ1MsS0FBSyxDQUFDQztJQUN0QztJQUVBLGFBQXFCO1FBQ3BCLDBDQUEwQztRQUMxQyxJQUFJLENBQUNWLGNBQWMsR0FBRyxJQUFJVyw4QkFBYztRQUN4QyxNQUFNQyxpQkFBaUIsSUFBSSxDQUFDQyxhQUFhO1FBQ3pDLElBQUksQ0FBQ2IsY0FBYyxDQUFDTSxTQUFTLENBQUNNO0lBQy9CO0lBRU9OLFVBQ05DLGFBQWtELEVBQ1A7UUFDM0MsTUFBTSxFQUFFTyxPQUFPLEVBQUVDLE9BQU8sRUFBRSxHQUFHUjtRQUM3QixJQUFJLENBQUNQLGNBQWMsR0FBR2M7UUFDdEIsTUFBTUUscUJBQXFCLElBQUksQ0FBQ0gsYUFBYSxDQUFnQkU7UUFDN0RELFFBQVFSLFNBQVMsQ0FBQ1U7UUFDbEIsT0FBTyxDQUFDYixPQUFrQlcsUUFBUVQsU0FBUyxDQUFDRjtJQUM3QztJQUVPRSxVQUNORixJQUFhLEVBQ2JDLFlBRUMsRUFDdUI7UUFDeEIsb0VBQW9FO1FBQ3BFLElBQUlBLGNBQWM7WUFDakIsTUFBTWEsaUJBQWlCLElBQUksQ0FBQ0osYUFBYSxDQUFDO2dCQUFFVDtZQUFhO1lBQ3pELElBQUksQ0FBQ0osY0FBYyxDQUFDTSxTQUFTLENBQUNXO1FBQy9CO1FBRUEsTUFBTWYsU0FBUyxJQUFJLENBQUNGLGNBQWMsQ0FBQ0ssU0FBUyxDQUFDRjtRQUM3QyxJQUFJLENBQUNlLGNBQWMsQ0FBQ2QsY0FBY0Y7UUFDbEMsT0FBT0E7SUFDUjtJQUVRZ0IsZUFDUGQsWUFFQyxFQUNERixNQUE2QixFQUM1QjtRQUNELElBQUksQ0FBQ0UsY0FBYztZQUNsQjtRQUNEO1FBRUEsTUFBTWUsZUFBZUMsT0FBT0MsT0FBTyxDQUFDakIsY0FBY2tCLElBQUksQ0FDckQsQ0FBQ0MsTUFBUSxDQUFDckIsT0FBT3NCLFNBQVMsQ0FBQ0QsSUFBSUUsRUFBRSxDQUFDLEdBQUdDLFFBQVEsR0FBRztRQUdqRCxJQUFJUCxnQkFBZ0IsTUFBTTtZQUN6QixNQUFNLElBQUlRLGlDQUF5QixDQUNsQyxDQUFDLG1EQUFtRCxFQUFFUixhQUFhLG9CQUFvQixFQUFFUyxLQUFLQyxTQUFTLENBQUMzQixPQUFPc0IsU0FBUyxHQUFHO1FBRTdIO1FBQ0EsT0FBTztZQUFFTDtRQUFhO0lBQ3ZCO0lBRVFOLGNBQ1BFLE9BQXNDLEVBQ1A7UUFDL0IsTUFBTWUsV0FBV0MsSUFBQUEsb0JBQWUsRUFBQ2hCLFNBQVNlLGFBQWFFLHNCQUFlO1FBQ3RFLE9BQU87WUFBRUY7WUFBVUcsWUFBWUMsd0JBQWlCO1lBQUUsR0FBR25CLE9BQU87UUFBQztJQUM5RDtBQUNEIn0=

package/commonjs/src/logger.type.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/commonjs/src/testing/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/commonjs/src/types.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DefaultLogLevel () {
+        return DefaultLogLevel;
+    },
+    get DefaultRedactions () {
+        return DefaultRedactions;
+    },
+    get LogLevels () {
+        return LogLevels;
+    }
+});
+const LOG_LEVELS = [
+    "fatal",
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace"
+];
+const LogLevels = {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10
+};
+const DefaultLogLevel = "info";
+const DefaultRedactions = {
+    paths: [
+        "*.password",
+        "*.secret"
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL3R5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IExPR19MRVZFTFMgPSBbXCJmYXRhbFwiLCBcImVycm9yXCIsIFwid2FyblwiLCBcImluZm9cIiwgXCJkZWJ1Z1wiLCBcInRyYWNlXCJdIGFzIGNvbnN0O1xuXG5leHBvcnQgdHlwZSBMb2dMZXZlbCA9IHR5cGVvZiBMT0dfTEVWRUxTO1xuXG5leHBvcnQgdHlwZSBEZWZhdWx0TGV2ZWxzID0gTG9nTGV2ZWxbbnVtYmVyXTtcblxuZXhwb3J0IGNvbnN0IExvZ0xldmVscyA9IHtcblx0ZmF0YWw6IDYwLFxuXHRlcnJvcjogNTAsXG5cdHdhcm46IDQwLFxuXHRpbmZvOiAzMCxcblx0ZGVidWc6IDIwLFxuXHR0cmFjZTogMTAsXG59IHNhdGlzZmllcyBSZWNvcmQ8RGVmYXVsdExldmVscywgbnVtYmVyPjtcblxuZXhwb3J0IGNvbnN0IERlZmF1bHRMb2dMZXZlbDogRGVmYXVsdExldmVscyA9IFwiaW5mb1wiO1xuXG5leHBvcnQgdHlwZSBSZWRhY3Rpb25PcHRpb25zID0ge1xuXHRwYXRoczogc3RyaW5nW107XG59O1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdFJlZGFjdGlvbnM6IFJlZGFjdGlvbk9wdGlvbnMgPSB7IHBhdGhzOiBbXCIqLnBhc3N3b3JkXCIsIFwiKi5zZWNyZXRcIl0gfTtcblxuZXhwb3J0IGludGVyZmFjZSBTY3JpYmVPcHRpb25zPFxuXHRUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsXG5cdEN1c3RvbU9ubHkgZXh0ZW5kcyB0cnVlIHwgZmFsc2UgPSB1bmRlZmluZWQsXG4+IHtcblx0bG9nTGV2ZWw/OiBEZWZhdWx0TGV2ZWxzIHwgc3RyaW5nO1xuXHRjdXN0b21MZXZlbHM/OiB7XG5cdFx0W2xldmVsIGluIFRdOiBudW1iZXI7XG5cdH07XG5cdGN1c3RvbU9ubHk/OiBDdXN0b21Pbmx5O1xuXHRyZWRhY3Rpb25zPzogUmVkYWN0aW9uT3B0aW9ucztcbn1cblxuZXhwb3J0IHR5cGUgTG9nQWRhcHRlck9wdGlvbnMgPSBSZWNvcmQ8c3RyaW5nLCBuZXZlcj47XG4iXSwibmFtZXMiOlsiRGVmYXVsdExvZ0xldmVsIiwiRGVmYXVsdFJlZGFjdGlvbnMiLCJMb2dMZXZlbHMiLCJMT0dfTEVWRUxTIiwiZmF0YWwiLCJlcnJvciIsIndhcm4iLCJpbmZvIiwiZGVidWciLCJ0cmFjZSIsInBhdGhzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztRQWVhQTtlQUFBQTs7UUFNQUM7ZUFBQUE7O1FBZkFDO2VBQUFBOzs7QUFOYixNQUFNQyxhQUFhO0lBQUM7SUFBUztJQUFTO0lBQVE7SUFBUTtJQUFTO0NBQVE7QUFNaEUsTUFBTUQsWUFBWTtJQUN4QkUsT0FBTztJQUNQQyxPQUFPO0lBQ1BDLE1BQU07SUFDTkMsTUFBTTtJQUNOQyxPQUFPO0lBQ1BDLE9BQU87QUFDUjtBQUVPLE1BQU1ULGtCQUFpQztBQU12QyxNQUFNQyxvQkFBc0M7SUFBRVMsT0FBTztRQUFDO1FBQWM7S0FBVztBQUFDIn0=

package/es6/src/console.adapter.js

@@ -0,0 +1,64 @@
+import { formatError, LogAdapter } from "./logger.adapter.js";
+import { DefaultLogLevel, LogLevels } from "./types.js";
+export class ConsoleAdapter extends LogAdapter {
+    configuredLevels;
+    configuredLogLevel = DefaultLogLevel;
+    configuredLogLevelValue = LogLevels.info;
+    constructor(_options = {}){
+        super();
+    }
+    configure(scribeOptions) {
+        // Get merged log levels (default + custom) using parent class method
+        this.configuredLevels = this.getLogLevels(scribeOptions);
+        const logLevelStr = scribeOptions.logLevel ?? DefaultLogLevel;
+        this.configuredLogLevel = logLevelStr;
+        this.configuredLogLevelValue = this.configuredLevels[logLevelStr] ?? LogLevels.info;
+    }
+    getLogger(name) {
+        const loggerName = name || "default";
+        return this.createConsoleLogger(loggerName);
+    }
+    createConsoleLogger(name) {
+        // Use the levels configured during the configure() call
+        const allLevels = this.configuredLevels;
+        const currentLevel = this.configuredLogLevel;
+        const threshold = this.configuredLogLevelValue;
+        const baseLogger = {
+            get currentLevel () {
+                return currentLevel;
+            },
+            get logLevels () {
+                return allLevels;
+            }
+        };
+        const logFunction = (level)=>(msg, ...args)=>{
+                const timestamp = new Date().toISOString();
+                let message;
+                if (typeof msg === "object") {
+                    message = msg instanceof Error ? formatError(msg) : JSON.stringify(msg);
+                } else {
+                    message = String(msg);
+                }
+                const logLine = `[${timestamp}] ${level.toUpperCase()} [${name}]: ${message}`;
+                if (args.length > 0) {
+                    console.log(logLine, ...args);
+                } else {
+                    console.log(logLine);
+                }
+            };
+        const noop = ()=>{};
+        // Start with base logger and isLevelEnabled method
+        const logger = Object.assign(baseLogger, {
+            isLevelEnabled: (level)=>(allLevels[level] ?? 0) >= threshold
+        });
+        // Dynamically add all log level methods (default + custom)
+        // Levels below the configured threshold are patched to noop
+        for (const [levelName, levelValue] of Object.entries(allLevels)){
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic logger level creation requires any
+            logger[levelName] = levelValue >= threshold ? logFunction(levelName) : noop;
+        }
+        return logger;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2NvbnNvbGUuYWRhcHRlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBmb3JtYXRFcnJvciwgTG9nQWRhcHRlciB9IGZyb20gXCIuL2xvZ2dlci5hZGFwdGVyLmpzXCI7XG5pbXBvcnQgdHlwZSB7IEJhc2VMb2dnZXIsIExvZ2dlciB9IGZyb20gXCIuL2xvZ2dlci50eXBlLmpzXCI7XG5pbXBvcnQge1xuXHREZWZhdWx0TG9nTGV2ZWwsXG5cdHR5cGUgTG9nQWRhcHRlck9wdGlvbnMsXG5cdExvZ0xldmVscyxcblx0dHlwZSBTY3JpYmVPcHRpb25zLFxufSBmcm9tIFwiLi90eXBlcy5qc1wiO1xuXG5leHBvcnQgdHlwZSBDb25zb2xlQWRhcHRlck9wdGlvbnMgPSB7fSAmIExvZ0FkYXB0ZXJPcHRpb25zO1xuXG5leHBvcnQgY2xhc3MgQ29uc29sZUFkYXB0ZXIgZXh0ZW5kcyBMb2dBZGFwdGVyIHtcblx0cHJpdmF0ZSBjb25maWd1cmVkTGV2ZWxzOiBSZWNvcmQ8c3RyaW5nLCBudW1iZXI+O1xuXHRwcml2YXRlIGNvbmZpZ3VyZWRMb2dMZXZlbDogc3RyaW5nID0gRGVmYXVsdExvZ0xldmVsO1xuXHRwcml2YXRlIGNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlOiBudW1iZXIgPSBMb2dMZXZlbHMuaW5mbztcblxuXHRwdWJsaWMgY29uc3RydWN0b3IoX29wdGlvbnM6IENvbnNvbGVBZGFwdGVyT3B0aW9ucyA9IHt9KSB7XG5cdFx0c3VwZXIoKTtcblx0fVxuXG5cdHB1YmxpYyBjb25maWd1cmU8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdHNjcmliZU9wdGlvbnM6IFNjcmliZU9wdGlvbnM8VCwgQ3VzdG9tT25seT4sXG5cdCkge1xuXHRcdC8vIEdldCBtZXJnZWQgbG9nIGxldmVscyAoZGVmYXVsdCArIGN1c3RvbSkgdXNpbmcgcGFyZW50IGNsYXNzIG1ldGhvZFxuXHRcdHRoaXMuY29uZmlndXJlZExldmVscyA9IHRoaXMuZ2V0TG9nTGV2ZWxzKHNjcmliZU9wdGlvbnMpO1xuXHRcdGNvbnN0IGxvZ0xldmVsU3RyID0gc2NyaWJlT3B0aW9ucy5sb2dMZXZlbCA/PyBEZWZhdWx0TG9nTGV2ZWw7XG5cdFx0dGhpcy5jb25maWd1cmVkTG9nTGV2ZWwgPSBsb2dMZXZlbFN0cjtcblx0XHR0aGlzLmNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlID0gdGhpcy5jb25maWd1cmVkTGV2ZWxzW2xvZ0xldmVsU3RyXSA/PyBMb2dMZXZlbHMuaW5mbztcblx0fVxuXG5cdHB1YmxpYyBnZXRMb2dnZXI8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdG5hbWU/OiBzdHJpbmcsXG5cdCk6IExvZ2dlcjxULCBDdXN0b21Pbmx5PiB7XG5cdFx0Y29uc3QgbG9nZ2VyTmFtZSA9IG5hbWUgfHwgXCJkZWZhdWx0XCI7XG5cdFx0cmV0dXJuIHRoaXMuY3JlYXRlQ29uc29sZUxvZ2dlcjxULCBDdXN0b21Pbmx5Pihsb2dnZXJOYW1lKTtcblx0fVxuXG5cdHByaXZhdGUgY3JlYXRlQ29uc29sZUxvZ2dlcjxcblx0XHRUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsXG5cdFx0Q3VzdG9tT25seSBleHRlbmRzIHRydWUgfCBmYWxzZSA9IGZhbHNlLFxuXHQ+KG5hbWU6IHN0cmluZyk6IExvZ2dlcjxULCBDdXN0b21Pbmx5PiB7XG5cdFx0Ly8gVXNlIHRoZSBsZXZlbHMgY29uZmlndXJlZCBkdXJpbmcgdGhlIGNvbmZpZ3VyZSgpIGNhbGxcblx0XHRjb25zdCBhbGxMZXZlbHMgPSB0aGlzLmNvbmZpZ3VyZWRMZXZlbHM7XG5cdFx0Y29uc3QgY3VycmVudExldmVsID0gdGhpcy5jb25maWd1cmVkTG9nTGV2ZWw7XG5cdFx0Y29uc3QgdGhyZXNob2xkID0gdGhpcy5jb25maWd1cmVkTG9nTGV2ZWxWYWx1ZTtcblxuXHRcdGNvbnN0IGJhc2VMb2dnZXI6IEJhc2VMb2dnZXIgPSB7XG5cdFx0XHRnZXQgY3VycmVudExldmVsKCkge1xuXHRcdFx0XHRyZXR1cm4gY3VycmVudExldmVsO1xuXHRcdFx0fSxcblx0XHRcdGdldCBsb2dMZXZlbHMoKSB7XG5cdFx0XHRcdHJldHVybiBhbGxMZXZlbHM7XG5cdFx0XHR9LFxuXHRcdH07XG5cblx0XHRjb25zdCBsb2dGdW5jdGlvbiA9XG5cdFx0XHQobGV2ZWw6IHN0cmluZykgPT5cblx0XHRcdChtc2c6IHN0cmluZyB8IG51bWJlciB8IG9iamVjdCwgLi4uYXJnczogdW5rbm93bltdKSA9PiB7XG5cdFx0XHRcdGNvbnN0IHRpbWVzdGFtcCA9IG5ldyBEYXRlKCkudG9JU09TdHJpbmcoKTtcblx0XHRcdFx0bGV0IG1lc3NhZ2U6IHN0cmluZztcblxuXHRcdFx0XHRpZiAodHlwZW9mIG1zZyA9PT0gXCJvYmplY3RcIikge1xuXHRcdFx0XHRcdG1lc3NhZ2UgPSBtc2cgaW5zdGFuY2VvZiBFcnJvciA/IGZvcm1hdEVycm9yKG1zZykgOiBKU09OLnN0cmluZ2lmeShtc2cpO1xuXHRcdFx0XHR9IGVsc2Uge1xuXHRcdFx0XHRcdG1lc3NhZ2UgPSBTdHJpbmcobXNnKTtcblx0XHRcdFx0fVxuXG5cdFx0XHRcdGNvbnN0IGxvZ0xpbmUgPSBgWyR7dGltZXN0YW1wfV0gJHtsZXZlbC50b1VwcGVyQ2FzZSgpfSBbJHtuYW1lfV06ICR7bWVzc2FnZX1gO1xuXG5cdFx0XHRcdGlmIChhcmdzLmxlbmd0aCA+IDApIHtcblx0XHRcdFx0XHRjb25zb2xlLmxvZyhsb2dMaW5lLCAuLi5hcmdzKTtcblx0XHRcdFx0fSBlbHNlIHtcblx0XHRcdFx0XHRjb25zb2xlLmxvZyhsb2dMaW5lKTtcblx0XHRcdFx0fVxuXHRcdFx0fTtcblxuXHRcdGNvbnN0IG5vb3AgPSAoKSA9PiB7fTtcblxuXHRcdC8vIFN0YXJ0IHdpdGggYmFzZSBsb2dnZXIgYW5kIGlzTGV2ZWxFbmFibGVkIG1ldGhvZFxuXHRcdGNvbnN0IGxvZ2dlciA9IE9iamVjdC5hc3NpZ24oYmFzZUxvZ2dlciwge1xuXHRcdFx0aXNMZXZlbEVuYWJsZWQ6IChsZXZlbDogc3RyaW5nKSA9PiAoYWxsTGV2ZWxzW2xldmVsXSA/PyAwKSA+PSB0aHJlc2hvbGQsXG5cdFx0fSk7XG5cblx0XHQvLyBEeW5hbWljYWxseSBhZGQgYWxsIGxvZyBsZXZlbCBtZXRob2RzIChkZWZhdWx0ICsgY3VzdG9tKVxuXHRcdC8vIExldmVscyBiZWxvdyB0aGUgY29uZmlndXJlZCB0aHJlc2hvbGQgYXJlIHBhdGNoZWQgdG8gbm9vcFxuXHRcdGZvciAoY29uc3QgW2xldmVsTmFtZSwgbGV2ZWxWYWx1ZV0gb2YgT2JqZWN0LmVudHJpZXMoYWxsTGV2ZWxzKSkge1xuXHRcdFx0Ly8gYmlvbWUtaWdub3JlIGxpbnQvc3VzcGljaW91cy9ub0V4cGxpY2l0QW55OiBEeW5hbWljIGxvZ2dlciBsZXZlbCBjcmVhdGlvbiByZXF1aXJlcyBhbnlcblx0XHRcdChsb2dnZXIgYXMgYW55KVtsZXZlbE5hbWVdID0gbGV2ZWxWYWx1ZSA+PSB0aHJlc2hvbGQgPyBsb2dGdW5jdGlvbihsZXZlbE5hbWUpIDogbm9vcDtcblx0XHR9XG5cblx0XHRyZXR1cm4gbG9nZ2VyIGFzIExvZ2dlcjxULCBDdXN0b21Pbmx5Pjtcblx0fVxufVxuIl0sIm5hbWVzIjpbImZvcm1hdEVycm9yIiwiTG9nQWRhcHRlciIsIkRlZmF1bHRMb2dMZXZlbCIsIkxvZ0xldmVscyIsIkNvbnNvbGVBZGFwdGVyIiwiY29uZmlndXJlZExldmVscyIsImNvbmZpZ3VyZWRMb2dMZXZlbCIsImNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlIiwiaW5mbyIsIl9vcHRpb25zIiwiY29uZmlndXJlIiwic2NyaWJlT3B0aW9ucyIsImdldExvZ0xldmVscyIsImxvZ0xldmVsU3RyIiwibG9nTGV2ZWwiLCJnZXRMb2dnZXIiLCJuYW1lIiwibG9nZ2VyTmFtZSIsImNyZWF0ZUNvbnNvbGVMb2dnZXIiLCJhbGxMZXZlbHMiLCJjdXJyZW50TGV2ZWwiLCJ0aHJlc2hvbGQiLCJiYXNlTG9nZ2VyIiwibG9nTGV2ZWxzIiwibG9nRnVuY3Rpb24iLCJsZXZlbCIsIm1zZyIsImFyZ3MiLCJ0aW1lc3RhbXAiLCJEYXRlIiwidG9JU09TdHJpbmciLCJtZXNzYWdlIiwiRXJyb3IiLCJKU09OIiwic3RyaW5naWZ5IiwiU3RyaW5nIiwibG9nTGluZSIsInRvVXBwZXJDYXNlIiwibGVuZ3RoIiwiY29uc29sZSIsImxvZyIsIm5vb3AiLCJsb2dnZXIiLCJPYmplY3QiLCJhc3NpZ24iLCJpc0xldmVsRW5hYmxlZCIsImxldmVsTmFtZSIsImxldmVsVmFsdWUiLCJlbnRyaWVzIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxXQUFXLEVBQUVDLFVBQVUsUUFBUSxzQkFBc0I7QUFFOUQsU0FDQ0MsZUFBZSxFQUVmQyxTQUFTLFFBRUgsYUFBYTtBQUlwQixPQUFPLE1BQU1DLHVCQUF1Qkg7SUFDM0JJLGlCQUF5QztJQUN6Q0MscUJBQTZCSixnQkFBZ0I7SUFDN0NLLDBCQUFrQ0osVUFBVUssSUFBSSxDQUFDO0lBRXpELFlBQW1CQyxXQUFrQyxDQUFDLENBQUMsQ0FBRTtRQUN4RCxLQUFLO0lBQ047SUFFT0MsVUFDTkMsYUFBMkMsRUFDMUM7UUFDRCxxRUFBcUU7UUFDckUsSUFBSSxDQUFDTixnQkFBZ0IsR0FBRyxJQUFJLENBQUNPLFlBQVksQ0FBQ0Q7UUFDMUMsTUFBTUUsY0FBY0YsY0FBY0csUUFBUSxJQUFJWjtRQUM5QyxJQUFJLENBQUNJLGtCQUFrQixHQUFHTztRQUMxQixJQUFJLENBQUNOLHVCQUF1QixHQUFHLElBQUksQ0FBQ0YsZ0JBQWdCLENBQUNRLFlBQVksSUFBSVYsVUFBVUssSUFBSTtJQUNwRjtJQUVPTyxVQUNOQyxJQUFhLEVBQ1c7UUFDeEIsTUFBTUMsYUFBYUQsUUFBUTtRQUMzQixPQUFPLElBQUksQ0FBQ0UsbUJBQW1CLENBQWdCRDtJQUNoRDtJQUVRQyxvQkFHTkYsSUFBWSxFQUF5QjtRQUN0Qyx3REFBd0Q7UUFDeEQsTUFBTUcsWUFBWSxJQUFJLENBQUNkLGdCQUFnQjtRQUN2QyxNQUFNZSxlQUFlLElBQUksQ0FBQ2Qsa0JBQWtCO1FBQzVDLE1BQU1lLFlBQVksSUFBSSxDQUFDZCx1QkFBdUI7UUFFOUMsTUFBTWUsYUFBeUI7WUFDOUIsSUFBSUYsZ0JBQWU7Z0JBQ2xCLE9BQU9BO1lBQ1I7WUFDQSxJQUFJRyxhQUFZO2dCQUNmLE9BQU9KO1lBQ1I7UUFDRDtRQUVBLE1BQU1LLGNBQ0wsQ0FBQ0MsUUFDRCxDQUFDQyxLQUErQixHQUFHQztnQkFDbEMsTUFBTUMsWUFBWSxJQUFJQyxPQUFPQyxXQUFXO2dCQUN4QyxJQUFJQztnQkFFSixJQUFJLE9BQU9MLFFBQVEsVUFBVTtvQkFDNUJLLFVBQVVMLGVBQWVNLFFBQVFoQyxZQUFZMEIsT0FBT08sS0FBS0MsU0FBUyxDQUFDUjtnQkFDcEUsT0FBTztvQkFDTkssVUFBVUksT0FBT1Q7Z0JBQ2xCO2dCQUVBLE1BQU1VLFVBQVUsQ0FBQyxDQUFDLEVBQUVSLFVBQVUsRUFBRSxFQUFFSCxNQUFNWSxXQUFXLEdBQUcsRUFBRSxFQUFFckIsS0FBSyxHQUFHLEVBQUVlLFNBQVM7Z0JBRTdFLElBQUlKLEtBQUtXLE1BQU0sR0FBRyxHQUFHO29CQUNwQkMsUUFBUUMsR0FBRyxDQUFDSixZQUFZVDtnQkFDekIsT0FBTztvQkFDTlksUUFBUUMsR0FBRyxDQUFDSjtnQkFDYjtZQUNEO1FBRUQsTUFBTUssT0FBTyxLQUFPO1FBRXBCLG1EQUFtRDtRQUNuRCxNQUFNQyxTQUFTQyxPQUFPQyxNQUFNLENBQUN0QixZQUFZO1lBQ3hDdUIsZ0JBQWdCLENBQUNwQixRQUFrQixBQUFDTixDQUFBQSxTQUFTLENBQUNNLE1BQU0sSUFBSSxDQUFBLEtBQU1KO1FBQy9EO1FBRUEsMkRBQTJEO1FBQzNELDREQUE0RDtRQUM1RCxLQUFLLE1BQU0sQ0FBQ3lCLFdBQVdDLFdBQVcsSUFBSUosT0FBT0ssT0FBTyxDQUFDN0IsV0FBWTtZQUNoRSx5RkFBeUY7WUFDeEZ1QixNQUFjLENBQUNJLFVBQVUsR0FBR0MsY0FBYzFCLFlBQVlHLFlBQVlzQixhQUFhTDtRQUNqRjtRQUVBLE9BQU9DO0lBQ1I7QUFDRCJ9

package/es6/src/logger.adapter.js

@@ -0,0 +1,27 @@
+import { LogLevels } from "./types.js";
+export function formatError(err) {
+    return err.stack ?? err.message;
+}
+export class LogAdapter {
+    flush(cb) {
+        cb?.();
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: Generic utility method needs flexible typing
+    getLogLevels(options) {
+        const { customOnly, customLevels } = options;
+        if (customOnly) {
+            return customLevels;
+        }
+        const levels = this.getUniqueLevels(LogLevels, customLevels);
+        return Object.fromEntries(levels);
+    }
+    getUniqueLevels(defaultLevels, customLevels) {
+        const defaultEntries = Object.entries(defaultLevels ?? {});
+        const customEntries = Object.entries(customLevels ?? {});
+        const defaultNotInCustom = defaultEntries.filter(([dk])=>customEntries.findIndex(([ck])=>ck === dk) === -1);
+        const unique = defaultNotInCustom.concat(customEntries);
+        return unique;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe",
-  "version": "0.0.1-dev.4",
+  "version": "0.0.1-dev.40",
   "description": "Structured logging interface with pluggable adapters",
   "keywords": [
     "typescript",

package/types/src/console.adapter.d.ts

@@ -0,0 +1,13 @@
+import { LogAdapter } from "./logger.adapter.js";
+import type { Logger } from "./logger.type.js";
+import { type LogAdapterOptions, type ScribeOptions } from "./types.js";
+export type ConsoleAdapterOptions = {} & LogAdapterOptions;
+export declare class ConsoleAdapter extends LogAdapter {
+    private configuredLevels;
+    private configuredLogLevel;
+    private configuredLogLevelValue;
+    constructor(_options?: ConsoleAdapterOptions);
+    configure<T extends string = never, CustomOnly extends true | false = false>(scribeOptions: ScribeOptions<T, CustomOnly>): void;
+    getLogger<T extends string = never, CustomOnly extends true | false = false>(name?: string): Logger<T, CustomOnly>;
+    private createConsoleLogger;
+}

package/types/src/env.d.ts

@@ -0,0 +1,27 @@
+import type { DefaultLevels } from "./types.js";
+/**
+ * Reads the log level from environment variables.
+ * Checks LOG_LEVEL, SCRIBE_LOG_LEVEL, and LOGGING_LEVEL in order.
+ * Returns null if none are set.
+ */
+export declare function getLogLevelFromEnv(): string | null;
+/**
+ * Reads a log-level flag from argv.
+ * Supports: --log-level <value>, -l <value>, and --log-level=<value>
+ */
+export declare function getLogLevelFromArgv(argv: readonly string[]): string | undefined;
+/**
+ * Returns true if the given string is a recognised default log level.
+ */
+export declare function isValidLogLevel(level: string): level is DefaultLevels;
+export type ResolveLogLevelOptions = {
+    explicitLogLevel?: string | null;
+    envLogLevel?: string | null;
+    defaultLogLevel: string;
+};
+/**
+ * Resolves log level with precedence: explicit > env > default.
+ * Invalid explicit/env levels fall back to default.
+ */
+export declare function resolveLogLevel(explicitLogLevel?: string | null): string | null;
+export declare function resolveLogLevel(options: ResolveLogLevelOptions): string;

package/types/src/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class LoggingConfigurationError extends Error {
+}

package/types/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./console.adapter.js";
+export * from "./env.js";
+export * from "./errors.js";
+export * from "./logger.adapter.js";
+export * from "./logger.factory.js";
+export * from "./logger.type.js";
+export * from "./types.js";

package/types/src/logger.adapter.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "./logger.type.js";
+import { type ScribeOptions } from "./types.js";
+export declare function formatError(err: Error): string;
+export interface LoggerAdapter {
+    configure<T extends string = never, CustomOnly extends true | false = false>(options: ScribeOptions<T, CustomOnly>): any;
+    getLogger<T extends string = never, CustomOnly extends true | false = false>(name: string): Logger<T, CustomOnly>;
+    flush(cb?: () => void): void;
+}
+export declare abstract class LogAdapter implements LoggerAdapter {
+    abstract configure<T extends string = never, CustomOnly extends true | false = false>(options: ScribeOptions<T, CustomOnly>): any;
+    abstract getLogger<T extends string = never, CustomOnly extends true | false = false>(name: string): Logger<T, CustomOnly>;
+    flush(cb?: () => void): void;
+    protected getLogLevels(options: ScribeOptions<any, any>): Record<string, number>;
+    protected getUniqueLevels(defaultLevels: Record<string, number>, customLevels: Record<string, number>): [string, number][];
+}