@fgv/ts-utils 5.0.2 → 5.1.0-0

package/lib/packlets/conversion/defaultingConverter.d.ts

@@ -8,15 +8,15 @@ import { ConstraintOptions, ConversionErrorFormatter, Converter, DefaultingConve
 export declare class GenericDefaultingConverter<T, TD = T, TC = unknown> implements DefaultingConverter<T, TD, TC> {
     private _converter;
     /**
-     * {@inheritdoc Conversion.DefaultingConverter.defaultValue}
+     * {@inheritDoc Conversion.DefaultingConverter.defaultValue}
      */
     defaultValue: TD;
     /**
-     * {@inheritdoc Converter.isOptional}
+     * {@inheritDoc Converter.isOptional}
      */
     get isOptional(): boolean;
     /**
-     * {@inheritdoc Converter.isOptional}
+     * {@inheritDoc Converter.isOptional}
      */
     get brand(): string | undefined;
     /**
@@ -26,55 +26,55 @@ export declare class GenericDefaultingConverter<T, TD = T, TC = unknown> impleme
      */
     constructor(converter: Converter<T, TC>, defaultValue: TD);
     /**
-     * {@inheritdoc Converter.convert}
+     * {@inheritDoc Converter.convert}
      */
     convert(from: unknown, ctx?: TC | undefined): Success<T | TD>;
     /**
-     * {@inheritdoc Converter.convertOptional}
+     * {@inheritDoc Converter.convertOptional}
      */
     convertOptional(from: unknown, context?: TC | undefined, onError?: ('failOnError' | 'ignoreErrors') | undefined): Result<T | TD | undefined>;
     /**
-     * {@inheritdoc Converter.optional}
+     * {@inheritDoc Converter.optional}
      */
     optional(onError?: ('failOnError' | 'ignoreErrors') | undefined): Converter<T | TD | undefined, TC>;
     /**
-     * {@inheritdoc Converter.map}
+     * {@inheritDoc Converter.map}
      */
     map<T2>(mapper: (from: T | TD) => Result<T2>): Converter<T2, TC>;
     /**
-     * {@inheritdoc Converter.mapConvert}
+     * {@inheritDoc Converter.mapConvert}
      */
     mapConvert<T2>(mapConverter: Converter<T2, unknown>): Converter<T2, TC>;
     /**
-     * {@inheritdoc Converter.mapItems}
+     * {@inheritDoc Converter.mapItems}
      */
     mapItems<TI>(mapper: (from: unknown) => Result<TI>): Converter<TI[], TC>;
     /**
-     * {@inheritdoc Converter.mapConvertItems}
+     * {@inheritDoc Converter.mapConvertItems}
      */
     mapConvertItems<TI>(mapConverter: Converter<TI, unknown>): Converter<TI[], TC>;
     /**
-     * {@inheritdoc Converter.withAction}
+     * {@inheritDoc Converter.withAction}
      */
     withAction<T2>(action: (result: Result<T | TD>) => Result<T2>): Converter<T2, TC>;
     /**
-     * {@inheritdoc Converter.withTypeGuard}
+     * {@inheritDoc Converter.withTypeGuard}
      */
     withTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string | undefined): Converter<TI, TC>;
     /**
-     * {@inheritdoc Converter.withItemTypeGuard}
+     * {@inheritDoc Converter.withItemTypeGuard}
      */
     withItemTypeGuard<TI>(guard: (from: unknown) => from is TI, message?: string | undefined): Converter<TI[], TC>;
     /**
-     * {@inheritdoc Converter.withConstraint}
+     * {@inheritDoc Converter.withConstraint}
      */
     withConstraint(constraint: (val: T | TD) => boolean | Result<T | TD>, options?: ConstraintOptions | undefined): Converter<T | TD, TC>;
     /**
-     * {@inheritdoc Converter.withBrand}
+     * {@inheritDoc Converter.withBrand}
      */
     withBrand<B extends string>(brand: B): Converter<Brand<T | TD, B>, TC>;
     /**
-     * {@inheritdoc Converter.withFormattedError}
+     * {@inheritDoc Converter.withFormattedError}
      */
     withFormattedError(formatter: ConversionErrorFormatter<TC>): Converter<T | TD, TC>;
     /**
@@ -85,6 +85,10 @@ export declare class GenericDefaultingConverter<T, TD = T, TC = unknown> impleme
      * {@link Conversion.DefaultingConverter | DefaultingConverter}.
      */
     withDefault<TD2 = T>(dflt: TD2): DefaultingConverter<T, TD2, TC>;
+    /**
+     * {@inheritDoc Converter.or}
+     */
+    or(__converter: Converter<T, TC>): DefaultingConverter<T, TD, TC>;
     private _applyDefault;
 }
 //# sourceMappingURL=defaultingConverter.d.ts.map

package/lib/packlets/conversion/defaultingConverter.js

@@ -30,13 +30,13 @@ const base_1 = require("../base");
  */
 class GenericDefaultingConverter {
     /**
-     * {@inheritdoc Converter.isOptional}
+     * {@inheritDoc Converter.isOptional}
      */
     get isOptional() {
         return this._converter.isOptional;
     }
     /**
-     * {@inheritdoc Converter.isOptional}
+     * {@inheritDoc Converter.isOptional}
      */
     get brand() {
         return this._converter.brand;
@@ -51,13 +51,13 @@ class GenericDefaultingConverter {
         this._converter = converter;
     }
     /**
-     * {@inheritdoc Converter.convert}
+     * {@inheritDoc Converter.convert}
      */
     convert(from, ctx) {
         return this._applyDefault(this._converter.convert(from, ctx));
     }
     /**
-     * {@inheritdoc Converter.convertOptional}
+     * {@inheritDoc Converter.convertOptional}
      */
     convertOptional(from, context, onError) {
         const converted = this._converter.convertOptional(from, context, onError);
@@ -67,7 +67,7 @@ class GenericDefaultingConverter {
         return converted;
     }
     /**
-     * {@inheritdoc Converter.optional}
+     * {@inheritDoc Converter.optional}
      */
     optional(onError) {
         // need to let the inner converter do its optional thing first or our default
@@ -75,61 +75,61 @@ class GenericDefaultingConverter {
         return this._converter.optional(onError).withAction((result) => this._applyDefault(result));
     }
     /**
-     * {@inheritdoc Converter.map}
+     * {@inheritDoc Converter.map}
      */
     map(mapper) {
         return this._converter.withAction((result) => this._applyDefault(result)).map(mapper);
     }
     /**
-     * {@inheritdoc Converter.mapConvert}
+     * {@inheritDoc Converter.mapConvert}
      */
     mapConvert(mapConverter) {
         return this._converter.withAction((result) => this._applyDefault(result)).mapConvert(mapConverter);
     }
     /**
-     * {@inheritdoc Converter.mapItems}
+     * {@inheritDoc Converter.mapItems}
      */
     mapItems(mapper) {
         return this._converter.withAction((result) => this._applyDefault(result)).mapItems(mapper);
     }
     /**
-     * {@inheritdoc Converter.mapConvertItems}
+     * {@inheritDoc Converter.mapConvertItems}
      */
     mapConvertItems(mapConverter) {
         return this._converter.withAction((result) => this._applyDefault(result)).mapConvertItems(mapConverter);
     }
     /**
-     * {@inheritdoc Converter.withAction}
+     * {@inheritDoc Converter.withAction}
      */
     withAction(action) {
         return this._converter.withAction((result) => this._applyDefault(result)).withAction(action);
     }
     /**
-     * {@inheritdoc Converter.withTypeGuard}
+     * {@inheritDoc Converter.withTypeGuard}
      */
     withTypeGuard(guard, message) {
         return this._converter.withAction((result) => this._applyDefault(result)).withTypeGuard(guard);
     }
     /**
-     * {@inheritdoc Converter.withItemTypeGuard}
+     * {@inheritDoc Converter.withItemTypeGuard}
      */
     withItemTypeGuard(guard, message) {
         return this._converter.withAction((result) => this._applyDefault(result)).withItemTypeGuard(guard);
     }
     /**
-     * {@inheritdoc Converter.withConstraint}
+     * {@inheritDoc Converter.withConstraint}
      */
     withConstraint(constraint, options) {
         return this._converter.withAction((result) => this._applyDefault(result)).withConstraint(constraint);
     }
     /**
-     * {@inheritdoc Converter.withBrand}
+     * {@inheritDoc Converter.withBrand}
      */
     withBrand(brand) {
         return this._converter.withAction((result) => this._applyDefault(result)).withBrand(brand);
     }
     /**
-     * {@inheritdoc Converter.withFormattedError}
+     * {@inheritDoc Converter.withFormattedError}
      */
     withFormattedError(formatter) {
         // formatter should never actually be invoked for a defaulting converter
@@ -145,6 +145,12 @@ class GenericDefaultingConverter {
     withDefault(dflt) {
         return new GenericDefaultingConverter(this._converter, dflt);
     }
+    /**
+     * {@inheritDoc Converter.or}
+     */
+    or(__converter) {
+        return this;
+    }
     _applyDefault(converted) {
         return converted.success ? converted : (0, base_1.succeed)(this.defaultValue);
     }

package/lib/packlets/logging/bootLogger.d.ts

@@ -0,0 +1,84 @@
+import { MessageLogLevel, Success } from '../base';
+import { IDetailLogger, ILogger, ReporterLogLevel } from './logger';
+/**
+ * A logger that buffers log entries during startup, then replays them
+ * to a real logger once it becomes available.
+ *
+ * @remarks
+ * During application bootstrap, the real logger (e.g. one backed by
+ * toast notifications) may not be available yet. `BootLogger` solves
+ * this by:
+ * 1. Buffering all log calls in memory during the boot phase.
+ * 2. When {@link BootLogger.ready | ready()} is called with the real
+ *    logger, replaying all buffered entries and then forwarding all
+ *    subsequent calls directly.
+ *
+ * @example
+ * ```typescript
+ * // Create early, before the real logger exists
+ * const bootLogger = new BootLogger('detail');
+ * bootLogger.info('Starting up...');
+ *
+ * // Later, when the real logger is available
+ * bootLogger.ready(realLogger);
+ * // 'Starting up...' is replayed to realLogger
+ * // All future calls go directly to realLogger
+ * ```
+ *
+ * @public
+ */
+export declare class BootLogger implements IDetailLogger {
+    private _buffer;
+    private _delegate;
+    private _isReady;
+    /**
+     * Creates a new boot logger.
+     * @param logLevel - The log level for the initial in-memory buffer phase.
+     * Defaults to 'detail' to capture everything during boot.
+     */
+    constructor(logLevel?: ReporterLogLevel);
+    /**
+     * {@inheritDoc Logging.ILogger.logLevel}
+     */
+    get logLevel(): ReporterLogLevel;
+    /**
+     * Whether the boot logger has been connected to a real logger.
+     */
+    get isReady(): boolean;
+    /**
+     * Connects this boot logger to a real logger.
+     * All buffered entries are replayed to the new logger in order,
+     * and all subsequent calls are forwarded directly.
+     * @param logger - The real logger to forward to.
+     */
+    ready(logger: ILogger): void;
+    /**
+     * {@inheritDoc Logging.ILogger.log}
+     */
+    log(level: MessageLogLevel, message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.ILogger.detail}
+     */
+    detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.ILogger.info}
+     */
+    info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.ILogger.warn}
+     */
+    warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.ILogger.error}
+     */
+    error(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.IDetailLogger.errorWithDetail}
+     */
+    errorWithDetail(message: string, detail: unknown): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.IDetailLogger.warnWithDetail}
+     */
+    warnWithDetail(message: string, detail: unknown): Success<string | undefined>;
+}
+//# sourceMappingURL=bootLogger.d.ts.map

package/lib/packlets/logging/bootLogger.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BootLogger = void 0;
+const logger_1 = require("./logger");
+/**
+ * A logger that buffers log entries during startup, then replays them
+ * to a real logger once it becomes available.
+ *
+ * @remarks
+ * During application bootstrap, the real logger (e.g. one backed by
+ * toast notifications) may not be available yet. `BootLogger` solves
+ * this by:
+ * 1. Buffering all log calls in memory during the boot phase.
+ * 2. When {@link BootLogger.ready | ready()} is called with the real
+ *    logger, replaying all buffered entries and then forwarding all
+ *    subsequent calls directly.
+ *
+ * @example
+ * ```typescript
+ * // Create early, before the real logger exists
+ * const bootLogger = new BootLogger('detail');
+ * bootLogger.info('Starting up...');
+ *
+ * // Later, when the real logger is available
+ * bootLogger.ready(realLogger);
+ * // 'Starting up...' is replayed to realLogger
+ * // All future calls go directly to realLogger
+ * ```
+ *
+ * @public
+ */
+class BootLogger {
+    /**
+     * Creates a new boot logger.
+     * @param logLevel - The log level for the initial in-memory buffer phase.
+     * Defaults to 'detail' to capture everything during boot.
+     */
+    constructor(logLevel) {
+        this._buffer = [];
+        this._isReady = false;
+        this._delegate = new logger_1.InMemoryLogger(logLevel !== null && logLevel !== void 0 ? logLevel : 'detail');
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.logLevel}
+     */
+    get logLevel() {
+        return this._delegate.logLevel;
+    }
+    /**
+     * Whether the boot logger has been connected to a real logger.
+     */
+    get isReady() {
+        return this._isReady;
+    }
+    /**
+     * Connects this boot logger to a real logger.
+     * All buffered entries are replayed to the new logger in order,
+     * and all subsequent calls are forwarded directly.
+     * @param logger - The real logger to forward to.
+     */
+    ready(logger) {
+        // Replay buffered entries
+        for (const entry of this._buffer) {
+            logger.log(entry.level, entry.message, ...entry.parameters);
+        }
+        // Switch to the real logger and discard the buffer
+        this._delegate = logger;
+        this._buffer = [];
+        this._isReady = true;
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.log}
+     */
+    log(level, message, ...parameters) {
+        if (!this._isReady) {
+            this._buffer.push({ level, message, parameters });
+        }
+        return this._delegate.log(level, message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.detail}
+     */
+    detail(message, ...parameters) {
+        return this.log('detail', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.info}
+     */
+    info(message, ...parameters) {
+        return this.log('info', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.warn}
+     */
+    warn(message, ...parameters) {
+        return this.log('warning', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.error}
+     */
+    error(message, ...parameters) {
+        return this.log('error', message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.IDetailLogger.errorWithDetail}
+     */
+    errorWithDetail(message, detail) {
+        if ((0, logger_1.isDetailLogger)(this._delegate)) {
+            return this._delegate.errorWithDetail(message, detail);
+        }
+        this.log('detail', detail);
+        return this.log('error', message);
+    }
+    /**
+     * {@inheritDoc Logging.IDetailLogger.warnWithDetail}
+     */
+    warnWithDetail(message, detail) {
+        if ((0, logger_1.isDetailLogger)(this._delegate)) {
+            return this._delegate.warnWithDetail(message, detail);
+        }
+        this.log('detail', detail);
+        return this.log('warning', message);
+    }
+}
+exports.BootLogger = BootLogger;
+//# sourceMappingURL=bootLogger.js.map

package/lib/packlets/logging/index.d.ts

@@ -1,3 +1,4 @@
+export * from './bootLogger';
 export * from './logger';
 export * from './logReporter';
 //# sourceMappingURL=index.d.ts.map

package/lib/packlets/logging/index.js

@@ -35,6 +35,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bootLogger"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./logReporter"), exports);
 //# sourceMappingURL=index.js.map

package/lib/packlets/logging/logReporter.d.ts

@@ -1,5 +1,5 @@
-import { ILogger, ReporterLogLevel } from './logger';
-import { ErrorFormatter, IResultReporter, MessageLogLevel, Success } from '../base';
+import { IDetailLogger, ILogger, ReporterLogLevel } from './logger';
+import { ErrorFormatter, IResultReporter, MessageLogLevel, Result, Success } from '../base';
 /**
  * A function that formats a value for logging.
  * @public
@@ -24,7 +24,7 @@ export interface ILogReporterCreateParams<T, TD = unknown> {
  * both {@link Logging.ILogger | ILogger} and {@link IResultReporter | IResultReporter}.
  * @public
  */
-export declare class LogReporter<T, TD = unknown> implements ILogger, IResultReporter<T, TD> {
+export declare class LogReporter<T, TD = unknown> implements IDetailLogger, IResultReporter<T, TD> {
     /**
      * Base logger used to by this reporter.
      * @public
@@ -45,6 +45,13 @@ export declare class LogReporter<T, TD = unknown> implements ILogger, IResultRep
      * @param params - The parameters for creating the {@link Logging.LogReporter | LogReporter}.
      */
     constructor(params?: ILogReporterCreateParams<T, TD>);
+    /**
+     * Creates a default {@link Logging.LogReporter | LogReporter} with a {@link Logging.NoOpLogger | NoOpLogger} with the
+     * supplied parameters, returning both the logger and reporter.
+     * @param logger - Optional logger to use; defaults to a new {@link Logging.NoOpLogger | NoOpLogger} if not provided.
+     * @returns
+     */
+    static createDefault(logger?: ILogger): Result<LogReporter<unknown>>;
     /**
      * {@inheritDoc Logging.ILogger.logLevel}
      */
@@ -65,6 +72,14 @@ export declare class LogReporter<T, TD = unknown> implements ILogger, IResultRep
      * {@inheritDoc Logging.ILogger.error}
      */
     error(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.IDetailLogger.errorWithDetail}
+     */
+    errorWithDetail(message: string, detail: unknown): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.IDetailLogger.warnWithDetail}
+     */
+    warnWithDetail(message: string, detail: unknown): Success<string | undefined>;
     /**
      * {@inheritDoc Logging.ILogger.log}
      */

package/lib/packlets/logging/logReporter.js

@@ -23,6 +23,7 @@ exports.LogReporter = void 0;
  * SOFTWARE.
  */
 const logger_1 = require("./logger");
+const base_1 = require("../base");
 /**
  * Abstract base class which wraps an existing {@link Logging.ILogger | ILogger} to implement
  * both {@link Logging.ILogger | ILogger} and {@link IResultReporter | IResultReporter}.
@@ -41,6 +42,16 @@ class LogReporter {
         this._valueFormatter = (_b = params.valueFormatter) !== null && _b !== void 0 ? _b : LogReporter.tryFormatObject;
         this._messageFormatter = (_c = params.messageFormatter) !== null && _c !== void 0 ? _c : ((message, __detail) => message);
     }
+    /**
+     * Creates a default {@link Logging.LogReporter | LogReporter} with a {@link Logging.NoOpLogger | NoOpLogger} with the
+     * supplied parameters, returning both the logger and reporter.
+     * @param logger - Optional logger to use; defaults to a new {@link Logging.NoOpLogger | NoOpLogger} if not provided.
+     * @returns
+     */
+    static createDefault(logger) {
+        logger = logger !== null && logger !== void 0 ? logger : new logger_1.NoOpLogger();
+        return (0, base_1.captureResult)(() => new LogReporter({ logger }));
+    }
     /**
      * {@inheritDoc Logging.ILogger.logLevel}
      */
@@ -71,6 +82,26 @@ class LogReporter {
     error(message, ...parameters) {
         return this.logger.error(message, ...parameters);
     }
+    /**
+     * {@inheritDoc Logging.IDetailLogger.errorWithDetail}
+     */
+    errorWithDetail(message, detail) {
+        if ((0, logger_1.isDetailLogger)(this.logger)) {
+            return this.logger.errorWithDetail(message, detail);
+        }
+        this.logger.detail(detail);
+        return this.logger.error(message);
+    }
+    /**
+     * {@inheritDoc Logging.IDetailLogger.warnWithDetail}
+     */
+    warnWithDetail(message, detail) {
+        if ((0, logger_1.isDetailLogger)(this.logger)) {
+            return this.logger.warnWithDetail(message, detail);
+        }
+        this.logger.detail(detail);
+        return this.logger.warn(message);
+    }
     /**
      * {@inheritDoc Logging.ILogger.log}
      */

package/lib/packlets/logging/logger.d.ts

@@ -72,10 +72,39 @@ export interface ILogger {
     error(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
 }
 /**
- * Abstract base class which implements {@link Logging.ILogger | ILogger}.
+ * Extended logger interface that supports logging a short summary message at a
+ * primary level (error/warn) while emitting the full detail at `detail` level.
+ *
+ * The detail is suppressed by default (requires log level `'detail'` or `'all'`),
+ * keeping the primary log clean while preserving the full context for debugging.
  * @public
  */
-export declare abstract class LoggerBase implements ILogger {
+export interface IDetailLogger extends ILogger {
+    /**
+     * Logs a short error summary at `error` level, then emits `detail` at `detail` level.
+     * @param message - Short human-readable summary.
+     * @param detail - Full detail (e.g. raw converter error) logged at `detail` level.
+     */
+    errorWithDetail(message: string, detail: unknown): Success<string | undefined>;
+    /**
+     * Logs a short warning summary at `warning` level, then emits `detail` at `detail` level.
+     * @param message - Short human-readable summary.
+     * @param detail - Full detail logged at `detail` level.
+     */
+    warnWithDetail(message: string, detail: unknown): Success<string | undefined>;
+}
+/**
+ * Type guard that checks whether a logger implements {@link IDetailLogger}.
+ * @param logger - The logger to check.
+ * @returns `true` if the logger implements `IDetailLogger`.
+ * @public
+ */
+export declare function isDetailLogger(logger: ILogger): logger is IDetailLogger;
+/**
+ * Abstract base class which implements {@link Logging.IDetailLogger | IDetailLogger}.
+ * @public
+ */
+export declare abstract class LoggerBase implements IDetailLogger {
     /**
      * {@inheritDoc Logging.ILogger.logLevel}
      */
@@ -97,6 +126,14 @@ export declare abstract class LoggerBase implements ILogger {
      * {@inheritDoc Logging.ILogger.error}
      */
     error(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.IDetailLogger.errorWithDetail}
+     */
+    errorWithDetail(message: string, detail: unknown): Success<string | undefined>;
+    /**
+     * {@inheritDoc Logging.IDetailLogger.warnWithDetail}
+     */
+    warnWithDetail(message: string, detail: unknown): Success<string | undefined>;
     /**
      * {@inheritDoc Logging.ILogger.log}
      */
@@ -162,10 +199,6 @@ export declare class InMemoryLogger extends LoggerBase {
     protected _log(message: string, __level: MessageLogLevel): Success<string | undefined>;
     /**
      * {@inheritDoc Logging.LoggerBase._suppressLog}
-     * @param level - The level of the message.
-     * @param message - The message to suppress.
-     * @param parameters - The parameters to suppress.
-     * @returns `Success` with `undefined` if the message is suppressed.
      * @internal
      */
     protected _suppressLog(level: MessageLogLevel, message?: unknown, ...parameters: unknown[]): Success<undefined>;

package/lib/packlets/logging/logger.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoOpLogger = exports.ConsoleLogger = exports.InMemoryLogger = exports.LoggerBase = void 0;
 exports.shouldLog = shouldLog;
 exports.stringifyLogValue = stringifyLogValue;
+exports.isDetailLogger = isDetailLogger;
 /*
  * Copyright (c) 2020 Erik Fortune
  *
@@ -75,7 +76,17 @@ function stringifyLogValue(value, maxLength) {
     return str;
 }
 /**
- * Abstract base class which implements {@link Logging.ILogger | ILogger}.
+ * Type guard that checks whether a logger implements {@link IDetailLogger}.
+ * @param logger - The logger to check.
+ * @returns `true` if the logger implements `IDetailLogger`.
+ * @public
+ */
+function isDetailLogger(logger) {
+    return (typeof logger.errorWithDetail === 'function' &&
+        typeof logger.warnWithDetail === 'function');
+}
+/**
+ * Abstract base class which implements {@link Logging.IDetailLogger | IDetailLogger}.
  * @public
  */
 class LoggerBase {
@@ -110,6 +121,20 @@ class LoggerBase {
     error(message, ...parameters) {
         return this.log('error', message, ...parameters);
     }
+    /**
+     * {@inheritDoc Logging.IDetailLogger.errorWithDetail}
+     */
+    errorWithDetail(message, detail) {
+        this.detail(detail);
+        return this.error(message);
+    }
+    /**
+     * {@inheritDoc Logging.IDetailLogger.warnWithDetail}
+     */
+    warnWithDetail(message, detail) {
+        this.detail(detail);
+        return this.warn(message);
+    }
     /**
      * {@inheritDoc Logging.ILogger.log}
      */
@@ -194,10 +219,6 @@ class InMemoryLogger extends LoggerBase {
     }
     /**
      * {@inheritDoc Logging.LoggerBase._suppressLog}
-     * @param level - The level of the message.
-     * @param message - The message to suppress.
-     * @param parameters - The parameters to suppress.
-     * @returns `Success` with `undefined` if the message is suppressed.
      * @internal
      */
     _suppressLog(level, message, ...parameters) {

package/lib/packlets/validation/classes.d.ts

@@ -1,5 +1,6 @@
 export { ArrayValidator, ArrayValidatorConstructorParams } from './array';
 export { BooleanValidator, BooleanValidatorConstructorParams } from './boolean';
+export { CompositeIdValidator, CompositeIdValidatorConstructorParams } from './compositeId';
 export { NumberValidator, NumberValidatorConstructorParams } from './number';
 export { FieldValidators, ObjectValidator, ObjectValidatorConstructorParams, ObjectValidatorOptions } from './object';
 export { OneOfValidator, OneOfValidatorConstructorParams } from './oneOf';