@fgv/ts-utils 5.0.0-22 → 5.0.0-23

package/dist/ts-utils.d.ts

@@ -490,6 +490,10 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
            * {@inheritdoc Collections.ResultMap.values}
            */
           values(): IterableIterator<TITEM>;
+          /**
+           * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+           */
+          valuesByIndex(): ReadonlyArray<TITEM>;
           /**
            * Gets a read-only version of this collector.
            */
@@ -559,6 +563,22 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
            protected _convertValue(value: unknown): DetailedResult<TITEM, CollectorResultDetail>;
           }
 
+          /**
+           * A console logger that outputs messages to the console.
+           * @public
+           */
+          declare class ConsoleLogger extends LoggerBase {
+              /**
+               * Creates a new console logger.
+               * @param logLevel - The level of logging to be used.
+               */
+              constructor(logLevel?: ReporterLogLevel);
+              /**
+               * {@inheritDoc Logging.LoggerBase._log}
+               */
+              protected _log(message: string, level: MessageLogLevel): Success<string | undefined>;
+          }
+
           /**
            * A {@link Validation.Constraint | Constraint<T>} function returns
            * `true` if the supplied value meets the constraint. Can return
@@ -1080,6 +1100,10 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                * {@inheritdoc IResult.withErrorFormat}
                */
               withErrorFormat(cb: ErrorFormatter<TD>): DetailedResult<T, TD>;
+              /**
+               * {@inheritdoc IResult.report}
+               */
+              report(reporter: IResultReporter<T, TD>, options?: IResultReportOptions): this;
               orThrow(logOrFormat?: IResultLogger<TD> | ErrorFormatter<TD>): never;
               orThrow(cb: ErrorFormatter): never;
               /**
@@ -1168,6 +1192,10 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                * {@inheritdoc Success.withErrorFormat}
                */
               withErrorFormat(cb: ErrorFormatter): DetailedResult<T, TD>;
+              /**
+               * {@inheritdoc IResult.report}
+               */
+              report(reporter: IResultReporter<T, TD>, options?: IResultReportOptions): this;
               /**
                * Creates a {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value and
                * optional detail.
@@ -1409,6 +1437,10 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                * {@inheritdoc IResult.aggregateError}
                */
               aggregateError(errors: IMessageAggregator): this;
+              /**
+               * {@inheritdoc IResult.report}
+               */
+              report(reporter: IResultReporter<T>, options?: IResultReportOptions): this;
               /**
                * Get a 'friendly' string representation of this object.
                * @remarks
@@ -2204,6 +2236,68 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                value: Validator<TV, unknown> | Converter<TV, unknown> | ConverterFunc<TV, unknown>;
                            }
 
+                           /**
+                            * Generic Result-aware logger interface with multiple levels of logging.
+                            * @public
+                            */
+                           declare interface ILogger {
+                               /**
+                                * The level of logging to be used.
+                                */
+                               readonly logLevel: ReporterLogLevel;
+                               /**
+                                * Logs a message at the given level.
+                                * @param level - The level of the message.
+                                * @param message - The message to log.
+                                * @param parameters - The parameters to log.
+                                * @returns `Success` with the logged message if the level is enabled, or
+                                * `Success` with `undefined` if the message is suppressed.
+                                */
+                               log(level: MessageLogLevel, message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                               /**
+                                * Logs a detail message.
+                                * @param message - The message to log.
+                                * @param parameters - The parameters to log.
+                                * @returns `Success` with the logged message if the level is enabled, or
+                                * `Success` with `undefined` if the message is suppressed.
+                                */
+                               detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                               /**
+                                * Logs an info message.
+                                * @param message - The message to log.
+                                * @param parameters - The parameters to log.
+                                * @returns `Success` with the logged message if the level is enabled, or
+                                * `Success` with `undefined` if the message is suppressed.
+                                */
+                               info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                               /**
+                                * Logs a warning message.
+                                * @param message - The message to log.
+                                * @param parameters - The parameters to log.
+                                * @returns `Success` with the logged message if the level is enabled, or
+                                * `Success` with `undefined` if the message is suppressed.
+                                */
+                               warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                               /**
+                                * Logs an error message.
+                                * @param message - The message to log.
+                                * @param parameters - The parameters to log.
+                                * @returns `Success` with the logged message if the level is enabled, or
+                                * `Success` with `undefined` if the message is suppressed.
+                                */
+                               error(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                           }
+
+                           /**
+                            * Parameters for creating a {@link Logging.LogReporter | LogReporter}.
+                            * @public
+                            */
+                           declare interface ILogReporterCreateParams<T, TD = unknown> {
+                               logger: ILogger;
+                               valueFormatter?: LogValueFormatter<T, TD>;
+                               messageFormatter?: LogMessageFormatter<TD>;
+                           }
+
                            /**
                             * Simple error aggregator to simplify collecting all errors in
                             * a flow.
@@ -2263,17 +2357,47 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                             declare function inMemory(files: IInMemoryFile[], prefix?: string): Result<FileTree_2>;
 
                             /**
+                             * An in-memory logger that stores logged and suppressed messages.
                              * @public
                              */
                             declare class InMemoryLogger extends LoggerBase {
-                                protected _messages: string[];
-                                protected _silent: string[];
-                                constructor(logLevel?: LogLevel);
-                                get messages(): string[];
-                                get silent(): string[];
+                                /**
+                                 * The messages that have been logged.
+                                 */
+                                protected _logged: string[];
+                                /**
+                                 * The messages that have been suppressed.
+                                 */
+                                protected _suppressed: string[];
+                                /**
+                                 * Creates a new in-memory logger.
+                                 * @param logLevel - The level of logging to be used.
+                                 */
+                                constructor(logLevel?: ReporterLogLevel);
+                                /**
+                                 * The messages that have been logged.
+                                 */
+                                get logged(): string[];
+                                /**
+                                 * The messages that have been suppressed.
+                                 */
+                                get suppressed(): string[];
+                                /**
+                                 * Clears the logged and suppressed messages.
+                                 */
                                 clear(): void;
-                                protected _innerLog(message: string): Success<string | undefined>;
-                                protected _innerSilent(message: string): Success<string | undefined>;
+                                /**
+                                 * {@inheritDoc Logging.LoggerBase._log}
+                                 */
+                                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.
+                                 */
+                                protected _suppressLog(level: MessageLogLevel, message?: unknown, ...parameters: unknown[]): Success<undefined>;
                             }
 
                             /**
@@ -2344,6 +2468,11 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                  * with an error if the index is out of range.
                                  */
                                 getAt(index: number): Result<TITEM>;
+                                /**
+                                 * Gets all items in the collection, ordered by index.
+                                 * @returns An array of items in the collection, ordered by index.
+                                 */
+                                valuesByIndex(): ReadonlyArray<TITEM>;
                             }
 
                             /**
@@ -2444,7 +2573,11 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                 /**
                                  * {@inheritdoc Collections.IReadOnlyValidatingCollector.getAt}
                                  */
-                                readonly getAt: (index: number) => Result<TITEM>;
+                                getAt(index: number): Result<TITEM>;
+                                /**
+                                 * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+                                 */
+                                valuesByIndex(): ReadonlyArray<TITEM>;
                             }
 
                             /**
@@ -2634,6 +2767,12 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                  * errors will be aggregated.
                                  */
                                 aggregateError(errors: IMessageAggregator): this;
+                                /**
+                                 * Reports the result to the supplied reporter
+                                 * @param reporter - The {@link IResultReporter | reporter} to which the result will be reported.
+                                 * @param options - The {@link IResultReportOptions | options} for reporting the result.
+                                 */
+                                report(reporter: IResultReporter<T>, options?: IResultReportOptions): this;
                             }
 
                             /**
@@ -2665,6 +2804,30 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                 converters: KeyValueConverters<TK, TV>;
                             }
 
+                            /**
+                             * Interface for reporting a result.
+                             * @public
+                             */
+                            export declare interface IResultReporter<T, TD = unknown> {
+                                reportSuccess(level: MessageLogLevel, value: T, detail?: TD): void;
+                                reportFailure(level: MessageLogLevel, message: string, detail?: TD): void;
+                            }
+
+                            /**
+                             * Options for reporting a result.
+                             * @public
+                             */
+                            export declare interface IResultReportOptions {
+                                /**
+                                 * The level of reporting to be used for failure results.  Default is 'error'.
+                                 */
+                                failure?: MessageLogLevel;
+                                /**
+                                 * The level of reporting to be used for success results.  Default is 'quiet'.
+                                 */
+                                success?: MessageLogLevel;
+                            }
+
                             /**
                              * Helper function to create a {@link Converter | Converter} from a supplied type guard function.
                              * @param description - a description of the thing to be validated for use in error messages
@@ -2850,49 +3013,126 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                             declare function literal_2<T extends string | number | boolean | symbol | null | undefined>(value: T): Validator<T>;
 
                             /**
+                             * Abstract base class which implements {@link Logging.ILogger | ILogger}.
                              * @public
                              */
-                            declare interface Logger {
-                                log(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-                                detail(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-                                info(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-                                warn(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
-                                warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-                                error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-                            }
-
-                            /**
-                             * @public
-                             */
-                            declare abstract class LoggerBase {
-                                logLevel: LogLevel;
-                                constructor(logLevel?: LogLevel);
+                            declare abstract class LoggerBase implements ILogger {
+                                /**
+                                 * {@inheritDoc Logging.ILogger.logLevel}
+                                 */
+                                logLevel: ReporterLogLevel;
+                                protected constructor(logLevel?: ReporterLogLevel);
+                                /**
+                                 * {@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>;
-                                warnAndFail<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-                                error<T>(message?: unknown, ...parameters: unknown[]): Failure<T>;
-                                log(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                                /**
+                                 * {@inheritDoc Logging.ILogger.error}
+                                 */
+                                error(message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                                /**
+                                 * {@inheritDoc Logging.ILogger.log}
+                                 */
+                                log(level: MessageLogLevel, message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                                /**
+                                 * Formats a message and parameters into a string.
+                                 * @param message - The message to format.
+                                 * @param parameters - The parameters to format.
+                                 * @returns The formatted message.
+                                 * @public
+                                 */
                                 protected _format(message?: unknown, ...parameters: unknown[]): string;
-                                protected _innerSilent(__message: string): Success<string | undefined>;
-                                protected abstract _innerLog(message: string): Success<string | undefined>;
+                                /**
+                                 * Inner method called for suppressed log messages.
+                                 */
+                                protected _suppressLog(__level: MessageLogLevel, __message?: unknown, ...__parameters: unknown[]): Success<undefined>;
+                                protected abstract _log(message: string, level: MessageLogLevel): Success<string | undefined>;
                             }
 
                             declare namespace Logging {
                                 export {
-                                    LogLevel,
-                                    Logger,
+                                    shouldLog,
+                                    ReporterLogLevel,
+                                    ILogger,
                                     LoggerBase,
                                     InMemoryLogger,
-                                    NoOpLogger
+                                    ConsoleLogger,
+                                    NoOpLogger,
+                                    LogValueFormatter,
+                                    LogMessageFormatter,
+                                    ILogReporterCreateParams,
+                                    LogReporter
                                 }
                             }
                             export { Logging }
 
                             /**
+                             * A function that formats a message for logging.
+                             * @public
+                             */
+                            declare type LogMessageFormatter<TD = unknown> = (message: string, detail?: TD) => string;
+
+                            /**
+                             * Abstract base class which wraps an existing {@link Logging.ILogger | ILogger} to implement
+                             * both {@link Logging.ILogger | ILogger} and {@link IResultReporter | IResultReporter}.
+                             * @public
+                             */
+                            declare class LogReporter<T, TD = unknown> implements ILogger, IResultReporter<T, TD> {
+                                protected readonly _logger: ILogger;
+                                protected readonly _valueFormatter: LogValueFormatter<T, TD>;
+                                protected readonly _messageFormatter: LogMessageFormatter<TD>;
+                                /**
+                                 * Creates a new {@link Logging.LogReporter | LogReporter}.
+                                 * @param params - The parameters for creating the {@link Logging.LogReporter | LogReporter}.
+                                 */
+                                constructor(params: ILogReporterCreateParams<T, TD>);
+                                /**
+                                 * {@inheritDoc Logging.ILogger.logLevel}
+                                 */
+                                get logLevel(): ReporterLogLevel;
+                                /**
+                                 * {@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.ILogger.log}
+                                 */
+                                log(level: MessageLogLevel, message?: unknown, ...parameters: unknown[]): Success<string | undefined>;
+                                /**
+                                 * {@inheritDoc IResultReporter.reportSuccess}
+                                 */
+                                reportSuccess(level: MessageLogLevel, value: T, detail?: TD): void;
+                                /**
+                                 * {@inheritDoc IResultReporter.reportFailure}
+                                 */
+                                reportFailure(level: MessageLogLevel, message: string, detail?: TD): void;
+                            }
+
+                            /**
+                             * A function that formats a value for logging.
                              * @public
                              */
-                            declare type LogLevel = 'detail' | 'info' | 'warning' | 'error' | 'silent';
+                            declare type LogValueFormatter<T, TD = unknown> = (value: T, detail?: TD) => string;
 
                             /**
                              * Aggregates successful results from a collection of {@link DetailedResult | DetailedResult<T, TD>},
@@ -3078,10 +3318,25 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                    }
 
                                    /**
+                                    * The severity level at which a message should be logged.
+                                    * @public
+                                    */
+                                   export declare type MessageLogLevel = 'quiet' | 'detail' | 'info' | 'warning' | 'error';
+
+                                   /**
+                                    * A no-op {@link Logging.LoggerBase | LoggerBase} that does not log anything.
                                     * @public
                                     */
                                    declare class NoOpLogger extends LoggerBase {
-                                       protected _innerLog(message: string): Success<string | undefined>;
+                                       /**
+                                        * Creates a new no-op logger.
+                                        * @param logLevel - The level of logging to be used.
+                                        */
+                                       constructor(logLevel?: ReporterLogLevel);
+                                       /**
+                                        * {@inheritDoc Logging.LoggerBase._log}
+                                        */
+                                       protected _log(message: string, __level: MessageLogLevel): Success<string | undefined>;
                                    }
 
                                    /**
@@ -3781,6 +4036,12 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                             */
                                         export declare function recordToMap<TS, TD, TK extends string = string>(src: Record<TK, TS>, factory: KeyedThingFactory<TS, TD, TK>): Result<Map<TK, TD>>;
 
+                                        /**
+                                         * The level of logging to be used.
+                                         * @public
+                                         */
+                                        declare type ReporterLogLevel = 'all' | 'detail' | 'info' | 'warning' | 'error' | 'silent';
+
                                         /**
                                          * Represents the {@link IResult | result} of some operation or sequence of operations.
                                          * @remarks
@@ -4041,6 +4302,15 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                          */
                                         export declare type ResultValueType<T> = T extends Result<infer TV> ? TV : never;
 
+                                        /**
+                                         * Compares two log levels.
+                                         * @param message - The first log level.
+                                         * @param reporter - The second log level.
+                                         * @returns `true` if the message should be logged, `false` if it should be suppressed.
+                                         * @public
+                                         */
+                                        declare function shouldLog(message: MessageLogLevel, reporter: ReporterLogLevel): boolean;
+
                                         /**
                                          * Helper function to create a {@link Conversion.ObjectConverter | ObjectConverter} which converts an object
                                          * without changing shape, a {@link Conversion.FieldConverters | FieldConverters<T, TC>} and an optional
@@ -4336,6 +4606,10 @@ declare class Collectible<TKEY extends string = string, TINDEX extends number =
                                                     * {@inheritdoc IResult.aggregateError}
                                                     */
                                                    aggregateError(__errors: IMessageAggregator): this;
+                                                   /**
+                                                    * {@inheritdoc IResult.report}
+                                                    */
+                                                   report(reporter: IResultReporter<T>, options?: IResultReportOptions): this;
                                                    /**
                                                     * Creates a {@link Success | Success<T>} with the supplied value.
                                                     * @param value - The value to be returned.

package/lib/index.d.ts

@@ -2,10 +2,11 @@ import * as Collections from './packlets/collections';
 import * as Conversion from './packlets/conversion';
 import * as Hash from './packlets/hash';
 import * as FileTree from './packlets/file-tree';
+import * as Logging from './packlets/logging';
 import * as Validation from './packlets/validation';
 import { Collector, ICollectible, ConvertingCollector, IReadOnlyResultMap, ResultMap, ValidatingCollector, ValidatingConvertingCollector, ValidatingResultMap } from './packlets/collections';
 import { Converter, Converters, ObjectConverter, StringConverter } from './packlets/conversion';
 import { Validator, Validators } from './packlets/validation';
 export * from './packlets/base';
-export { Collections, Collector, ConvertingCollector, Conversion, Converter, Converters, FileTree, Hash, ICollectible, IReadOnlyResultMap, ObjectConverter, ResultMap, StringConverter, ValidatingCollector, ValidatingConvertingCollector, ValidatingResultMap, Validation, Validator, Validators };
+export { Collections, Collector, ConvertingCollector, Conversion, Converter, Converters, FileTree, Hash, ICollectible, IReadOnlyResultMap, Logging, ObjectConverter, ResultMap, StringConverter, ValidatingCollector, ValidatingConvertingCollector, ValidatingResultMap, Validation, Validator, Validators };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -57,7 +57,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 });
-exports.Validators = exports.Validation = exports.ValidatingResultMap = exports.ValidatingConvertingCollector = exports.ValidatingCollector = exports.StringConverter = exports.ResultMap = exports.ObjectConverter = exports.Hash = exports.FileTree = exports.Converters = exports.Conversion = exports.ConvertingCollector = exports.Collector = exports.Collections = void 0;
+exports.Validators = exports.Validation = exports.ValidatingResultMap = exports.ValidatingConvertingCollector = exports.ValidatingCollector = exports.StringConverter = exports.ResultMap = exports.ObjectConverter = exports.Logging = exports.Hash = exports.FileTree = exports.Converters = exports.Conversion = exports.ConvertingCollector = exports.Collector = exports.Collections = void 0;
 const Collections = __importStar(require("./packlets/collections"));
 exports.Collections = Collections;
 const Conversion = __importStar(require("./packlets/conversion"));
@@ -66,6 +66,8 @@ const Hash = __importStar(require("./packlets/hash"));
 exports.Hash = Hash;
 const FileTree = __importStar(require("./packlets/file-tree"));
 exports.FileTree = FileTree;
+const Logging = __importStar(require("./packlets/logging"));
+exports.Logging = Logging;
 const Validation = __importStar(require("./packlets/validation"));
 exports.Validation = Validation;
 const collections_1 = require("./packlets/collections");

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

@@ -1,9 +1,7 @@
-import * as Logging from './logger';
 export * from './brand';
 export * from './mapResults';
 export * from './messageAggregator';
 export { Normalizer } from './normalize';
 export * from './result';
 export * from './utils';
-export { Logging };
 //# sourceMappingURL=index.d.ts.map

package/lib/packlets/base/index.js

@@ -31,35 +31,11 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 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 });
-exports.Logging = exports.Normalizer = void 0;
-const Logging = __importStar(require("./logger"));
-exports.Logging = Logging;
+exports.Normalizer = void 0;
 __exportStar(require("./brand"), exports);
 __exportStar(require("./mapResults"), exports);
 __exportStar(require("./messageAggregator"), exports);

package/lib/packlets/base/result.d.ts

@@ -41,6 +41,33 @@ export interface IResultLogger<TD = unknown> {
      */
     error(message: string, detail?: TD): void;
 }
+/**
+ * The severity level at which a message should be logged.
+ * @public
+ */
+export type MessageLogLevel = 'quiet' | 'detail' | 'info' | 'warning' | 'error';
+/**
+ * Options for reporting a result.
+ * @public
+ */
+export interface IResultReportOptions {
+    /**
+     * The level of reporting to be used for failure results.  Default is 'error'.
+     */
+    failure?: MessageLogLevel;
+    /**
+     * The level of reporting to be used for success results.  Default is 'quiet'.
+     */
+    success?: MessageLogLevel;
+}
+/**
+ * Interface for reporting a result.
+ * @public
+ */
+export interface IResultReporter<T, TD = unknown> {
+    reportSuccess(level: MessageLogLevel, value: T, detail?: TD): void;
+    reportFailure(level: MessageLogLevel, message: string, detail?: TD): void;
+}
 /**
  * Simple error aggregator to simplify collecting all errors in
  * a flow.
@@ -237,6 +264,12 @@ export interface IResult<T> {
      * errors will be aggregated.
      */
     aggregateError(errors: IMessageAggregator): this;
+    /**
+     * Reports the result to the supplied reporter
+     * @param reporter - The {@link IResultReporter | reporter} to which the result will be reported.
+     * @param options - The {@link IResultReportOptions | options} for reporting the result.
+     */
+    report(reporter: IResultReporter<T>, options?: IResultReportOptions): this;
 }
 /**
  * Reports a successful {@link IResult | result} from some operation and the
@@ -323,6 +356,10 @@ export declare class Success<T> implements IResult<T> {
      * {@inheritdoc IResult.aggregateError}
      */
     aggregateError(__errors: IMessageAggregator): this;
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter: IResultReporter<T>, options?: IResultReportOptions): this;
     /**
      * Creates a {@link Success | Success<T>} with the supplied value.
      * @param value - The value to be returned.
@@ -415,6 +452,10 @@ export declare class Failure<T> implements IResult<T> {
      * {@inheritdoc IResult.aggregateError}
      */
     aggregateError(errors: IMessageAggregator): this;
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter: IResultReporter<T>, options?: IResultReportOptions): this;
     /**
      * Get a 'friendly' string representation of this object.
      * @remarks
@@ -537,6 +578,10 @@ export declare class DetailedSuccess<T, TD> extends Success<T> {
      * {@inheritdoc Success.withErrorFormat}
      */
     withErrorFormat(cb: ErrorFormatter): DetailedResult<T, TD>;
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter: IResultReporter<T, TD>, options?: IResultReportOptions): this;
     /**
      * Creates a {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value and
      * optional detail.
@@ -599,6 +644,10 @@ export declare class DetailedFailure<T, TD> extends Failure<T> {
      * {@inheritdoc IResult.withErrorFormat}
      */
     withErrorFormat(cb: ErrorFormatter<TD>): DetailedResult<T, TD>;
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter: IResultReporter<T, TD>, options?: IResultReportOptions): this;
     orThrow(logOrFormat?: IResultLogger<TD> | ErrorFormatter<TD>): never;
     orThrow(cb: ErrorFormatter): never;
     /**