@fgv/ts-utils 5.0.1-9 → 5.0.1

package/dist/test/helpers/jest/matchers/toSucceedAndMatchInlineSnapshot/index.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchInlineSnapshot } from 'jest-snapshot';
+import { printReceivedResult } from '../../utils/matcherHelpers';
+const matcherName = 'toSucceedAndMatchInlineSnapshot';
+export default {
+    toSucceedAndMatchInlineSnapshot: function (received, snapshot) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        printReceivedResult(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchInlineSnapshot.call(context, received.value, {}, snapshot);
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedAndMatchSnapshot/index.js

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { matcherHint } from 'jest-matcher-utils';
+import { toMatchSnapshot } from 'jest-snapshot';
+import { printReceivedResult } from '../../utils/matcherHelpers';
+const matcherName = 'toSucceedAndMatchSnapshot';
+export default {
+    toSucceedAndMatchSnapshot: function (received) {
+        const context = this;
+        if (received.isFailure()) {
+            return {
+                pass: false,
+                message: () => {
+                    return [
+                        matcherHint(`${matcherName}`, 'callback'),
+                        'Expected:\n  Callback to succeed with a result that matches the snapshot',
+                        printReceivedResult(received)
+                    ].join('\n');
+                }
+            };
+        }
+        return toMatchSnapshot.call(context, received.value, 'toSucceedAndMatchSnapshot');
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedAndSatisfy/index.js

@@ -0,0 +1,53 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received) {
+    const expected = 'successful callback';
+    const got = [printReceivedResult(received)];
+    got.push('  Callback returned true');
+    return () => [
+        matcherHint(`.not.${matcherName}`, 'result', 'callback'),
+        printExpectedResult('success', false, expected),
+        ...got
+    ].join('\n');
+}
+function failMessage(received, cbResult) {
+    const expected = 'successful callback';
+    const got = [printReceivedResult(received)];
+    /* c8 ignore else */
+    if (cbResult.isFailure()) {
+        got.push(cbResult.message);
+    }
+    else if (cbResult.value === false) {
+        got.push('  Callback returned false');
+    }
+    else if (cbResult.value === undefined) {
+        /* c8 ignore else */
+        got.push('  Callback was not invoked');
+    }
+    else {
+        /* c8 ignore next */
+        throw new Error('Internal error: toSucceedAndSatisfy.failMessage passed success with true');
+    }
+    return () => [
+        matcherHint(`${matcherName}`, 'result', 'callback'),
+        printExpectedResult('success', true, expected),
+        ...got
+    ].join('\n');
+}
+export default {
+    toSucceedAndSatisfy: function (received, test) {
+        // For the normal (not '.not') case, we do not want to capture exceptions
+        // so that the IDE can display exactly the line on which the failure case.
+        // For the .not case, we want to swallow exceptions or expect failures since
+        // we're just testing failure and not the reason.
+        const capture = this.isNot;
+        const cbResult = predicate(received, test, !!capture);
+        const pass = cbResult.isSuccess() && cbResult.value === true;
+        if (pass) {
+            return { pass: true, message: passMessage(received) };
+        }
+        return { pass: false, message: failMessage(received, cbResult) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedAndSatisfy/predicate.js

@@ -0,0 +1,17 @@
+import { captureResult, fail, succeed } from '../../ts-utils';
+export const matcherName = 'toSucceedAndSatisfy';
+// If the result is successful and callback does not throw, returns Success with the callback return value, or
+//    true if the callback returns undefined
+// If the result is successful but the callback throws, returns Failure with the thrown error
+// If the result is failure, returns Success with undefined
+export function predicate(received, cb, capture) {
+    if (received.isSuccess()) {
+        const cbResult = capture ? captureResult(() => cb(received.value)) : succeed(cb(received.value));
+        if (cbResult.isSuccess()) {
+            return succeed(cbResult.value === true || cbResult.value === undefined);
+        }
+        return fail(`  Callback failed with:\n    ${cbResult.message}`);
+    }
+    return succeed(undefined);
+}
+//# sourceMappingURL=predicate.js.map

package/dist/test/helpers/jest/matchers/toSucceedWith/index.js

@@ -0,0 +1,27 @@
+import { printExpectedResult, printReceivedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedResult('success', false, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedResult('success', true, expected),
+        printReceivedResult(received)
+    ].join('\n');
+}
+export default {
+    toSucceedWith: function (received, expected) {
+        const pass = predicate(received, expected);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedWith/predicate.js

@@ -0,0 +1,12 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toSucceedWith';
+export function predicate(received, expected) {
+    if (received.isSuccess()) {
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            return expected.test(received.value);
+        }
+        return equals(received.value, expected);
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/test/helpers/jest/matchers/toSucceedWithDetail/index.js

@@ -0,0 +1,27 @@
+import { printExpectedDetailedResult, printReceivedDetailedResult } from '../../utils/matcherHelpers';
+import { matcherName, predicate } from './predicate';
+import { matcherHint } from 'jest-matcher-utils';
+function passMessage(received, expected, expectedDetail) {
+    return () => [
+        matcherHint(`.not.${matcherName}`),
+        printExpectedDetailedResult('success', false, expected, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+function failMessage(received, expected, expectedDetail) {
+    return () => [
+        matcherHint(`${matcherName}`),
+        printExpectedDetailedResult('success', true, expected, expectedDetail),
+        printReceivedDetailedResult(received)
+    ].join('\n');
+}
+export default {
+    toSucceedWithDetail: function (received, expected, detail) {
+        const pass = predicate(received, expected, detail);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected, detail) };
+        }
+        return { pass: false, message: failMessage(received, expected, detail) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/matchers/toSucceedWithDetail/predicate.js

@@ -0,0 +1,17 @@
+import { equals } from '@jest/expect-utils';
+export const matcherName = 'toSucceedWithDetail';
+export function predicate(received, expected, detail) {
+    if (received.isSuccess()) {
+        let pass = false;
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            pass = expected.test(received.value);
+        }
+        else {
+            pass = equals(received.value, expected);
+        }
+        pass = pass && equals(received.detail, detail);
+        return pass;
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/dist/test/helpers/jest/resolvers/cli.js

@@ -0,0 +1,10 @@
+import * as Resolver from '../utils/snapshotResolver';
+export const CLI_SNAPSHOT_FOLDER = '__cli__';
+export function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, CLI_SNAPSHOT_FOLDER);
+}
+export function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+export const testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=cli.js.map

package/dist/test/helpers/jest/resolvers/ide.js

@@ -0,0 +1,10 @@
+import * as Resolver from '../utils/snapshotResolver';
+export const CLI_SNAPSHOT_FOLDER = '__ide__';
+export function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, CLI_SNAPSHOT_FOLDER);
+}
+export function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+export const testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=ide.js.map

package/dist/test/helpers/jest/ts-utils.js

@@ -0,0 +1,2 @@
+export * from '../../../index';
+//# sourceMappingURL=ts-utils.js.map

package/dist/test/helpers/jest/types/index.js

@@ -0,0 +1,3 @@
+/// <reference types="jest"/>
+export {};
+//# sourceMappingURL=index.js.map

package/dist/test/helpers/jest/utils/matcherHelpers.js

@@ -0,0 +1,47 @@
+import { printExpected, printReceived } from 'jest-matcher-utils';
+function printExpectedValue(outcome, expected) {
+    return expected !== undefined ? `  ${outcome} with ${printExpected(expected)}` : `  ${outcome}`;
+}
+export function printExpectedResult(expect, isNot, expected) {
+    return [
+        'Expected:',
+        isNot
+            ? expect === 'success'
+                ? printExpectedValue('Success', expected)
+                : printExpectedValue('Failure', expected)
+            : expect === 'success'
+                ? printExpectedValue('Not success', expected)
+                : printExpectedValue('Not failure', expected)
+    ].join('\n');
+}
+export function printExpectedDetailedResult(expect, isNot, expectedMessage, expectedDetail) {
+    /* c8 ignore next */
+    return [
+        'Expected:',
+        isNot
+            ? expect === 'success'
+                ? printExpectedValue('Success', expectedMessage)
+                : printExpectedValue('Failure', expectedMessage)
+            : expect === 'success'
+                ? printExpectedValue('Not success', expectedMessage)
+                : printExpectedValue('Not failure', expectedMessage),
+        `  Detail: "${printExpected(expectedDetail)}"`
+    ].join('\n');
+}
+export function printReceivedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with ${printReceived(received.value)}`
+            : `  Failure with "${received.message}"`
+    ].join('\n');
+}
+export function printReceivedDetailedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with "${printReceived(received.value)}"\n  Detail: "${printReceived(received.detail)}"`
+            : `  Failure with "${received.message}"\n  Detail: "${printReceived(received.detail)}"`
+    ].join('\n');
+}
+//# sourceMappingURL=matcherHelpers.js.map

package/dist/test/helpers/jest/utils/snapshotResolver.js

@@ -0,0 +1,11 @@
+import path from 'path';
+export function resolveSnapshotPath(testPath, snapshotExtension, snapshotFolderName) {
+    const snapshotPath = path.join(path.join(path.dirname(testPath), '__snapshots__', snapshotFolderName), path.basename(testPath) + snapshotExtension);
+    return snapshotPath;
+}
+export function resolveTestPath(snapshotFilePath, snapshotExtension) {
+    const testPath = path.join(path.dirname(path.dirname(path.dirname(snapshotFilePath))), path.basename(snapshotFilePath, snapshotExtension));
+    return testPath;
+}
+export const testPathForConsistencyCheck = path.posix.join('consistency_check', '__tests__', 'subdir', 'example.test.js');
+//# sourceMappingURL=snapshotResolver.js.map

package/dist/test/unit/collections/helpers.js

@@ -0,0 +1,106 @@
+/*
+ * 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, succeed } from '../../../packlets/base';
+import { Collectible, ConvertingCollector } from '../../../packlets/collections';
+import { Converters } from '../../../packlets/conversion';
+export const testThingKey = Converters.string
+    .withConstraint((s) => /^thing\d{1,4}$/.test(s))
+    .withFormattedError((val) => `${val} is invalid TestThingKey`)
+    .withBrand('TestThingKey');
+export const testThingIndex = Converters.number
+    .withConstraint((n) => n >= 0)
+    .withBrand('TestThingIndex');
+export const testThing = Converters.strictObject({
+    str: Converters.string.optional(),
+    num: Converters.number.optional(),
+    bool: Converters.boolean.optional()
+});
+export class BrandedCollectibleTestThing extends Collectible {
+    constructor(thing, key, index) {
+        super({ key, index, indexConverter: testThingIndex });
+        this.str = thing.str;
+        this.num = thing.num;
+        this.bool = thing.bool;
+    }
+    static create(thing, key, index) {
+        return testThingKey.convert(key).onSuccess((convertedKey) => {
+            return testThingIndex.convert(index).onSuccess((convertedIndex) => {
+                return captureResult(() => new BrandedCollectibleTestThing(thing, convertedKey, convertedIndex));
+            });
+        });
+    }
+}
+export class CollectibleTestThing extends Collectible {
+    constructor(thing, key, index) {
+        super({ key, index, indexConverter: Converters.number });
+        this.str = thing.str;
+        this.num = thing.num;
+        this.bool = thing.bool;
+    }
+    static create(thing, key, index) {
+        return captureResult(() => new CollectibleTestThing(thing, key, index));
+    }
+}
+export class BrokenCollectibleTestThing extends CollectibleTestThing {
+    constructor(thing, key, index) {
+        super(thing, key, index ? (index + 1) : undefined);
+    }
+    setIndex(index) {
+        this._index = index + 1;
+        return succeed(this.index);
+    }
+}
+export class TestCollector extends ConvertingCollector {
+    constructor(things) {
+        const entries = things
+            ? { entries: things.map((thing, index) => [`thing${index}`, thing]) }
+            : {};
+        const params = Object.assign({ factory: TestCollector._factory }, entries);
+        super(params);
+    }
+    static _factory(key, index, item) {
+        return succeed(new CollectibleTestThing(item, key, index));
+    }
+}
+export function getTestThings() {
+    const things = [
+        { str: 'thing0', num: 0, bool: false },
+        { str: 'thing1', num: 1, bool: true },
+        { str: 'thing2', num: 2, bool: false },
+        { str: 'thing3', num: 3, bool: true },
+        { str: 'thing4', num: 4, bool: false }
+    ];
+    const collectibles = things.map((thing, index) => new CollectibleTestThing(thing, `thing${index}`, index));
+    return { things, collectibles };
+}
+export function getBrandedTestThings() {
+    const things = [
+        { str: 'thing0', num: 0, bool: false },
+        { str: 'thing1', num: 1, bool: true },
+        { str: 'thing2', num: 2, bool: false },
+        { str: 'thing3', num: 3, bool: true },
+        { str: 'thing4', num: 4, bool: false }
+    ];
+    const collectibles = things.map((thing, index) => BrandedCollectibleTestThing.create(thing, `thing${index}`, index).orThrow());
+    return { things, collectibles };
+}
+//# sourceMappingURL=helpers.js.map

package/dist/test/unit/hashTextEncodeCompat.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ */
+import '../helpers/jest';
+import { Crc32Normalizer } from '../../packlets/hash';
+describe('Crc32Normalizer TextEncoder/Buffer compatibility', () => {
+    test('falls back to a non-TextEncoder path when TextEncoder is unavailable', () => {
+        const expected = Crc32Normalizer.crc32Hash(['hello']);
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        const g = globalThis;
+        const originalTextEncoder = g.TextEncoder;
+        try {
+            delete g.TextEncoder;
+            const actual = Crc32Normalizer.crc32Hash(['hello']);
+            expect(actual).toEqual(expected);
+        }
+        finally {
+            // Restore environment
+            g.TextEncoder = originalTextEncoder;
+        }
+    });
+});
+//# sourceMappingURL=hashTextEncodeCompat.js.map

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.53.3"
+      "packageVersion": "7.54.0"
     }
   ]
 }

package/lib/packlets/hash/crcNormalizer.js

@@ -23,7 +23,47 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Crc32Normalizer = void 0;
 const hashingNormalizer_1 = require("./hashingNormalizer");
-const textEncoder = new TextEncoder();
+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) {
@@ -69,7 +109,7 @@ class Crc32Normalizer extends hashingNormalizer_1.HashingNormalizer {
         super(Crc32Normalizer.crc32Hash);
     }
     static crc32Hash(parts) {
-        return crc32(textEncoder.encode(parts.join('|')))
+        return crc32(encodeUtf8(parts.join('|')))
             .toString(16)
             .padStart(8, '0');
     }

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@fgv/ts-utils",
-  "version": "5.0.1-9",
+  "version": "5.0.1",
   "description": "Assorted Typescript Utilities",
   "main": "lib/index.js",
+  "module": "dist/index.js",
   "types": "dist/ts-utils.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/ts-utils.d.ts",
+      "import": "./dist/index.js",
+      "require": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
   "sideEffects": false,
   "keywords": [
     "typescript",
@@ -43,7 +52,8 @@
     "@rushstack/eslint-config": "4.5.3",
     "@types/heft-jest": "1.0.6",
     "@rushstack/heft-jest-plugin": "1.1.3",
-    "eslint-plugin-tsdoc": "~0.4.0"
+    "eslint-plugin-tsdoc": "~0.4.0",
+    "@fgv/heft-dual-rig": "0.1.0"
   },
   "scripts": {
     "build": "heft build --clean",