@fgv/ts-utils 5.0.1-9 → 5.0.1

package/dist/packlets/conversion/defaultingConverter.js

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2020 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 { succeed } from '../base';
+/**
+ * Generic {@link Conversion.DefaultingConverter | DefaultingConverter}, which wraps another converter
+ * to substitute a supplied default value for any errors returned by the inner converter.
+ * @public
+ */
+export class GenericDefaultingConverter {
+    /**
+     * {@inheritdoc Converter.isOptional}
+     */
+    get isOptional() {
+        return this._converter.isOptional;
+    }
+    /**
+     * {@inheritdoc Converter.isOptional}
+     */
+    get brand() {
+        return this._converter.brand;
+    }
+    /**
+     * Constructs a new {@link Conversion.GenericDefaultingConverter | generic defaulting converter}.
+     * @param converter - inner {@link Converter | Converter} used for the base conversion.
+     * @param defaultValue - default value to be supplied if the inner conversion fails.
+     */
+    constructor(converter, defaultValue) {
+        this.defaultValue = defaultValue;
+        this._converter = converter;
+    }
+    /**
+     * {@inheritdoc Converter.convert}
+     */
+    convert(from, ctx) {
+        return this._applyDefault(this._converter.convert(from, ctx));
+    }
+    /**
+     * {@inheritdoc Converter.convertOptional}
+     */
+    convertOptional(from, context, onError) {
+        const converted = this._converter.convertOptional(from, context, onError);
+        if (converted.isFailure()) {
+            return succeed(this.defaultValue);
+        }
+        return converted;
+    }
+    /**
+     * {@inheritdoc Converter.optional}
+     */
+    optional(onError) {
+        // need to let the inner converter do its optional thing first or our default
+        // steps on everything
+        return this._converter.optional(onError).withAction((result) => this._applyDefault(result));
+    }
+    /**
+     * {@inheritdoc Converter.map}
+     */
+    map(mapper) {
+        return this._converter.withAction((result) => this._applyDefault(result)).map(mapper);
+    }
+    /**
+     * {@inheritdoc Converter.mapConvert}
+     */
+    mapConvert(mapConverter) {
+        return this._converter.withAction((result) => this._applyDefault(result)).mapConvert(mapConverter);
+    }
+    /**
+     * {@inheritdoc Converter.mapItems}
+     */
+    mapItems(mapper) {
+        return this._converter.withAction((result) => this._applyDefault(result)).mapItems(mapper);
+    }
+    /**
+     * {@inheritdoc Converter.mapConvertItems}
+     */
+    mapConvertItems(mapConverter) {
+        return this._converter.withAction((result) => this._applyDefault(result)).mapConvertItems(mapConverter);
+    }
+    /**
+     * {@inheritdoc Converter.withAction}
+     */
+    withAction(action) {
+        return this._converter.withAction((result) => this._applyDefault(result)).withAction(action);
+    }
+    /**
+     * {@inheritdoc Converter.withTypeGuard}
+     */
+    withTypeGuard(guard, message) {
+        return this._converter.withAction((result) => this._applyDefault(result)).withTypeGuard(guard);
+    }
+    /**
+     * {@inheritdoc Converter.withItemTypeGuard}
+     */
+    withItemTypeGuard(guard, message) {
+        return this._converter.withAction((result) => this._applyDefault(result)).withItemTypeGuard(guard);
+    }
+    /**
+     * {@inheritdoc Converter.withConstraint}
+     */
+    withConstraint(constraint, options) {
+        return this._converter.withAction((result) => this._applyDefault(result)).withConstraint(constraint);
+    }
+    /**
+     * {@inheritdoc Converter.withBrand}
+     */
+    withBrand(brand) {
+        return this._converter.withAction((result) => this._applyDefault(result)).withBrand(brand);
+    }
+    /**
+     * {@inheritdoc Converter.withFormattedError}
+     */
+    withFormattedError(formatter) {
+        // formatter should never actually be invoked for a defaulting converter
+        return this._converter.withAction((result) => this._applyDefault(result)).withFormattedError(formatter);
+    }
+    /**
+     * Returns a Converter which always succeeds with the supplied default value rather
+     * than failing.
+     *
+     * Note that the supplied default value *overrides* the default value of this
+     * {@link Conversion.DefaultingConverter | DefaultingConverter}.
+     */
+    withDefault(dflt) {
+        return new GenericDefaultingConverter(this._converter, dflt);
+    }
+    _applyDefault(converted) {
+        return converted.success ? converted : succeed(this.defaultValue);
+    }
+}
+//# sourceMappingURL=defaultingConverter.js.map

package/dist/packlets/conversion/index.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 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 Converters from './converters';
+export * from './baseConverter';
+export * from './converter';
+export * from './defaultingConverter';
+export * from './objectConverter';
+export * from './stringConverter';
+export { Converters };
+//# sourceMappingURL=index.js.map

package/dist/packlets/conversion/objectConverter.js

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2023 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 { fail, isKeyOf, succeed } from '../base';
+import { BaseConverter } from './baseConverter';
+import { field, optionalField } from './converters';
+/**
+ * A {@link Converter | Converter} which converts an object of type `<T>` without changing shape, given
+ * a {@link Conversion.FieldConverters | FieldConverters<T>} for the fields in the object.
+ * @remarks
+ * By default, if all of the required fields exist and can be converted, returns a new object with
+ * the converted values under the original key names.  If any required fields do not exist or cannot
+ * be converted, the entire conversion fails. See {@link Conversion.ObjectConverterOptions | ObjectConverterOptions}
+ * for other conversion options.
+ * @public
+ */
+export class ObjectConverter extends BaseConverter {
+    /**
+     * Concrete implementation of {@link Converters.(ObjectConverter:constructor)}
+     * @internal
+     */
+    constructor(fields, opt) {
+        const options = Array.isArray(opt) ? { optionalFields: opt } : opt !== null && opt !== void 0 ? opt : { optionalFields: [] };
+        super((from, __self, context) => ObjectConverter._convert(from, context, fields, options));
+        this.fields = fields;
+        this.options = options;
+    }
+    /**
+     * Converts the supplied object using the {@link Conversion.ObjectConverter | ObjectConverter}
+     * with all fields optional.
+     * @param from - The object to be converted.
+     * @param context - An optional context object passed to the field converters.
+     * @returns A {@link Result} containing the converted object or an error message.
+     */
+    convertPartial(from, context) {
+        const options = Object.assign(Object.assign({}, this.options), { modifier: 'partial' });
+        return ObjectConverter._convert(from, context, this.fields, options);
+    }
+    /**
+     * Converts the supplied object using the {@link Conversion.ObjectConverter | ObjectConverter}
+     * with all fields required.
+     * @param from - The object to be converted.
+     * @param context - An optional context object passed to the field converters.
+     * @returns A {@link Result} containing the converted object or an error message.
+     */
+    convertRequired(from, context) {
+        const options = Object.assign(Object.assign({}, this.options), { modifier: 'required' });
+        return ObjectConverter._convert(from, context, this.fields, options);
+    }
+    /**
+     * Concrete implementation of
+     * {@link Conversion.ObjectConverter.(partial:1) | ObjectConverter.partial(ObjectConverterOptions)} and
+     * {@link Conversion.ObjectConverter.(partial:2) | ObjectConverter.partial((keyof T))[]}.
+     * @internal
+     */
+    partial(opt) {
+        const options = opt === undefined
+            ? Object.assign(Object.assign({}, this.options), { modifier: 'partial' }) : Array.isArray(opt)
+            ? Object.assign(Object.assign({}, this.options), { optionalFields: [...opt] }) : opt;
+        return new ObjectConverter(this.fields, options)._with(this._traits());
+    }
+    /**
+     * Creates a new {@link Conversion.ObjectConverter | ObjectConverter} derived from this one but with
+     * new optional properties as specified by a supplied array of `keyof T`.
+     * @param addOptionalProperties - The keys to be made optional.
+     * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} with the additional optional source
+     * properties.
+     */
+    addPartial(addOptionalProperties) {
+        var _a;
+        /* c8 ignore next 1 - coverage having a bad day */
+        const myOptional = (_a = this.options.optionalFields) !== null && _a !== void 0 ? _a : [];
+        const optional = [...myOptional, ...addOptionalProperties];
+        return this.partial(optional)._with(this._traits());
+    }
+    /**
+     * Creates a new {@link Conversion.ObjectConverter | ObjectConverter} derived from this one but with
+     * all properties required.
+     * @returns A new {@link Conversion.ObjectConverter | ObjectConverter} with the additional required source properties.
+     */
+    required() {
+        const options = Object.assign(Object.assign({}, this.options), { modifier: 'required' });
+        return new ObjectConverter(this.fields, options)._with(this._traits());
+    }
+    static _convert(from, context, fields, options) {
+        // eslint bug thinks key is used before defined
+        var _a;
+        const converted = {};
+        const errors = [];
+        for (const key in fields) {
+            if (fields[key]) {
+                const isOptional = options.modifier === 'partial' ||
+                    (options.modifier !== 'required' &&
+                        (fields[key].isOptional === true || ((_a = options.optionalFields) === null || _a === void 0 ? void 0 : _a.includes(key)) === true));
+                const result = isOptional
+                    ? optionalField(key, fields[key]).convert(from, context)
+                    : field(key, fields[key]).convert(from, context);
+                if (result.isSuccess() && result.value !== undefined) {
+                    converted[key] = result.value;
+                }
+                else if (result.isFailure()) {
+                    errors.push(result.message);
+                }
+            }
+        }
+        if (options.strict === true) {
+            if (typeof from === 'object' && !Array.isArray(from)) {
+                for (const key in from) {
+                    if (from.hasOwnProperty(key) && (!isKeyOf(key, fields) || fields[key] === undefined)) {
+                        errors.push(`${key}: unexpected property in source object`);
+                    }
+                }
+            }
+            else {
+                errors.push('source is not an object');
+            }
+        }
+        return errors.length === 0
+            ? succeed(converted)
+            : fail(options.description ? `${options.description}: ${errors.join('\n')}` : errors.join('\n'));
+    }
+}
+//# sourceMappingURL=objectConverter.js.map

package/dist/packlets/conversion/stringConverter.js

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2023 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 { fail, succeed } from '../base';
+import { BaseConverter } from './baseConverter';
+/**
+ * The {@link Conversion.StringConverter | StringConverter} class extends
+ * {@link Conversion.BaseConverter | BaseConverter} to provide string-specific
+ * helper methods.
+ * @public
+ */
+export class StringConverter extends BaseConverter {
+    /**
+     * Construct a new {@link Conversion.StringConverter | StringConverter}.
+     * @param defaultContext - Optional context used by the conversion.
+     * @param traits - Optional traits to be applied to the conversion.
+     * @param converter - Optional conversion function to be used for the conversion.
+     */
+    constructor(defaultContext, traits, converter = StringConverter._convert) {
+        super(converter, defaultContext, traits);
+    }
+    /**
+     * @internal
+     */
+    static _convert(from) {
+        return typeof from === 'string' ? succeed(from) : fail(`Not a string: ${JSON.stringify(from)}`);
+    }
+    /**
+     * @internal
+     */
+    static _wrap(wrapped, converter, traits) {
+        return new StringConverter(undefined, undefined, (from) => {
+            return wrapped.convert(from).onSuccess(converter);
+        })._with(wrapped._traits(traits));
+    }
+    /**
+     * Concrete implementation of {@link Conversion.StringConverter.matching#string | StringConverter.matching(string)},
+     * {@link Conversion.StringConverter.matching#array | StringConverter.matching(string[])},
+     * {@link Conversion.StringConverter.matching#set | StringConverter.matching(Set<string>)}, and
+     * {@link Conversion.StringConverter.matching#regexp | StringConverter.matching(RegExp)}.
+     * @internal
+     */
+    matching(match, options) {
+        const message = options === null || options === void 0 ? void 0 : options.message;
+        if (typeof match === 'string') {
+            return StringConverter._wrap(this, (from) => {
+                return match === from
+                    ? succeed(from)
+                    : fail(message ? `"${from}": ${message}` : `"${from}": does not match "${match}"`);
+            });
+        }
+        else if (match instanceof RegExp) {
+            return StringConverter._wrap(this, (from) => {
+                return match.test(from)
+                    ? succeed(from)
+                    : fail(message ? `"${from}": ${message}` : `"${from}": does not match "${match}"`);
+            });
+        }
+        else if (match instanceof Set) {
+            return StringConverter._wrap(this, (from) => {
+                return match.has(from)
+                    ? succeed(from)
+                    : fail(message ? `"${from}": ${message}` : `"${from}": not found in set`);
+            });
+        }
+        else {
+            return StringConverter._wrap(this, (from) => {
+                return match.includes(from)
+                    ? succeed(from)
+                    : fail(message ? `"${from}": ${message}` : `"${from}": not found in [${match.join(',')}]`);
+            });
+        }
+    }
+}
+//# sourceMappingURL=stringConverter.js.map

package/dist/packlets/hash/crcNormalizer.js

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2023 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 { HashingNormalizer } from './hashingNormalizer';
+function encodeUtf8(input) {
+    // Prefer built-in TextEncoder when available (browsers and modern Node)
+    // @ts-ignore - global TextEncoder may be unavailable in some environments
+    const GlobalTextEncoder = typeof TextEncoder !== 'undefined' ? TextEncoder : undefined;
+    if (GlobalTextEncoder) {
+        return new GlobalTextEncoder().encode(input);
+    }
+    // Very small manual UTF-8 encoder as a last resort
+    /* eslint-disable no-bitwise */
+    const bytes = [];
+    for (let i = 0; i < input.length; i++) {
+        let codePoint = input.charCodeAt(i);
+        if (codePoint >= 0xd800 && codePoint <= 0xdbff && i + 1 < input.length) {
+            const next = input.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                codePoint = ((codePoint - 0xd800) << 10) + (next - 0xdc00) + 0x10000;
+                i++;
+            }
+        }
+        if (codePoint < 0x80) {
+            bytes.push(codePoint);
+        }
+        else if (codePoint < 0x800) {
+            bytes.push(0xc0 | (codePoint >> 6));
+            bytes.push(0x80 | (codePoint & 0x3f));
+        }
+        else if (codePoint < 0x10000) {
+            bytes.push(0xe0 | (codePoint >> 12));
+            bytes.push(0x80 | ((codePoint >> 6) & 0x3f));
+            bytes.push(0x80 | (codePoint & 0x3f));
+        }
+        else {
+            bytes.push(0xf0 | (codePoint >> 18));
+            bytes.push(0x80 | ((codePoint >> 12) & 0x3f));
+            bytes.push(0x80 | ((codePoint >> 6) & 0x3f));
+            bytes.push(0x80 | (codePoint & 0x3f));
+        }
+    }
+    /* eslint-enable no-bitwise */
+    return new Uint8Array(bytes);
+}
+const POLYNOMIAL = 0xedb88320;
+const crc32Table = [];
+function crc32(bytes, crc = 0xffffffff) {
+    if (crc32Table.length === 0) {
+        buildCrc32Table();
+    }
+    for (let i = 0; i < bytes.length; ++i) {
+        // eslint-disable-next-line no-bitwise
+        crc = crc32Table[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ -1) >>> 0;
+}
+const toUInt32 = (n) => {
+    if (n >= 0) {
+        return n;
+    }
+    return 0xffffffff - n * -1 + 1;
+};
+function buildCrc32Table() {
+    if (crc32Table.length === 0) {
+        for (let n = 0; n < 256; n++) {
+            let r = n;
+            for (let i = 0; i < 8; i++) {
+                // eslint-disable-next-line no-bitwise
+                if (r & 1) {
+                    r = (r >>> 1) ^ POLYNOMIAL;
+                }
+                else {
+                    r = r >>> 1;
+                }
+            }
+            crc32Table.push(toUInt32(r));
+        }
+    }
+}
+/**
+ * A {@link Hash.HashingNormalizer | hashing normalizer} which computes object
+ * hash using the CRC32 algorithm.
+ * @public
+ */
+export class Crc32Normalizer extends HashingNormalizer {
+    constructor() {
+        super(Crc32Normalizer.crc32Hash);
+    }
+    static crc32Hash(parts) {
+        return crc32(encodeUtf8(parts.join('|')))
+            .toString(16)
+            .padStart(8, '0');
+    }
+}
+//# sourceMappingURL=crcNormalizer.js.map

package/dist/packlets/hash/hashingNormalizer.js

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2021 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 { Normalizer, captureResult, fail, mapResults, succeed } from '../base';
+/**
+ * Normalizes an arbitrary JSON object
+ * @public
+ */
+export class HashingNormalizer extends Normalizer {
+    constructor(hash) {
+        super();
+        this._hash = hash;
+    }
+    computeHash(from) {
+        switch (typeof from) {
+            case 'string':
+            case 'bigint':
+            case 'boolean':
+            case 'number':
+            case 'symbol':
+            case 'undefined':
+                return this._normalizeLiteralToString(from).onSuccess((v) => {
+                    return captureResult(() => this._hash([v]));
+                });
+            case 'object':
+                if (from === null || from instanceof Date || from instanceof RegExp) {
+                    return this._normalizeLiteralToString(from).onSuccess((v) => {
+                        return captureResult(() => this._hash([v]));
+                    });
+                }
+                else if (Array.isArray(from)) {
+                    return mapResults(from.map((e) => this.computeHash(e))).onSuccess((a) => {
+                        return captureResult(() => this._hash(['array', ...a]));
+                    });
+                }
+                else if (from instanceof Map || from instanceof Set) {
+                    const type = from instanceof Map ? 'map' : 'set';
+                    return this.computeHash([type, ...this.normalizeEntries(from.entries())]);
+                }
+                return this.computeHash(['object', ...this.normalizeEntries(Object.entries(from))]);
+        }
+        return fail(`computeHash: Unexpected type - cannot hash '${typeof from}'`);
+    }
+    /**
+     * Constructs a normalized string representation of some literal value.
+     * @param from - The literal value to be normalized.
+     * @returns A normalized string representation of the literal.
+     * @internal
+     */
+    _normalizeLiteralToString(from) {
+        switch (typeof from) {
+            case 'string':
+                return succeed(from);
+            case 'bigint':
+            case 'boolean':
+            case 'number':
+            case 'symbol':
+            case 'undefined':
+                return succeed(`${typeof from}:[[[${String(from)}]]]`);
+        }
+        if (from === null) {
+            return succeed('object:[[[null]]');
+        }
+        if (from instanceof Date) {
+            return succeed(`Date:[[[${String(from.valueOf())}]]]`);
+        }
+        if (from instanceof RegExp) {
+            return succeed(`RegExp:[[[${from.toString()}]]]`);
+        }
+        /* c8 ignore next 2 */
+        return fail(`cannot normalize ${JSON.stringify(from)}`);
+    }
+}
+//# sourceMappingURL=hashingNormalizer.js.map

package/dist/packlets/hash/index.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2020 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 * from './crcNormalizer';
+export * from './hashingNormalizer';
+//# sourceMappingURL=index.js.map

package/dist/packlets/logging/index.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2020 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 * from './logger';
+export * from './logReporter';
+//# sourceMappingURL=index.js.map