@tstdl/base 0.92.166 → 0.92.168

package/lock/web/web-lock.js

@@ -4,61 +4,68 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { map, timer } from 'rxjs';
-import { CancellationToken } from '../../cancellation/index.js';
 import { Injectable } from '../../injector/index.js';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
-import { assertStringPass, isDefined, isNull, isObject } from '../../utils/type-guards.js';
+import { assertStringPass, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { Lock } from '../lock.js';
 import { WebLockProvider } from './web-lock.provider.js';
 let WebLock = class WebLock extends Lock {
-    async acquire(timeout, throwOnFail) {
-        const acquirePromise = new DeferredPromise();
+    async tryAcquireOnce() {
+        return await this.tryAcquire(0);
+    }
+    async tryAcquire(timeout) {
+        const controllerPromise = new DeferredPromise();
         const releasePromise = new DeferredPromise();
-        const controller = {
-            lost: false,
-            release() {
-                releasePromise.resolve();
-            },
-        };
-        const timeoutToken = (isDefined(timeout) && (timeout > 0)) ? CancellationToken.from(timer(timeout).pipe(map(() => true))) : undefined;
-        void navigator.locks.request(this.resource, {
-            signal: isDefined(timeoutToken) ? timeoutToken.asAbortSignal() : undefined,
-            ifAvailable: isDefined(timeout) && (timeout <= 0),
-        }, async (lock) => {
+        const ifAvailable = isUndefined(timeout) || (timeout <= 0);
+        const signal = ifAvailable ? undefined : AbortSignal.any([AbortSignal.timeout(timeout), this.cancellationSignal.asAbortSignal()]);
+        await navigator.locks
+            .request(this.resource, { signal, ifAvailable }, async (lock) => {
             if (isNull(lock)) {
-                acquirePromise.resolve(false);
-                return;
+                throw new Error('Failed to acquire lock.');
             }
-            acquirePromise.resolve(true);
+            let lost = false;
+            controllerPromise.resolve({
+                get lost() {
+                    return lost;
+                },
+                async release() {
+                    releasePromise.resolve();
+                },
+            });
             await releasePromise;
+            lost = true;
         })
-            .catch((error) => acquirePromise.reject(error));
-        try {
-            const success = await acquirePromise;
-            if (!success) {
-                throw new Error('Failed to acquire lock.');
-            }
-            return controller;
-        }
-        catch (error) {
-            if (throwOnFail) {
-                throw error;
-            }
-            return false;
-        }
+            .catch(() => controllerPromise.resolve(false));
+        return await controllerPromise;
     }
-    async use(timeout, throwOnFail, func) {
-        const controller = await this.acquire(timeout, throwOnFail);
-        if (controller == false) {
-            return { success: false, result: undefined };
-        }
+    async tryUse(timeout, func) {
+        const ifAvailable = isUndefined(timeout) || (timeout <= 0);
+        const signal = ifAvailable ? undefined : AbortSignal.any([AbortSignal.timeout(timeout), this.cancellationSignal.asAbortSignal()]);
+        let result;
         try {
-            const result = await func(controller);
-            return { success: true, result };
+            result = await navigator.locks.request(this.resource, { signal, ifAvailable }, async (lock) => {
+                if (isNull(lock)) {
+                    return { type: 'already-locked' };
+                }
+                try {
+                    const returnValue = await func({ lost: false });
+                    return { type: 'result', value: returnValue };
+                }
+                catch (error) {
+                    return { type: 'error', error };
+                }
+            });
+        }
+        catch {
+            return { success: false }; // navigator.locks.request throws a DOMException on timeout
         }
-        finally {
-            await controller.release();
+        switch (result.type) {
+            case 'result':
+                return { success: true, result: result.value };
+            case 'already-locked':
+                return { success: false };
+            case 'error':
+                throw result.error;
         }
     }
     async exists() {

package/lock/web/web-lock.provider.d.ts

@@ -1,8 +1,5 @@
 import type { Lock } from '../../lock/index.js';
 import { LockProvider } from '../../lock/index.js';
 export declare class WebLockProvider extends LockProvider {
-    private readonly _prefix;
-    constructor(prefix?: string);
-    prefix(prefix: string): LockProvider;
     get(resource: string): Lock;
 }

package/lock/web/web-lock.provider.js

@@ -4,32 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var WebLockProvider_1;
-import { InjectArg, Singleton } from '../../injector/index.js';
+import { Singleton } from '../../injector/index.js';
 import { LockProvider } from '../../lock/index.js';
 import { WebLock } from './web-lock.js';
-let WebLockProvider = WebLockProvider_1 = class WebLockProvider extends LockProvider {
-    _prefix;
-    constructor(prefix = '') {
-        super();
-        this._prefix = prefix;
-    }
-    prefix(prefix) {
-        return new WebLockProvider_1(this._prefix + prefix);
-    }
+let WebLockProvider = class WebLockProvider extends LockProvider {
     get(resource) {
-        return new WebLock(this._prefix + resource);
+        return new WebLock(this.getResourceString(resource, this._prefix), this.cancellationSignal);
     }
 };
-WebLockProvider = WebLockProvider_1 = __decorate([
-    Singleton(),
-    __param(0, InjectArg()),
-    __metadata("design:paramtypes", [String])
+WebLockProvider = __decorate([
+    Singleton()
 ], WebLockProvider);
 export { WebLockProvider };

package/logger/formatter.d.ts

@@ -0,0 +1,13 @@
+import type { Record } from '../types/types.js';
+import type { LogLevel } from './level.js';
+export type LogPayload = {
+    timestamp: Date;
+    level: LogLevel;
+    module: string[];
+    message: string;
+    context: Record<string>;
+};
+/** Formats a log payload for a transport. */
+export declare abstract class LogFormatter {
+    abstract format(payload: LogPayload): string;
+}

package/logger/formatter.js

@@ -0,0 +1,3 @@
+/** Formats a log payload for a transport. */
+export class LogFormatter {
+}

package/logger/formatters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './json.js';
+export * from './pretty-print.js';

package/logger/formatters/index.js

@@ -0,0 +1,2 @@
+export * from './json.js';
+export * from './pretty-print.js';

package/logger/formatters/json.d.ts

@@ -0,0 +1,5 @@
+import { LogFormatter, type LogPayload } from '../formatter.js';
+/** Formats log entries as a JSON string. */
+export declare class JsonLogFormatter extends LogFormatter {
+    format(payload: LogPayload): string;
+}

package/logger/formatters/json.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { enumValueName } from '../../utils/enum.js';
+import { formatError } from '../../utils/format-error.js';
+import { isNotNullOrUndefined } from '../../utils/type-guards.js';
+import { LogFormatter } from '../formatter.js';
+import { LogLevel } from '../level.js';
+/** Formats log entries as a JSON string. */
+let JsonLogFormatter = class JsonLogFormatter extends LogFormatter {
+    format(payload) {
+        const logObject = {
+            timestamp: payload.timestamp.toISOString(),
+            level: enumValueName(LogLevel, payload.level).toLowerCase(),
+            module: (payload.module.length > 0) ? payload.module.join('.') : null,
+            message: payload.message,
+            ...payload.context,
+        };
+        // Special handling for error objects to make them serializable
+        if (isNotNullOrUndefined(logObject['error'])) {
+            logObject['error'] = formatError(logObject['error'], { includeStack: true });
+        }
+        return JSON.stringify(logObject);
+    }
+};
+JsonLogFormatter = __decorate([
+    Singleton()
+], JsonLogFormatter);
+export { JsonLogFormatter };

package/logger/formatters/pretty-print.d.ts

@@ -0,0 +1,5 @@
+import { LogFormatter, type LogPayload } from '../formatter.js';
+/** Formats log entries in a human-readable, colorful format for development consoles. */
+export declare class PrettyPrintLogFormatter extends LogFormatter {
+    format(payload: LogPayload): string;
+}

package/logger/formatters/pretty-print.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { enumValueName } from '../../utils/enum.js';
+import { formatError } from '../../utils/format-error.js';
+import { isNotNullOrUndefined } from '../../utils/type-guards.js';
+import { LogFormatter } from '../formatter.js';
+import { LogLevel } from '../level.js';
+const levelColorMap = {
+    [LogLevel.Error]: '\x1b[31m', // Red
+    [LogLevel.Warn]: '\x1b[33m', // Yellow
+    [LogLevel.Info]: '\x1b[32m', // Green
+    [LogLevel.Verbose]: '\x1b[36m', // Cyan
+    [LogLevel.Debug]: '\x1b[34m', // Blue
+    [LogLevel.Trace]: '\x1b[90m', // Gray
+};
+const resetColor = '\x1b[0m';
+const dimColor = '\x1b[2m';
+/** Formats log entries in a human-readable, colorful format for development consoles. */
+let PrettyPrintLogFormatter = class PrettyPrintLogFormatter extends LogFormatter {
+    format(payload) {
+        const color = levelColorMap[payload.level];
+        const levelName = enumValueName(LogLevel, payload.level).toUpperCase();
+        const levelString = `${levelName}:`.padEnd(8);
+        const moduleString = payload.module.map((m) => `[${m}]`).join(' ');
+        const metadata = { ...payload.context };
+        let metadataString = '';
+        let errorString = '';
+        if (Object.keys(metadata).length > 0) {
+            const displayMeta = {};
+            // Don't display metadata used in interpolation
+            const interpolationKeys = Array.from(payload.message.matchAll(/{([^{}]+)}/g)).map((match) => match[1]);
+            for (const key in metadata) {
+                if (!interpolationKeys.includes(key)) {
+                    displayMeta[key] = metadata[key];
+                }
+            }
+            if (Object.keys(displayMeta).length > 0) {
+                metadataString = ` ${dimColor}${JSON.stringify(displayMeta)}${resetColor}`;
+            }
+            if (isNotNullOrUndefined(metadata['error'])) {
+                errorString += `\n${formatError(metadata['error'], { includeStack: true })}`;
+            }
+        }
+        return `${dimColor}${payload.timestamp.toISOString()}${resetColor} ${color}${levelString}${resetColor} ${moduleString}${moduleString.length > 0 ? ' ' : ''}${payload.message}${metadataString}${errorString}`;
+    }
+};
+PrettyPrintLogFormatter = __decorate([
+    Singleton()
+], PrettyPrintLogFormatter);
+export { PrettyPrintLogFormatter };

package/logger/index.d.ts

@@ -3,8 +3,11 @@
  *
  * @module Logger
  */
-export * from './console/index.js';
+export * from './formatter.js';
+export * from './formatters/index.js';
 export * from './level.js';
 export * from './logger.js';
-export * from './noop/index.js';
+export * from './manager.js';
 export * from './tokens.js';
+export * from './transport.js';
+export * from './transports/index.js';

package/logger/index.js

@@ -3,8 +3,11 @@
  *
  * @module Logger
  */
-export * from './console/index.js';
+export * from './formatter.js';
+export * from './formatters/index.js';
 export * from './level.js';
 export * from './logger.js';
-export * from './noop/index.js';
+export * from './manager.js';
 export * from './tokens.js';
+export * from './transport.js';
+export * from './transports/index.js';

package/logger/level.d.ts

@@ -1,8 +1,10 @@
-export declare enum LogLevel {
-    Error = 0,
-    Warn = 1,
-    Info = 2,
-    Verbose = 3,
-    Debug = 4,
-    Trace = 5
-}
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const LogLevel: {
+    readonly Error: 0;
+    readonly Warn: 1;
+    readonly Info: 2;
+    readonly Verbose: 3;
+    readonly Debug: 4;
+    readonly Trace: 5;
+};
+export type LogLevel = EnumType<typeof LogLevel>;

package/logger/level.js

@@ -1,9 +1,9 @@
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["Error"] = 0] = "Error";
-    LogLevel[LogLevel["Warn"] = 1] = "Warn";
-    LogLevel[LogLevel["Info"] = 2] = "Info";
-    LogLevel[LogLevel["Verbose"] = 3] = "Verbose";
-    LogLevel[LogLevel["Debug"] = 4] = "Debug";
-    LogLevel[LogLevel["Trace"] = 5] = "Trace";
-})(LogLevel || (LogLevel = {}));
+import { defineEnum } from '../enumeration/enumeration.js';
+export const LogLevel = defineEnum('LogLevel', {
+    Error: 0,
+    Warn: 1,
+    Info: 2,
+    Verbose: 3,
+    Debug: 4,
+    Trace: 5,
+});

package/logger/logger.d.ts

@@ -1,41 +1,32 @@
 import type { Resolvable } from '../injector/index.js';
 import { resolveArgumentType } from '../injector/index.js';
+import type { Record } from '../types/types.js';
 import { LogLevel } from './level.js';
-export type LogEntry = string;
-export type LogEntryProvider = () => LogEntry;
-export type LogEntryOrProvider = LogEntry | LogEntryProvider;
-export type LoggerStatic = new (level: LogLevel) => Logger;
-export type LogErrorOptions = {
-    includeRest?: boolean;
-    includeStack?: boolean;
-};
-/** Either string as a module shorthand or object */
-export type LoggerArgument = string | undefined | {
-    level?: LogLevel;
+export type LoggerArgument = string | string[] | {
     module?: string | string[];
-    prefix?: string;
+    context?: Record<string>;
+    level?: LogLevel;
 };
 export type LoggerForkOptions = {
-    subModule?: string;
-    prefix?: string;
+    context?: Record<string>;
+    replaceContext?: boolean;
     level?: LogLevel;
 };
-export declare abstract class Logger implements Resolvable<LoggerArgument> {
-    readonly level: LogLevel;
-    readonly module?: string[];
-    readonly logPrefix: string;
+export declare class Logger implements Resolvable<LoggerArgument> {
+    #private;
+    readonly module: string[];
+    readonly context: Record<string>;
+    readonly level: LogLevel | undefined;
     readonly [resolveArgumentType]: LoggerArgument;
-    constructor(level: LogLevel, module?: string | string[], prefix?: string);
-    error(entry: LogEntryOrProvider): void;
-    error(error: unknown, options?: LogErrorOptions): void;
-    warn(entry: LogEntryOrProvider): void;
-    info(entry: LogEntryOrProvider): void;
-    verbose(entry: LogEntryOrProvider): void;
-    debug(entry: LogEntryOrProvider): void;
-    trace(entry: LogEntryOrProvider): void;
+    error(message: string, context?: Record<string>): void;
+    error(error: unknown, context?: Record<string>): void;
+    warn(message: string, context?: Record<string>): void;
+    info(message: string, context?: Record<string>): void;
+    verbose(message: string, context?: Record<string>): void;
+    debug(message: string, context?: Record<string>): void;
+    trace(message: string, context?: Record<string>): void;
+    fork(subModule: string | string[], options?: LoggerForkOptions): Logger;
+    fork(options: LoggerForkOptions): Logger;
+    with(context: Record<string>): Logger;
     private _log;
-    abstract fork(options: LoggerForkOptions): Logger;
-    abstract subModule(subModule: string): Logger;
-    abstract prefix(prefix: string): Logger;
-    protected abstract log(level: LogLevel, entry: LogEntry | Error, errorOptions?: LogErrorOptions): void;
 }

package/logger/logger.js

@@ -1,39 +1,111 @@
-import { resolveArgumentType } from '../injector/index.js';
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Logger_1;
+import { createContextProvider } from '../context/context.js';
+import { inject, Injectable, injectArgument, isInInjectionContext, resolveArgumentType } from '../injector/index.js';
 import { toArray } from '../utils/array/array.js';
-import { isDefined, isFunction } from '../utils/type-guards.js';
+import { now } from '../utils/date-time.js';
+import { getCachedDereference } from '../utils/object/dereference.js';
+import { hasOwnProperty } from '../utils/object/object.js';
+import { isArray, isNotArray, isObject, isString } from '../utils/type-guards.js';
 import { LogLevel } from './level.js';
-export class Logger {
-    level;
-    module;
-    logPrefix;
-    constructor(level, module, prefix = '') {
-        this.level = level;
-        this.module = isDefined(module) ? toArray(module) : undefined;
-        this.logPrefix = prefix;
+import { LogManager } from './manager.js';
+const { getCurrentLoggerCreationContext, runInLoggerCreationContext, isInLoggerCreationContext } = createContextProvider('LoggerCreation');
+let Logger = Logger_1 = class Logger {
+    #manager = getCurrentLoggerCreationContext()?.manager ?? inject(LogManager);
+    #argument = isInInjectionContext() ? injectArgument(this, { optional: true }) : undefined;
+    module = getCurrentLoggerCreationContext()?.module ?? moduleFromArgument(this.#argument);
+    context = getCurrentLoggerCreationContext()?.context ?? ((isObject(this.#argument) && isNotArray(this.#argument)) ? (this.#argument.context ?? {}) : {});
+    level = isInLoggerCreationContext() ? getCurrentLoggerCreationContext().level : (isObject(this.#argument) && isNotArray(this.#argument)) ? this.#argument.level : undefined;
+    error(errorOrMessage, context) {
+        if (isString(errorOrMessage)) {
+            this._log(LogLevel.Error, errorOrMessage, context);
+        }
+        else {
+            const message = (errorOrMessage instanceof Error) ? errorOrMessage.message : 'Error';
+            this._log(LogLevel.Error, message, { ...context, error: errorOrMessage });
+        }
     }
-    error(errorOrEntry, options) {
-        this._log(LogLevel.Error, errorOrEntry, options);
+    warn(message, context) {
+        this._log(LogLevel.Warn, message, context);
     }
-    warn(entry) {
-        this._log(LogLevel.Warn, entry);
+    info(message, context) {
+        this._log(LogLevel.Info, message, context);
     }
-    info(entry) {
-        this._log(LogLevel.Info, entry);
+    verbose(message, context) {
+        this._log(LogLevel.Verbose, message, context);
     }
-    verbose(entry) {
-        this._log(LogLevel.Verbose, entry);
+    debug(message, context) {
+        this._log(LogLevel.Debug, message, context);
     }
-    debug(entry) {
-        this._log(LogLevel.Debug, entry);
+    trace(message, context) {
+        this._log(LogLevel.Trace, message, context);
     }
-    trace(entry) {
-        this._log(LogLevel.Trace, entry);
+    fork(subModuleOrOptions, optionsOrNothing) {
+        const subModule = (isString(subModuleOrOptions) || isArray(subModuleOrOptions)) ? subModuleOrOptions : [];
+        const options = (isString(subModuleOrOptions) || isArray(subModuleOrOptions)) ? optionsOrNothing : subModuleOrOptions;
+        const newModule = [...this.module, ...toArray(subModule)];
+        const creationContext = {
+            manager: this.#manager,
+            module: newModule,
+            context: (options?.replaceContext == true) ? (options.context ?? {}) : { ...this.context, ...options?.context },
+            level: options?.level ?? this.level,
+        };
+        return runInLoggerCreationContext(creationContext, () => new Logger_1());
     }
-    _log(level, entryOrProvider, errorOptions) {
-        if (this.level < level) {
+    with(context) {
+        const creationContext = {
+            manager: this.#manager,
+            module: this.module,
+            context: { ...this.context, ...context },
+            level: this.level,
+        };
+        return runInLoggerCreationContext(creationContext, () => new Logger_1());
+    }
+    _log(level, message, context = {}) {
+        const moduleLevel = this.level ?? this.#manager.getModuleLevel(this.module);
+        if (level > moduleLevel) {
             return;
         }
-        const entry = isFunction(entryOrProvider) ? entryOrProvider() : entryOrProvider;
-        this.log(level, entry, errorOptions);
+        const effectiveContext = { ...this.context, ...context };
+        const finalMessage = interpolateMessage(message, effectiveContext);
+        const payload = {
+            timestamp: now(),
+            level,
+            module: this.module,
+            message: finalMessage,
+            context: effectiveContext,
+        };
+        this.#manager.log(payload);
+    }
+};
+Logger = Logger_1 = __decorate([
+    Injectable()
+], Logger);
+export { Logger };
+function moduleFromArgument(argument) {
+    if (isString(argument)) {
+        return toArray(argument);
     }
+    if (isArray(argument)) {
+        return argument;
+    }
+    if (isObject(argument)) {
+        return moduleFromArgument(argument.module);
+    }
+    return [];
+}
+const cachedDereference = getCachedDereference({ optional: true });
+function interpolateMessage(message, context) {
+    return message.replace(/{([^{}]+)}/g, (match, key) => {
+        if (hasOwnProperty(context, key)) {
+            const value = cachedDereference(context, key);
+            return String(value);
+        }
+        return match;
+    });
 }

package/logger/manager.d.ts

@@ -0,0 +1,20 @@
+import type { LogPayload } from './formatter.js';
+import { LogLevel } from './level.js';
+export declare class LogManager {
+    #private;
+    log(payload: LogPayload): void;
+    setDefaultLevel(level: LogLevel): void;
+    /**
+     * Sets the log level for a specific module.
+     * @param module The module (e.g., 'Api.Users' or ['Api', 'Users'])
+     * @param level The log level to set
+     */
+    setModuleLevel(module: string | string[], level: LogLevel): void;
+    /**
+     * Gets the effective log level for a given module path.
+     * It finds the most specific rule matching the module path.
+     * @param modulePath Array of module names, e.g., ['Api', 'Users']
+     * @returns The effective log level
+     */
+    getModuleLevel(modulePath?: string | string[]): LogLevel;
+}