@fgv/ts-utils 5.0.2 → 5.1.0-0

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

@@ -9,17 +9,123 @@ export interface IResultMapConstructorParams<TK extends string = string, TV = un
     entries?: Iterable<KeyValueEntry<TK, TV>>;
 }
 /**
- * Deferred constructor for the {@link Collections.ResultMap.(getOrAdd:2) | getOrAdd} method.
+ * Deferred constructor for the {@link Collections.ResultMap.getOrAdd | getOrAdd} method.
  * @public
  */
 export type ResultMapValueFactory<TK extends string = string, TV = unknown> = (key: TK) => Result<TV>;
+/**
+ * Interface for a mutable {@link Collections.ResultMap | ResultMap}.
+ * @public
+ */
+export interface IResultMap<TK extends string = string, TV = unknown> extends IReadOnlyResultMap<TK, TV> {
+    /**
+     * Sets a key/value pair in the map if the key does not already exist.
+     * @param key - The key to set.
+     * @param value - The value to set.
+     * @returns `Success` with the value and detail `added` if the key was added,
+     * `Failure` with detail `exists` if the key already exists. Fails with detail
+     * 'invalid-key' or 'invalid-value' and an error message if either is invalid.
+     */
+    add(key: TK, value: TV): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Sets a key/value pair in the map regardless of whether the key already exists.
+     * @param key - The key to set.
+     * @param value - The value to set.
+     * @returns `Success` with the new value and the detail `updated` if the
+     * key was found and updated, `Success` with the new value and detail
+     * `added` if the key was not found and added.  Fails with detail
+     * 'invalid-key' or 'invalid-value' and an error message if either is invalid.
+     */
+    set(key: TK, value: TV): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Updates the value associated with a key in the map.
+     * @param key - The key to update.
+     * @param value - The value to set.
+     * @returns `Success` with the value and detail 'updated' if the key was found
+     * and the value updated, `Failure` an error message and with detail `not-found`
+     * if the key was not found, or with detail 'invalid-key' or 'invalid-value'
+     * if either is invalid.
+     */
+    update(key: TK, value: TV): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Deletes a key from the map.
+     * @param key - The key to delete.
+     * @returns `Success` with the previous value and the detail 'deleted'
+     * if the key was found and deleted, `Failure` with detail 'not-found'
+     * if the key was not found, or with detail 'invalid-key' if the key is invalid.
+     */
+    delete(key: TK): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Gets a value from the map.
+     * @param key - The key to retrieve.
+     * @returns `Success` with the value and detail `exists` if the key was found,
+     * `Failure` with detail `not-found` if the key was not found or with detail
+     * `invalid-key` if the key is invalid.
+     */
+    get(key: TK): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Gets a value from the map, or adds a supplied value if it does not exist.
+     * @param key - The key to be retrieved or created.
+     * @param value - The value to add if the key does not exist.
+     * @returns `Success` with the value and detail `exists` if the key was found,
+     * `Success` with the value and detail `added` if the key was not found and added.
+     * Fails with detail 'invalid-key' or 'invalid-value' and an error message if either
+     * is invalid.
+     * {@label WITH_VALUE}
+     */
+    getOrAdd(key: TK, value: TV): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Gets a value from the map, or adds a value created by a factory function if it does not exist.
+     * @param key - The key of the element to be retrieved or created.
+     * @param factory - A {@link Collections.ResultMapValueFactory | factory function} to create the value if
+     * the key does not exist.
+     * @returns `Success` with the value and detail `exists` if the key was found, `Success` with
+     * the value and detail `added` if the key was not found and added. Fails with detail 'invalid-key'
+     * or 'invalid-value' and an error message if either is invalid.
+     * {@label WITH_FACTORY}
+     */
+    getOrAdd(key: TK, factory: ResultMapValueFactory<TK, TV>): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Returns an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    entries(): IterableIterator<KeyValueEntry<TK, TV>>;
+    /**
+     * Returns the number of entries in the map.
+     */
+    readonly size: number;
+    /**
+     * Returns an iterator over the map keys.
+     * @returns An iterator over the map keys.
+     */
+    keys(): IterableIterator<TK>;
+    /**
+     * Returns an iterator over the map values.
+     * @returns An iterator over the map values.
+     */
+    values(): IterableIterator<TV>;
+    /**
+     * Calls a function for each entry in the map.
+     * @param cb - The function to call for each entry.
+     * @param arg - An optional argument to pass to the callback.
+     */
+    forEach(cb: ResultMapForEachCb<TK, TV>, arg?: unknown): void;
+    /**
+     * Clears all entries from the map.
+     */
+    clear(): void;
+    /**
+     * Gets a readonly version of this map.
+     */
+    toReadOnly(): IReadOnlyResultMap<TK, TV>;
+}
 /**
  * A {@link Collections.ResultMap | ResultMap} class as a `Map<TK, TV>`-like object which
  * reports success or failure with additional details using the
  * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-utils#the-result-pattern | result pattern}.
  * @public
  */
-export declare class ResultMap<TK extends string = string, TV = unknown> implements IReadOnlyResultMap<TK, TV> {
+export declare class ResultMap<TK extends string = string, TV = unknown> implements IResultMap<TK, TV> {
     /**
      * Protected raw access to the inner `Map<TK, TV>` object.
      * @public

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

@@ -8,15 +8,15 @@ import { KeyValueConverters } from './keyValueConverters';
  */
 export interface IReadOnlyResultMapValidator<TK extends string = string, TV = unknown> {
     /**
-     * {@inheritdoc Collections.ResultMapValidator.map}
+     * {@inheritDoc Collections.ReadOnlyResultMapValidator.map}
      */
     readonly map: IReadOnlyResultMap<TK, TV>;
     /**
-     * {@inheritdoc Collections.ResultMap.get}
+     * {@inheritDoc Collections.ResultMap.get}
      */
     get(key: string): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: string): boolean;
 }
@@ -28,6 +28,40 @@ export interface IResultMapValidatorCreateParams<TK extends string = string, TV
     map: ResultMap<TK, TV>;
     converters: KeyValueConverters<TK, TV>;
 }
+/**
+ * A read-only validator for any {@link Collections.IReadOnlyResultMap | IReadOnlyResultMap}
+ * that validates weakly-typed keys before accessing values.
+ * @public
+ */
+export declare class ReadOnlyResultMapValidator<TK extends string = string, TV = unknown> implements IReadOnlyResultMapValidator<TK, TV> {
+    /**
+     * The key-value converters used for validation.
+     */
+    readonly converters: KeyValueConverters<TK, TV>;
+    /**
+     * The underlying map.
+     */
+    get map(): IReadOnlyResultMap<TK, TV>;
+    private readonly _map;
+    /**
+     * Constructs a new {@link Collections.ReadOnlyResultMapValidator | ReadOnlyResultMapValidator}.
+     * @param map - The map to validate access to.
+     * @param converters - The key-value converters for validation.
+     */
+    constructor(map: IReadOnlyResultMap<TK, TV>, converters: KeyValueConverters<TK, TV>);
+    /**
+     * Gets a value from the map by key, validating the key first.
+     * @param key - The key to retrieve (will be validated).
+     * @returns `Success` with the value if found, `Failure` otherwise.
+     */
+    get(key: string): DetailedResult<TV, ResultMapResultDetail>;
+    /**
+     * Checks if the map contains a key, validating the key first.
+     * @param key - The key to check (will be validated).
+     * @returns `true` if the key exists and is valid, `false` otherwise.
+     */
+    has(key: string): boolean;
+}
 /**
  * A {@link Collections.ResultMap | ResultMap} wrapper which validates weakly-typed keys
  * before calling the wrapped result map.
@@ -43,35 +77,35 @@ export declare class ResultMapValidator<TK extends string = string, TV = unknown
      */
     constructor(params: IResultMapValidatorCreateParams<TK, TV>);
     /**
-     * {@inheritdoc Collections.ResultMap.add}
+     * {@inheritDoc Collections.ResultMap.add}
      */
     add(key: string, value: unknown): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.delete}
+     * {@inheritDoc Collections.ResultMap.delete}
      */
     delete(key: string): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.get}
+     * {@inheritDoc Collections.ResultMap.get}
      */
     get(key: string): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.(getOrAdd:1)}
+     * {@inheritDoc Collections.ResultMap.getOrAdd}
      */
     getOrAdd(key: string, value: unknown): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.(getOrAdd:2)}
+     * {@inheritDoc Collections.ResultMap.getOrAdd}
      */
     getOrAdd(key: string, factory: ResultMapValueFactory<TK, TV>): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key: string): boolean;
     /**
-     * {@inheritdoc Collections.ResultMap.set}
+     * {@inheritDoc Collections.ResultMap.set}
      */
     set(key: string, value: unknown): DetailedResult<TV, ResultMapResultDetail>;
     /**
-     * {@inheritdoc Collections.ResultMap.update}
+     * {@inheritDoc Collections.ResultMap.update}
      */
     update(key: string, value: unknown): DetailedResult<TV, ResultMapResultDetail>;
     /**

package/lib/packlets/collections/resultMapValidator.js

@@ -21,8 +21,53 @@
  * SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResultMapValidator = void 0;
+exports.ResultMapValidator = exports.ReadOnlyResultMapValidator = void 0;
 const base_1 = require("../base");
+/**
+ * A read-only validator for any {@link Collections.IReadOnlyResultMap | IReadOnlyResultMap}
+ * that validates weakly-typed keys before accessing values.
+ * @public
+ */
+class ReadOnlyResultMapValidator {
+    /**
+     * The underlying map.
+     */
+    get map() {
+        return this._map;
+    }
+    /**
+     * Constructs a new {@link Collections.ReadOnlyResultMapValidator | ReadOnlyResultMapValidator}.
+     * @param map - The map to validate access to.
+     * @param converters - The key-value converters for validation.
+     */
+    constructor(map, converters) {
+        this._map = map;
+        this.converters = converters;
+    }
+    /**
+     * Gets a value from the map by key, validating the key first.
+     * @param key - The key to retrieve (will be validated).
+     * @returns `Success` with the value if found, `Failure` otherwise.
+     */
+    get(key) {
+        return this.converters.convertKey(key).onSuccess((validKey) => {
+            return this._map.get(validKey);
+        });
+    }
+    /**
+     * Checks if the map contains a key, validating the key first.
+     * @param key - The key to check (will be validated).
+     * @returns `true` if the key exists and is valid, `false` otherwise.
+     */
+    has(key) {
+        const result = this.converters.convertKey(key);
+        if (result.isFailure()) {
+            return false;
+        }
+        return this._map.has(result.value);
+    }
+}
+exports.ReadOnlyResultMapValidator = ReadOnlyResultMapValidator;
 /**
  * A {@link Collections.ResultMap | ResultMap} wrapper which validates weakly-typed keys
  * before calling the wrapped result map.
@@ -41,7 +86,7 @@ class ResultMapValidator {
         this.converters = params.converters;
     }
     /**
-     * {@inheritdoc Collections.ResultMap.add}
+     * {@inheritDoc Collections.ResultMap.add}
      */
     add(key, value) {
         return this.converters.convertEntry([key, value]).onSuccess(([vk, vv]) => {
@@ -49,7 +94,7 @@ class ResultMapValidator {
         });
     }
     /**
-     * {@inheritdoc Collections.ResultMap.delete}
+     * {@inheritDoc Collections.ResultMap.delete}
      */
     delete(key) {
         return this.converters.convertKey(key).onSuccess((k) => {
@@ -57,7 +102,7 @@ class ResultMapValidator {
         });
     }
     /**
-     * {@inheritdoc Collections.ResultMap.get}
+     * {@inheritDoc Collections.ResultMap.get}
      */
     get(key) {
         return this.converters.convertKey(key).onSuccess((k) => {
@@ -84,13 +129,13 @@ class ResultMapValidator {
         }
     }
     /**
-     * {@inheritdoc Collections.ResultMap.has}
+     * {@inheritDoc Collections.ResultMap.has}
      */
     has(key) {
         return this._map.has(key);
     }
     /**
-     * {@inheritdoc Collections.ResultMap.set}
+     * {@inheritDoc Collections.ResultMap.set}
      */
     set(key, value) {
         return this.converters.convertEntry([key, value]).onSuccess(([vk, vv]) => {
@@ -98,7 +143,7 @@ class ResultMapValidator {
         });
     }
     /**
-     * {@inheritdoc Collections.ResultMap.update}
+     * {@inheritDoc Collections.ResultMap.update}
      */
     update(key, value) {
         return this.converters.convertEntry([key, value]).onSuccess(([vk, vv]) => {

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

@@ -12,15 +12,15 @@ import { CollectorValidator } from './collectorValidator';
  */
 export interface IReadOnlyValidatingCollector<TITEM extends ICollectible<any, any>> extends IReadOnlyValidatingResultMap<CollectibleKey<TITEM>, TITEM> {
     /**
-     * {@inheritdoc Collections.ValidatingCollector.validating}
+     * {@inheritDoc Collections.ValidatingCollector.validating}
      */
     readonly validating: IReadOnlyCollectorValidator<TITEM>;
     /**
-     * {@inheritdoc Collections.IReadOnlyValidatingCollector.getAt}
+     * {@inheritDoc Collections.IReadOnlyCollector.getAt}
      */
     getAt(index: number): Result<TITEM>;
     /**
-     * {@inheritdoc Collections.IReadOnlyCollector.valuesByIndex}
+     * {@inheritDoc Collections.IReadOnlyCollector.valuesByIndex}
      */
     valuesByIndex(): ReadonlyArray<TITEM>;
 }
@@ -30,11 +30,11 @@ export interface IReadOnlyValidatingCollector<TITEM extends ICollectible<any, an
  */
 export interface IValidatingCollectorConstructorParams<TITEM extends ICollectible<any, any>> {
     /**
-     * {@inheritdoc Collections.ICollectorValidatorCreateParams.converters}
+     * {@inheritDoc Collections.ICollectorValidatorCreateParams.converters}
      */
     converters: KeyValueConverters<CollectibleKey<TITEM>, TITEM>;
     /**
-     * {@inheritdoc Collections.ICollectorConstructorParams.items}
+     * {@inheritDoc Collections.ICollectorConstructorParams.items}
      */
     items?: unknown[];
 }

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

@@ -11,15 +11,15 @@ import { IReadOnlyValidatingCollector } from './validatingCollector';
  */
 export interface IValidatingConvertingCollectorConstructorParams<TITEM extends ICollectible<any, any>, TSRC = TITEM> {
     /**
-     * {@inheritdoc Collections.IConvertingCollectorConstructorParams.factory}
+     * {@inheritDoc Collections.IConvertingCollectorConstructorParams.factory}
      */
     factory: CollectibleFactory<TITEM, TSRC>;
     /**
-     * {@inheritdoc Collections.IConvertingCollectorValidatorCreateParams.converters}
+     * {@inheritDoc Collections.IConvertingCollectorValidatorCreateParams.converters}
      */
     converters: KeyValueConverters<CollectibleKey<TITEM>, TSRC>;
     /**
-     * {@inheritdoc Collections.IConvertingCollectorConstructorParams.entries}
+     * {@inheritDoc Collections.IConvertingCollectorConstructorParams.entries}
      */
     entries?: KeyValueEntry<CollectibleKey<TITEM>, TSRC>[];
 }

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

@@ -0,0 +1,102 @@
+import { Result } from '../base';
+import { KeyValueConverters } from './keyValueConverters';
+import { IReadOnlyResultMap } from './readonlyResultMap';
+import { ReadOnlyConvertingResultMap, ConvertingResultMapValueConverter } from './readOnlyConvertingResultMap';
+import { ConvertingResultMap } from './convertingResultMap';
+import { IResultMap } from './resultMap';
+import { ReadOnlyResultMapValidator } from './resultMapValidator';
+/**
+ * Parameters for constructing a
+ * {@link Collections.ValidatingReadOnlyConvertingResultMap | ValidatingReadOnlyConvertingResultMap}.
+ * @public
+ */
+export interface IValidatingReadOnlyConvertingResultMapConstructorParams<TK extends string, TSRC, TTARGET> {
+    /**
+     * The inner map containing source values.
+     */
+    inner: IReadOnlyResultMap<TK, TSRC>;
+    /**
+     * The converter function to transform source values to target values.
+     */
+    converter: ConvertingResultMapValueConverter<TK, TSRC, TTARGET>;
+    /**
+     * The key-value converters for validating weakly-typed access.
+     */
+    converters: KeyValueConverters<TK, TTARGET>;
+}
+/**
+ * A read-only result map that wraps an inner {@link Collections.IReadOnlyResultMap | IReadOnlyResultMap}
+ * of source type and returns lazily-converted, cached values of a target type, with a
+ * {@link Collections.ReadOnlyResultMapValidator | validating} property for weakly-typed access.
+ * @public
+ */
+export declare class ValidatingReadOnlyConvertingResultMap<TK extends string, TSRC, TTARGET> extends ReadOnlyConvertingResultMap<TK, TSRC, TTARGET> {
+    /**
+     * A validator for weakly-typed access to the map.
+     */
+    readonly validating: ReadOnlyResultMapValidator<TK, TTARGET>;
+    /**
+     * The key-value converters used for validation.
+     */
+    protected readonly _converters: KeyValueConverters<TK, TTARGET>;
+    /**
+     * Constructs a new {@link Collections.ValidatingReadOnlyConvertingResultMap | ValidatingReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params: IValidatingReadOnlyConvertingResultMapConstructorParams<TK, TSRC, TTARGET>);
+    /**
+     * Creates a new {@link Collections.ValidatingReadOnlyConvertingResultMap | ValidatingReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create<TK extends string, TSRC, TTARGET>(params: IValidatingReadOnlyConvertingResultMapConstructorParams<TK, TSRC, TTARGET>): Result<ValidatingReadOnlyConvertingResultMap<TK, TSRC, TTARGET>>;
+}
+/**
+ * Parameters for constructing a
+ * {@link Collections.ValidatingConvertingResultMap | ValidatingConvertingResultMap}.
+ * @public
+ */
+export interface IValidatingConvertingResultMapConstructorParams<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>> {
+    /**
+     * The inner map containing source values.
+     */
+    inner: TSRCMAP;
+    /**
+     * The converter function to transform source values to target values.
+     */
+    converter: ConvertingResultMapValueConverter<TK, TSRC, TTARGET>;
+    /**
+     * The key-value converters for validating weakly-typed access.
+     */
+    converters: KeyValueConverters<TK, TTARGET>;
+}
+/**
+ * A result map that wraps an inner {@link Collections.IResultMap | IResultMap} of source type
+ * and returns lazily-converted, cached values of a target type, with a
+ * {@link Collections.ReadOnlyResultMapValidator | validating} property for weakly-typed access
+ * and a {@link Collections.CacheInvalidatingResultMapWrapper | source} property for mutable access
+ * to the underlying source map.
+ * @public
+ */
+export declare class ValidatingConvertingResultMap<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>> extends ConvertingResultMap<TK, TSRC, TTARGET, TSRCMAP> {
+    /**
+     * A validator for weakly-typed access to the map.
+     */
+    readonly validating: ReadOnlyResultMapValidator<TK, TTARGET>;
+    /**
+     * The key-value converters used for validation.
+     */
+    protected readonly _converters: KeyValueConverters<TK, TTARGET>;
+    /**
+     * Constructs a new {@link Collections.ValidatingConvertingResultMap | ValidatingConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params: IValidatingConvertingResultMapConstructorParams<TK, TSRC, TTARGET, TSRCMAP>);
+    /**
+     * Creates a new {@link Collections.ValidatingConvertingResultMap | ValidatingConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create<TK extends string, TSRC, TTARGET, TSRCMAP extends IResultMap<TK, TSRC> = IResultMap<TK, TSRC>>(params: IValidatingConvertingResultMapConstructorParams<TK, TSRC, TTARGET, TSRCMAP>): Result<ValidatingConvertingResultMap<TK, TSRC, TTARGET, TSRCMAP>>;
+}
+//# sourceMappingURL=validatingConvertingResultMap.d.ts.map

package/lib/packlets/collections/validatingConvertingResultMap.js

@@ -0,0 +1,83 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatingConvertingResultMap = exports.ValidatingReadOnlyConvertingResultMap = void 0;
+const base_1 = require("../base");
+const readOnlyConvertingResultMap_1 = require("./readOnlyConvertingResultMap");
+const convertingResultMap_1 = require("./convertingResultMap");
+const resultMapValidator_1 = require("./resultMapValidator");
+/**
+ * A read-only result map that wraps an inner {@link Collections.IReadOnlyResultMap | IReadOnlyResultMap}
+ * of source type and returns lazily-converted, cached values of a target type, with a
+ * {@link Collections.ReadOnlyResultMapValidator | validating} property for weakly-typed access.
+ * @public
+ */
+class ValidatingReadOnlyConvertingResultMap extends readOnlyConvertingResultMap_1.ReadOnlyConvertingResultMap {
+    /**
+     * Constructs a new {@link Collections.ValidatingReadOnlyConvertingResultMap | ValidatingReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params) {
+        super({ inner: params.inner, converter: params.converter });
+        this._converters = params.converters;
+        this.validating = new resultMapValidator_1.ReadOnlyResultMapValidator(this, params.converters);
+    }
+    /**
+     * Creates a new {@link Collections.ValidatingReadOnlyConvertingResultMap | ValidatingReadOnlyConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create(params) {
+        return (0, base_1.captureResult)(() => new ValidatingReadOnlyConvertingResultMap(params));
+    }
+}
+exports.ValidatingReadOnlyConvertingResultMap = ValidatingReadOnlyConvertingResultMap;
+/**
+ * A result map that wraps an inner {@link Collections.IResultMap | IResultMap} of source type
+ * and returns lazily-converted, cached values of a target type, with a
+ * {@link Collections.ReadOnlyResultMapValidator | validating} property for weakly-typed access
+ * and a {@link Collections.CacheInvalidatingResultMapWrapper | source} property for mutable access
+ * to the underlying source map.
+ * @public
+ */
+class ValidatingConvertingResultMap extends convertingResultMap_1.ConvertingResultMap {
+    /**
+     * Constructs a new {@link Collections.ValidatingConvertingResultMap | ValidatingConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     */
+    constructor(params) {
+        super({ inner: params.inner, converter: params.converter });
+        this._converters = params.converters;
+        this.validating = new resultMapValidator_1.ReadOnlyResultMapValidator(this, params.converters);
+    }
+    /**
+     * Creates a new {@link Collections.ValidatingConvertingResultMap | ValidatingConvertingResultMap}.
+     * @param params - Parameters for constructing the map.
+     * @returns `Success` with the new map, or `Failure` with error details if an error occurred.
+     */
+    static create(params) {
+        return (0, base_1.captureResult)(() => new ValidatingConvertingResultMap(params));
+    }
+}
+exports.ValidatingConvertingResultMap = ValidatingConvertingResultMap;
+//# sourceMappingURL=validatingConvertingResultMap.js.map

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

@@ -10,7 +10,7 @@ import { IReadOnlyResultMapValidator, ResultMapValidator } from './resultMapVali
  */
 export interface IReadOnlyValidatingResultMap<TK extends string = string, TV = unknown> extends IReadOnlyResultMap<TK, TV> {
     /**
-     * {@inheritdoc Collections.ValidatingResultMap.validating}
+     * {@inheritDoc Collections.ValidatingResultMap.validating}
      */
     readonly validating: IReadOnlyResultMapValidator<TK, TV>;
 }