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

package/lib/packlets/base/result.js

@@ -130,6 +130,15 @@ class Success {
     aggregateError(__errors) {
         return this;
     }
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter, options) {
+        var _a;
+        const level = (_a = options === null || options === void 0 ? void 0 : options.success) !== null && _a !== void 0 ? _a : 'quiet';
+        reporter.reportSuccess(level, this._value);
+        return this;
+    }
     /**
      * Creates a {@link Success | Success<T>} with the supplied value.
      * @param value - The value to be returned.
@@ -247,6 +256,15 @@ class Failure {
         errors.addMessage(this._message);
         return this;
     }
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter, options) {
+        var _a;
+        const level = (_a = options === null || options === void 0 ? void 0 : options.failure) !== null && _a !== void 0 ? _a : 'error';
+        reporter.reportFailure(level, this._message);
+        return this;
+    }
     /**
      * Get a 'friendly' string representation of this object.
      * @remarks
@@ -376,6 +394,15 @@ class DetailedSuccess extends Success {
     withErrorFormat(cb) {
         return this;
     }
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter, options) {
+        var _a;
+        const level = (_a = options === null || options === void 0 ? void 0 : options.success) !== null && _a !== void 0 ? _a : 'quiet';
+        reporter.reportSuccess(level, this._value, this._detail);
+        return this;
+    }
     /**
      * Creates a {@link DetailedSuccess | DetailedSuccess<T, TD>} with the supplied value and
      * optional detail.
@@ -452,6 +479,15 @@ class DetailedFailure extends Failure {
     withErrorFormat(cb) {
         return failWithDetail(cb(this._message, this._detail), this._detail);
     }
+    /**
+     * {@inheritdoc IResult.report}
+     */
+    report(reporter, options) {
+        var _a;
+        const level = (_a = options === null || options === void 0 ? void 0 : options.failure) !== null && _a !== void 0 ? _a : 'error';
+        reporter.reportFailure(level, this._message, this._detail);
+        return this;
+    }
     orThrow(logOrFormat) {
         if (logOrFormat !== undefined) {
             if (typeof logOrFormat === 'function') {

package/lib/packlets/collections/collector.d.ts

@@ -19,6 +19,11 @@ export interface IReadOnlyCollector<TITEM extends ICollectible<any, any>> extend
      * 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>;
 }
 /**
  * Parameters for constructing a {@link Collections.Collector | ICollector}.
@@ -115,6 +120,10 @@ export declare class Collector<TITEM extends ICollectible<any, any>> implements
      * {@inheritdoc Collections.ResultMap.values}
      */
     values(): IterableIterator<TITEM>;
+    /**
+     * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+     */
+    valuesByIndex(): ReadonlyArray<TITEM>;
     /**
      * Gets a read-only version of this collector.
      */

package/lib/packlets/collections/collector.js

@@ -157,6 +157,12 @@ class Collector {
     values() {
         return this._byKey.values();
     }
+    /**
+     * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+     */
+    valuesByIndex() {
+        return this._byIndex;
+    }
     /**
      * Gets a read-only version of this collector.
      */

package/lib/packlets/collections/validatingCollector.d.ts

@@ -18,7 +18,11 @@ export interface IReadOnlyValidatingCollector<TITEM extends ICollectible<any, an
     /**
      * {@inheritdoc Collections.IReadOnlyValidatingCollector.getAt}
      */
-    readonly getAt: (index: number) => Result<TITEM>;
+    getAt(index: number): Result<TITEM>;
+    /**
+     * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+     */
+    valuesByIndex(): ReadonlyArray<TITEM>;
 }
 /**
  * Parameters for constructing a {@link Collections.ValidatingCollector | ValidatingCollector}.

package/lib/packlets/hash/hashingNormalizer.js

@@ -51,13 +51,14 @@ class HashingNormalizer extends base_1.Normalizer {
                 }
                 else if (Array.isArray(from)) {
                     return (0, base_1.mapResults)(from.map((e) => this.computeHash(e))).onSuccess((a) => {
-                        return (0, base_1.captureResult)(() => this._hash(a));
+                        return (0, base_1.captureResult)(() => this._hash(['array', ...a]));
                     });
                 }
                 else if (from instanceof Map || from instanceof Set) {
-                    return this.computeHash(this.normalizeEntries(from.entries()));
+                    const type = from instanceof Map ? 'map' : 'set';
+                    return this.computeHash([type, ...this.normalizeEntries(from.entries())]);
                 }
-                return this.computeHash(this.normalizeEntries(Object.entries(from)));
+                return this.computeHash(['object', ...this.normalizeEntries(Object.entries(from))]);
         }
         return (0, base_1.fail)(`computeHash: Unexpected type - cannot hash '${typeof from}'`);
     }

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

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

package/{src/packlets/hash/index.ts → lib/packlets/logging/index.js}

@@ -1,3 +1,4 @@
+"use strict";
 /*
  * Copyright (c) 2020 Erik Fortune
  *
@@ -19,6 +20,21 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-
-export * from './crcNormalizer';
-export * from './hashingNormalizer';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./logger"), exports);
+__exportStar(require("./logReporter"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,69 @@
+import { ILogger, ReporterLogLevel } from './logger';
+import { IResultReporter, MessageLogLevel, Success } from '../base';
+/**
+ * A function that formats a value for logging.
+ * @public
+ */
+export type LogValueFormatter<T, TD = unknown> = (value: T, detail?: TD) => string;
+/**
+ * A function that formats a message for logging.
+ * @public
+ */
+export type LogMessageFormatter<TD = unknown> = (message: string, detail?: TD) => string;
+/**
+ * Parameters for creating a {@link Logging.LogReporter | LogReporter}.
+ * @public
+ */
+export interface ILogReporterCreateParams<T, TD = unknown> {
+    logger: ILogger;
+    valueFormatter?: LogValueFormatter<T, TD>;
+    messageFormatter?: LogMessageFormatter<TD>;
+}
+/**
+ * Abstract base class which wraps an existing {@link Logging.ILogger | ILogger} to implement
+ * both {@link Logging.ILogger | ILogger} and {@link IResultReporter | IResultReporter}.
+ * @public
+ */
+export 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;
+}
+//# sourceMappingURL=logReporter.d.ts.map

package/lib/packlets/logging/logReporter.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogReporter = void 0;
+/**
+ * Abstract base class which wraps an existing {@link Logging.ILogger | ILogger} to implement
+ * both {@link Logging.ILogger | ILogger} and {@link IResultReporter | IResultReporter}.
+ * @public
+ */
+class LogReporter {
+    /**
+     * Creates a new {@link Logging.LogReporter | LogReporter}.
+     * @param params - The parameters for creating the {@link Logging.LogReporter | LogReporter}.
+     */
+    constructor(params) {
+        var _a, _b;
+        this._logger = params.logger;
+        this._valueFormatter = (_a = params.valueFormatter) !== null && _a !== void 0 ? _a : ((message, __detail) => String(message));
+        this._messageFormatter = (_b = params.messageFormatter) !== null && _b !== void 0 ? _b : ((message, __detail) => message);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.logLevel}
+     */
+    get logLevel() {
+        return this._logger.logLevel;
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.detail}
+     */
+    detail(message, ...parameters) {
+        return this._logger.detail(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.info}
+     */
+    info(message, ...parameters) {
+        return this._logger.info(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.warn}
+     */
+    warn(message, ...parameters) {
+        return this._logger.warn(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.error}
+     */
+    error(message, ...parameters) {
+        return this._logger.error(message, ...parameters);
+    }
+    /**
+     * {@inheritDoc Logging.ILogger.log}
+     */
+    log(level, message, ...parameters) {
+        return this._logger.log(level, message, ...parameters);
+    }
+    /**
+     * {@inheritDoc IResultReporter.reportSuccess}
+     */
+    reportSuccess(level, value, detail) {
+        const formatted = this._valueFormatter(value, detail);
+        this.log(level, formatted);
+    }
+    /**
+     * {@inheritDoc IResultReporter.reportFailure}
+     */
+    reportFailure(level, message, detail) {
+        const formatted = this._messageFormatter(message, detail);
+        this.log(level, formatted);
+    }
+}
+exports.LogReporter = LogReporter;
+//# sourceMappingURL=logReporter.js.map

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

@@ -0,0 +1,183 @@
+import { MessageLogLevel, Success } from '../base';
+/**
+ * The level of logging to be used.
+ * @public
+ */
+export type ReporterLogLevel = 'all' | 'detail' | 'info' | 'warning' | 'error' | 'silent';
+/**
+ * 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
+ */
+export declare function shouldLog(message: MessageLogLevel, reporter: ReporterLogLevel): boolean;
+/**
+ * Generic Result-aware logger interface with multiple levels of logging.
+ * @public
+ */
+export 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>;
+}
+/**
+ * Abstract base class which implements {@link Logging.ILogger | ILogger}.
+ * @public
+ */
+export 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>;
+    /**
+     * {@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;
+    /**
+     * 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>;
+}
+/**
+ * An in-memory logger that stores logged and suppressed messages.
+ * @public
+ */
+export declare class InMemoryLogger extends LoggerBase {
+    /**
+     * 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;
+    /**
+     * {@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>;
+}
+/**
+ * A console logger that outputs messages to the console.
+ * @public
+ */
+export 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 no-op {@link Logging.LoggerBase | LoggerBase} that does not log anything.
+ * @public
+ */
+export declare class NoOpLogger extends LoggerBase {
+    /**
+     * 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>;
+}
+//# sourceMappingURL=logger.d.ts.map