@fgv/ts-utils 5.0.1-9 → 5.0.1

package/dist/packlets/collections/convertingCollectorValidator.js

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+import { failWithDetail } from '../base';
+/**
+ * A {@link Collections.ConvertingCollector | ConvertingCollector} wrapper which validates weakly-typed keys
+ * and values before calling the wrapped collector.  Unlike the basic {@link Collections.CollectorValidator | CollectorValidator},
+ * the converting collector expects the items to be in the source type of the converting collector, not the target type.
+ * @public
+ */
+export class ConvertingCollectorValidator {
+    get map() {
+        return this._collector.toReadOnly();
+    }
+    /**
+     * Constructs a new {@link Collections.ConvertingCollectorValidator | ConvertingCollectorValidator}.
+     * @param params - Required parameters for constructing the collector validator.
+     */
+    constructor(params) {
+        this._collector = params.collector;
+        this.converters = params.converters;
+    }
+    add(key, valueOrFactory) {
+        if (this.has(key)) {
+            return failWithDetail(`${key}: already exists`, 'exists');
+        }
+        return this.getOrAdd(key, valueOrFactory);
+    }
+    /**
+     * {@inheritdoc Collections.Collector.get}
+     */
+    get(key) {
+        return this.converters.convertKey(key).onSuccess((k) => {
+            return this._collector.get(k);
+        });
+    }
+    getOrAdd(key, valueOrFactory) {
+        if (!this._isCollectibleFactoryCallback(valueOrFactory)) {
+            const converted = this.converters.convertEntry([key, valueOrFactory]);
+            if (converted.isFailure()) {
+                return failWithDetail(converted.message, converted.detail);
+            }
+            const [vk, vs] = converted.value;
+            return this._collector.getOrAdd(vk, vs);
+        }
+        else {
+            const converted = this.converters.convertKey(key);
+            if (converted.isFailure()) {
+                return failWithDetail(converted.message, converted.detail);
+            }
+            return this._collector.getOrAdd(converted.value, valueOrFactory);
+        }
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.has}
+     */
+    has(key) {
+        return this._collector.has(key);
+    }
+    /**
+     * {@inheritdoc Collections.Collector.toReadOnly}
+     */
+    toReadOnly() {
+        return this;
+    }
+    /**
+     * Determines if a value is a {@link Collections.CollectibleFactoryCallback | CollectibleFactoryCallback}.
+     * @param value - The value to check.
+     * @returns `true` if the value is a {@link Collections.CollectibleFactoryCallback | CollectibleFactoryCallback},
+     * `false` otherwise.
+     * @public
+     */
+    _isCollectibleFactoryCallback(value) {
+        return typeof value === 'function';
+    }
+}
+//# sourceMappingURL=convertingCollectorValidator.js.map

package/dist/packlets/collections/index.js

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+import * as Utils from './utils';
+export * from './collectible';
+export * from './convertingCollector';
+export * from './collector';
+export * from './collectorValidator';
+export * from './convertingCollectorValidator';
+export * from './validatingConvertingCollector';
+export * from './common';
+export * from './keyValueConverters';
+export * from './readonlyResultMap';
+export * from './resultMap';
+export * from './resultMapValidator';
+export * from './validatingCollector';
+export * from './validatingResultMap';
+export { Utils };
+//# sourceMappingURL=index.js.map

package/dist/packlets/collections/keyValueConverters.js

@@ -0,0 +1,100 @@
+/*
+ * 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.
+ */
+import { failWithDetail, MessageAggregator, succeed, succeedWithDetail } from '../base';
+import { Converters } from '../conversion';
+/**
+ * Helper class for converting strongly-typed keys, values, or entries
+ * from unknown values.
+ * @public
+ */
+export class KeyValueConverters {
+    /**
+     * Constructs a new key-value validator.
+     * @param key - Required key {@link Validator | validator}, {@link Converter | converter},
+     * or {@link Conversion.ConverterFunc | converter function}.
+     * @param value - Required value {@link Validator | validator}, {@link Converter | converter},
+     * or {@link Conversion.ConverterFunc | converter function}.
+     */
+    constructor({ key, value }) {
+        this.key = typeof key === 'function' ? Converters.generic(key) : key;
+        this.value = typeof value === 'function' ? Converters.generic(value) : value;
+    }
+    /**
+     * Converts a supplied unknown to a valid key value of type `<TK>`.
+     * @param key - The unknown to be converted.
+     * @returns `Success` with the converted key value and 'success' detail if the key is valid,
+     * or `Failure` with an error message and 'invalid-key' detail if the key is invalid.
+     */
+    convertKey(key) {
+        return this.key.convert(key).withFailureDetail('invalid-key');
+    }
+    /**
+     * Converts a supplied unknown to a valid value of type `<TV>`.
+     * @param key - The unknown to be converted.
+     * @returns `Success` with the converted value and 'success' detail if the value is valid,
+     * or `Failure` with an error message and 'invalid-value' detail if the value is invalid.
+     */
+    convertValue(key) {
+        return this.value.convert(key).withFailureDetail('invalid-value');
+    }
+    /**
+     * Converts a supplied unknown to a valid entry of type `[<TK>, <TV>]`.
+     * @param entry - The unknown to be converted.
+     * @returns `Success` with the converted entry and 'success' detail if the entry
+     * is valid, or `Failure` with an error message and 'invalid-key' or 'invalid-value' detail if
+     * the entry is invalid
+     */
+    convertEntry(entry) {
+        if (Array.isArray(entry) && entry.length === 2) {
+            const errors = new MessageAggregator();
+            const key = this.convertKey(entry[0]).aggregateError(errors).orDefault();
+            const value = this.convertValue(entry[1]).aggregateError(errors).orDefault();
+            if (key && value) {
+                return succeedWithDetail([key, value], 'success');
+            }
+            const detail = key ? 'invalid-value' : 'invalid-key';
+            return failWithDetail(`invalid entry: ${errors.toString()}`, detail);
+        }
+        /* c8 ignore next 2 */
+        return failWithDetail(`malformed entry: "${JSON.stringify(entry)}"`, 'invalid-value');
+    }
+    /**
+     * Converts a supplied iterable of unknowns to valid key-value pairs.
+     * @param entries - The iterable of unknowns to be converted.
+     * @returns `Success` with an array of converted key-value pairs if all entries are valid,
+     * or `Failure` with an error message if any entry is invalid.
+     */
+    convertEntries(entries) {
+        const errors = new MessageAggregator();
+        const converted = [];
+        for (const element of entries) {
+            this.convertEntry(element)
+                .onSuccess((e) => {
+                converted.push(e);
+                return succeedWithDetail(e, 'success');
+            })
+                .aggregateError(errors);
+        }
+        return errors.returnOrReport(succeed(converted));
+    }
+}
+//# sourceMappingURL=keyValueConverters.js.map

package/dist/packlets/collections/readonlyResultMap.js

@@ -0,0 +1,23 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=readonlyResultMap.js.map

package/dist/packlets/collections/resultMap.js

@@ -0,0 +1,214 @@
+/*
+ * 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.
+ */
+import { captureResult, failWithDetail, succeed, succeedWithDetail } from '../base';
+import { isIterable } from './utils';
+/**
+ * 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 class ResultMap {
+    /**
+     * Constructs a new {@link Collections.ResultMap | ResultMap}.
+     * @param iterableOrParams - An iterable to initialize the map, or a set of parameters
+     * to configure the map.
+     */
+    constructor(iterableOrParams) {
+        const params = isIterable(iterableOrParams) ? { entries: iterableOrParams } : iterableOrParams !== null && iterableOrParams !== void 0 ? iterableOrParams : {};
+        this._inner = new Map(params.entries);
+    }
+    /**
+     * Creates a new {@link Collections.ResultMap | ResultMap}.
+     * @param elementsOrParams - An optional iterable to initialize the map, or a set of parameters
+     * to configure the map.
+     * @returns `Success` with the new map, or `Failure` with error details
+     * if an error occurred.
+     * @public
+     */
+    static create(elementsOrParams) {
+        return captureResult(() => new ResultMap(elementsOrParams));
+    }
+    /**
+     * 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, value) {
+        if (this._inner.has(key)) {
+            return failWithDetail(`${key}: already exists.`, 'exists');
+        }
+        this._inner.set(key, value);
+        return succeedWithDetail(value, 'added');
+    }
+    /**
+     * Clears the map.
+     */
+    clear() {
+        this._inner.clear();
+    }
+    /**
+     * 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) {
+        const was = this._inner.get(key);
+        if (this._inner.delete(key)) {
+            return succeedWithDetail(was, 'deleted');
+        }
+        return failWithDetail(`${key}: not found.`, 'not-found');
+    }
+    /**
+     * Returns an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    entries() {
+        return this._inner.entries();
+    }
+    /**
+     * 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, arg) {
+        for (const [key, value] of this._inner.entries()) {
+            cb(value, key, this, arg);
+        }
+    }
+    /**
+     * 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) {
+        if (this._inner.has(key)) {
+            return succeedWithDetail(this._inner.get(key), 'exists');
+        }
+        return failWithDetail(`${key}: not found.`, 'not-found');
+    }
+    getOrAdd(key, valueOrFactory) {
+        if (this._inner.has(key)) {
+            return succeedWithDetail(this._inner.get(key), 'exists');
+        }
+        const factory = this._isResultMapValueFactory(valueOrFactory)
+            ? valueOrFactory
+            : () => succeed(valueOrFactory);
+        return factory(key)
+            .onSuccess((val) => {
+            this._inner.set(key, val);
+            return succeedWithDetail(val, 'added');
+        })
+            .withDetail('invalid-value', 'added');
+    }
+    /**
+     * Returns `true` if the map contains a key.
+     * @param key - The key to check.
+     * @returns `true` if the key exists, `false` otherwise.
+     */
+    has(key) {
+        return this._inner.has(key);
+    }
+    /**
+     * Returns an iterator over the map keys.
+     * @returns An iterator over the map keys.
+     */
+    keys() {
+        return this._inner.keys();
+    }
+    /**
+     * Sets a key/value pair in the map.
+     * @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, value) {
+        const detail = this._inner.has(key) ? 'updated' : 'added';
+        this._inner.set(key, value);
+        return succeedWithDetail(value, detail);
+    }
+    /**
+     * Returns the number of entries in the map.
+     */
+    get size() {
+        return this._inner.size;
+    }
+    /**
+     * Updates an existing key in the map - the map is not updated if the key does
+     * not exist.
+     * @param key - The key to update.
+     * @param value - The value to set.
+     * @returns `Success` with the value and detail 'exists' 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, value) {
+        if (this._inner.has(key)) {
+            this._inner.set(key, value);
+            return succeedWithDetail(value, 'updated');
+        }
+        return failWithDetail(`${key}: not found.`, 'not-found');
+    }
+    /**
+     * Returns an iterator over the map values.
+     * @returns An iterator over the map values.
+     */
+    values() {
+        return this._inner.values();
+    }
+    /**
+     * Gets an iterator over the map entries.
+     * @returns An iterator over the map entries.
+     */
+    [Symbol.iterator]() {
+        return this._inner[Symbol.iterator]();
+    }
+    /**
+     * Gets a readonly version of this map.
+     * @returns A readonly version of this map.
+     */
+    toReadOnly() {
+        return this;
+    }
+    /**
+     * Determines if a value is a {@link Collections.ResultMapValueFactory | ResultMapValueFactory}.
+     * @param value - The value to check.
+     * @returns `true` if the value is a {@link Collections.ResultMapValueFactory | ResultMapValueFactory},
+     * `false` otherwise.
+     * @public
+     */
+    _isResultMapValueFactory(value) {
+        return typeof value === 'function';
+    }
+}
+//# sourceMappingURL=resultMap.js.map

package/dist/packlets/collections/resultMapValidator.js

@@ -0,0 +1,122 @@
+/*
+ * 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.
+ */
+import { failWithDetail, succeedWithDetail } from '../base';
+/**
+ * A {@link Collections.ResultMap | ResultMap} wrapper which validates weakly-typed keys
+ * before calling the wrapped result map.
+ * @public
+ */
+export class ResultMapValidator {
+    get map() {
+        return this._map;
+    }
+    /**
+     * Constructs a new {@link Collections.ResultMapValidator | ResultMapValidator}.
+     * @param params - Required parameters for constructing the result map validator.
+     */
+    constructor(params) {
+        this._map = params.map;
+        this.converters = params.converters;
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.add}
+     */
+    add(key, value) {
+        return this.converters.convertEntry([key, value]).onSuccess(([vk, vv]) => {
+            return this._map.add(vk, vv);
+        });
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.delete}
+     */
+    delete(key) {
+        return this.converters.convertKey(key).onSuccess((k) => {
+            return this._map.delete(k);
+        });
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.get}
+     */
+    get(key) {
+        return this.converters.convertKey(key).onSuccess((k) => {
+            return this._map.get(k);
+        });
+    }
+    getOrAdd(key, valueOrFactory) {
+        if (!this._isResultMapValueFactory(valueOrFactory)) {
+            return this.converters.convertEntry([key, valueOrFactory]).onSuccess(([vk, vv]) => {
+                return this._map.getOrAdd(vk, vv);
+            });
+        }
+        else {
+            return this.converters.convertKey(key).onSuccess((k) => {
+                return this._map.get(k).onFailure(() => {
+                    const value = valueOrFactory(k)
+                        .onSuccess((value) => this.converters.convertEntry([k, value]))
+                        .onSuccess(([__key, value]) => succeedWithDetail(value, 'added'));
+                    return value.success
+                        ? this._map.add(k, value.value)
+                        : failWithDetail(value.message, 'invalid-value');
+                });
+            });
+        }
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.has}
+     */
+    has(key) {
+        return this._map.has(key);
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.set}
+     */
+    set(key, value) {
+        return this.converters.convertEntry([key, value]).onSuccess(([vk, vv]) => {
+            return this._map.set(vk, vv);
+        });
+    }
+    /**
+     * {@inheritdoc Collections.ResultMap.update}
+     */
+    update(key, value) {
+        return this.converters.convertEntry([key, value]).onSuccess(([vk, vv]) => {
+            return this._map.update(vk, vv);
+        });
+    }
+    /**
+     * Gets a read-only version of this validator.
+     */
+    toReadOnly() {
+        return this;
+    }
+    /**
+     * Determines if a value is a {@link Collections.ResultMapValueFactory | ResultMapValueFactory}.
+     * @param value - The value to check.
+     * @returns `true` if the value is a {@link Collections.ResultMapValueFactory | ResultMapValueFactory},
+     * `false` otherwise.
+     * @public
+     */
+    _isResultMapValueFactory(value) {
+        return typeof value === 'function';
+    }
+}
+//# sourceMappingURL=resultMapValidator.js.map

package/dist/packlets/collections/utils.js

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+/**
+ * Determines if a supplied value is an iterable object or some other type.
+ * @param value - The value to be tested.
+ * @returns `true` if the value is an iterable object, `false` otherwise.
+ * @public
+ */
+export function isIterable(value) {
+    return (value && typeof value === 'object' && Symbol.iterator in value) === true;
+}
+//# sourceMappingURL=utils.js.map