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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcherHelpers_1 = require("../../utils/matcherHelpers");
+const predicate_1 = require("./predicate");
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+function passMessage(received, expected) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`.not.${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedResult)('success', false, expected),
+        (0, matcherHelpers_1.printReceivedResult)(received)
+    ].join('\n');
+}
+function failMessage(received, expected) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedResult)('success', true, expected),
+        (0, matcherHelpers_1.printReceivedResult)(received)
+    ].join('\n');
+}
+exports.default = {
+    toSucceedWith: function (received, expected) {
+        const pass = (0, predicate_1.predicate)(received, expected);
+        if (pass) {
+            return { pass: true, message: passMessage(received, expected) };
+        }
+        return { pass: false, message: failMessage(received, expected) };
+    }
+};
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/matchers/toSucceedWith/predicate.d.ts

@@ -0,0 +1,4 @@
+import { Result } from '../../../../../index';
+export declare const matcherName: string;
+export declare function predicate<T>(received: Result<T>, expected: unknown): boolean;
+//# sourceMappingURL=predicate.d.ts.map

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matcherName = void 0;
+exports.predicate = predicate;
+const expect_utils_1 = require("@jest/expect-utils");
+exports.matcherName = 'toSucceedWith';
+function predicate(received, expected) {
+    if (received.isSuccess()) {
+        if (typeof received.value === 'string' && expected instanceof RegExp) {
+            return expected.test(received.value);
+        }
+        return (0, expect_utils_1.equals)(received.value, expected);
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/lib/test/helpers/jest/matchers/toSucceedWithDetail/index.d.ts

@@ -0,0 +1,18 @@
+import { DetailedResult, ResultDetailType, ResultValueType } from '../../ts-utils';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toSucceedWithDetail to verify that a DetailedResult\<T, TD\> is
+             * a success and that the result value and detail matches the supplied
+             * values
+             */
+            toSucceedWithDetail(expected: ResultValueType<T> | RegExp, detail: ResultDetailType<T> | undefined): R;
+        }
+    }
+}
+declare const _default: {
+    toSucceedWithDetail: <T extends DetailedResult<unknown, unknown>>(received: T, expected: ResultValueType<T> | RegExp, detail: ResultDetailType<T> | undefined) => jest.CustomMatcherResult;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcherHelpers_1 = require("../../utils/matcherHelpers");
+const predicate_1 = require("./predicate");
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+function passMessage(received, expected, expectedDetail) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`.not.${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedDetailedResult)('success', false, expected, expectedDetail),
+        (0, matcherHelpers_1.printReceivedDetailedResult)(received)
+    ].join('\n');
+}
+function failMessage(received, expected, expectedDetail) {
+    return () => [
+        (0, jest_matcher_utils_1.matcherHint)(`${predicate_1.matcherName}`),
+        (0, matcherHelpers_1.printExpectedDetailedResult)('success', true, expected, expectedDetail),
+        (0, matcherHelpers_1.printReceivedDetailedResult)(received)
+    ].join('\n');
+}
+exports.default = {
+    toSucceedWithDetail: function (received, expected, detail) {
+        const pass = (0, predicate_1.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/lib/test/helpers/jest/matchers/toSucceedWithDetail/predicate.d.ts

@@ -0,0 +1,4 @@
+import { DetailedResult } from '../../ts-utils';
+export declare const matcherName: string;
+export declare function predicate<T, TD>(received: DetailedResult<T, TD>, expected: unknown, detail: TD | undefined): boolean;
+//# sourceMappingURL=predicate.d.ts.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matcherName = void 0;
+exports.predicate = predicate;
+const expect_utils_1 = require("@jest/expect-utils");
+exports.matcherName = 'toSucceedWithDetail';
+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 = (0, expect_utils_1.equals)(received.value, expected);
+        }
+        pass = pass && (0, expect_utils_1.equals)(received.detail, detail);
+        return pass;
+    }
+    return false;
+}
+//# sourceMappingURL=predicate.js.map

package/lib/test/helpers/jest/resolvers/cli.d.ts

@@ -0,0 +1,5 @@
+export declare const CLI_SNAPSHOT_FOLDER: string;
+export declare function resolveSnapshotPath(testPath: string, ext: string): string;
+export declare function resolveTestPath(snapshotPath: string, ext: string): string;
+export declare const testPathForConsistencyCheck: string;
+//# sourceMappingURL=cli.d.ts.map

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

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPathForConsistencyCheck = exports.CLI_SNAPSHOT_FOLDER = void 0;
+exports.resolveSnapshotPath = resolveSnapshotPath;
+exports.resolveTestPath = resolveTestPath;
+const Resolver = __importStar(require("../utils/snapshotResolver"));
+exports.CLI_SNAPSHOT_FOLDER = '__cli__';
+function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, exports.CLI_SNAPSHOT_FOLDER);
+}
+function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+exports.testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=cli.js.map

package/lib/test/helpers/jest/resolvers/ide.d.ts

@@ -0,0 +1,5 @@
+export declare const CLI_SNAPSHOT_FOLDER: string;
+export declare function resolveSnapshotPath(testPath: string, ext: string): string;
+export declare function resolveTestPath(snapshotPath: string, ext: string): string;
+export declare const testPathForConsistencyCheck: string;
+//# sourceMappingURL=ide.d.ts.map

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

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPathForConsistencyCheck = exports.CLI_SNAPSHOT_FOLDER = void 0;
+exports.resolveSnapshotPath = resolveSnapshotPath;
+exports.resolveTestPath = resolveTestPath;
+const Resolver = __importStar(require("../utils/snapshotResolver"));
+exports.CLI_SNAPSHOT_FOLDER = '__ide__';
+function resolveSnapshotPath(testPath, ext) {
+    return Resolver.resolveSnapshotPath(testPath, ext, exports.CLI_SNAPSHOT_FOLDER);
+}
+function resolveTestPath(snapshotPath, ext) {
+    return Resolver.resolveTestPath(snapshotPath, ext);
+}
+exports.testPathForConsistencyCheck = Resolver.testPathForConsistencyCheck;
+//# sourceMappingURL=ide.js.map

package/lib/test/helpers/jest/ts-utils.d.ts

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../../index"), exports);
+//# sourceMappingURL=ts-utils.js.map

package/lib/test/helpers/jest/types/index.d.ts

@@ -0,0 +1,79 @@
+import { ResultDetailType, ResultValueType } from '../ts-utils';
+declare global {
+    namespace jest {
+        interface Matchers<R, T> {
+            /**
+             * Use .toSucceed to verify that a Result\<T\> is a success
+             */
+            toSucceed(): R;
+            /**
+             * Use .toSucceedWith to verify that a Result\<T\> is a success
+             * and that the result value matches the supplied value
+             * @param expected -
+             */
+            toSucceedWith(expected: ResultValueType<T> | RegExp): R;
+            /**
+             * Use .toSucceedWithDetail to verify that a DetailedResult\<T, TD\> is
+             * a success and that the result value and detail matches the supplied
+             * values
+             * @param expected -
+             * @param detail -
+             */
+            toSucceedWithDetail(expected: ResultValueType<T>, detail: ResultDetailType<T> | undefined): R;
+            /**
+             * Use .toSucceedAndSatisfy to verify that a Result\<T\> is a success
+             * and that the supplied test function returns true (or void)
+             * for the resulting value
+             * @param test -
+             */
+            toSucceedAndSatisfy(test: (value: ResultValueType<T>) => boolean | void): R;
+            /**
+             * Use .toSucceedAndMatchInlineSnapshot to verify that a Result\<T\> is a success
+             * and that the result value matches an inline snapshot
+             */
+            toSucceedAndMatchInlineSnapshot(snapshot: string | undefined): R;
+            /**
+             * Use .toSucceedAndMatchSnapshot to verify that a Result\<T\> is a success
+             * and that the result value matches a stored snapshot
+             */
+            toSucceedAndMatchSnapshot(): R;
+            /**
+             * Use .toFail to verify that a Result\<T\> is a failure
+             */
+            toFail(): R;
+            /**
+             * Use .toFailWith to verify that a Result\<T\> is a failure
+             * that matches a supplied string, RegExp or undefined value
+             * @param message -
+             */
+            toFailWith(expected: string | RegExp | undefined): R;
+            /**
+             * Use .toFailWithDetail to verify that a DetailedResult\<T\> is
+             * a failure that matches both a supplied expected failure value
+             * (string, RegExp or undefined) and a supplied failure detail.
+             * @param message -
+             * @param detail -
+             */
+            toFailWithDetail(message: string | RegExp | undefined, detail: ResultDetailType<T>): R;
+            /**
+             * Use .toFailTest to test a custom matcher by
+             * verifying that a test case fails.
+             */
+            toFailTest(): R;
+            /**
+             * Use .toFailTestWith to test a custom matcher by
+             * verifying that a test case fails as expected and
+             * reports an error matching a stored snapshot.
+             */
+            toFailTestAndMatchSnapshot(): R;
+            /**
+             * Use .toFailTestWith to test a custom matcher by
+             * verifying that a test case fails as expected and
+             * reports an error matching a supplied value.
+             * @param expected -
+             */
+            toFailTestWith(expected: string | string[] | RegExp): R;
+        }
+    }
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+"use strict";
+/// <reference types="jest"/>
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/lib/test/helpers/jest/utils/matcherHelpers.d.ts

@@ -0,0 +1,6 @@
+import { DetailedResult, Result } from '../ts-utils';
+export declare function printExpectedResult<T>(expect: 'success' | 'failure', isNot: boolean, expected?: T): string;
+export declare function printExpectedDetailedResult<T, TD>(expect: 'success' | 'failure', isNot: boolean, expectedMessage?: T, expectedDetail?: TD): string;
+export declare function printReceivedResult<T>(received: Result<T>): string;
+export declare function printReceivedDetailedResult<T, TD>(received: DetailedResult<T, TD>): string;
+//# sourceMappingURL=matcherHelpers.d.ts.map

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printExpectedResult = printExpectedResult;
+exports.printExpectedDetailedResult = printExpectedDetailedResult;
+exports.printReceivedResult = printReceivedResult;
+exports.printReceivedDetailedResult = printReceivedDetailedResult;
+const jest_matcher_utils_1 = require("jest-matcher-utils");
+function printExpectedValue(outcome, expected) {
+    return expected !== undefined ? `  ${outcome} with ${(0, jest_matcher_utils_1.printExpected)(expected)}` : `  ${outcome}`;
+}
+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');
+}
+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: "${(0, jest_matcher_utils_1.printExpected)(expectedDetail)}"`
+    ].join('\n');
+}
+function printReceivedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with ${(0, jest_matcher_utils_1.printReceived)(received.value)}`
+            : `  Failure with "${received.message}"`
+    ].join('\n');
+}
+function printReceivedDetailedResult(received) {
+    return [
+        'Received:',
+        received.isSuccess()
+            ? `  Success with "${(0, jest_matcher_utils_1.printReceived)(received.value)}"\n  Detail: "${(0, jest_matcher_utils_1.printReceived)(received.detail)}"`
+            : `  Failure with "${received.message}"\n  Detail: "${(0, jest_matcher_utils_1.printReceived)(received.detail)}"`
+    ].join('\n');
+}
+//# sourceMappingURL=matcherHelpers.js.map

package/lib/test/helpers/jest/utils/snapshotResolver.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveSnapshotPath(testPath: string, snapshotExtension: string, snapshotFolderName: string): string;
+export declare function resolveTestPath(snapshotFilePath: string, snapshotExtension: string): string;
+export declare const testPathForConsistencyCheck: string;
+//# sourceMappingURL=snapshotResolver.d.ts.map

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

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testPathForConsistencyCheck = void 0;
+exports.resolveSnapshotPath = resolveSnapshotPath;
+exports.resolveTestPath = resolveTestPath;
+const path_1 = __importDefault(require("path"));
+function resolveSnapshotPath(testPath, snapshotExtension, snapshotFolderName) {
+    const snapshotPath = path_1.default.join(path_1.default.join(path_1.default.dirname(testPath), '__snapshots__', snapshotFolderName), path_1.default.basename(testPath) + snapshotExtension);
+    return snapshotPath;
+}
+function resolveTestPath(snapshotFilePath, snapshotExtension) {
+    const testPath = path_1.default.join(path_1.default.dirname(path_1.default.dirname(path_1.default.dirname(snapshotFilePath))), path_1.default.basename(snapshotFilePath, snapshotExtension));
+    return testPath;
+}
+exports.testPathForConsistencyCheck = path_1.default.posix.join('consistency_check', '__tests__', 'subdir', 'example.test.js');
+//# sourceMappingURL=snapshotResolver.js.map

package/lib/test/unit/collections/collectible.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=collectible.test.d.ts.map

package/lib/test/unit/collections/collector.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=collector.test.d.ts.map

package/lib/test/unit/collections/collectors.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=collectors.test.d.ts.map

package/lib/test/unit/collections/convertingCollector.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=convertingCollector.test.d.ts.map

package/lib/test/unit/collections/helpers.d.ts

@@ -0,0 +1,44 @@
+import { Brand, Result } from '../../../packlets/base';
+import { Collectible, ConvertingCollector } from '../../../packlets/collections';
+import { Converter } from '../../../packlets/conversion';
+export type TestThingKey = Brand<string, 'TestThingKey'>;
+export type TestThingIndex = Brand<number, 'TestThingIndex'>;
+export declare const testThingKey: Converter<TestThingKey, unknown>;
+export declare const testThingIndex: Converter<TestThingIndex, unknown>;
+export interface ITestThing {
+    str?: string;
+    num?: number;
+    bool?: boolean;
+}
+export declare const testThing: Converter<ITestThing, unknown>;
+export declare class BrandedCollectibleTestThing extends Collectible<TestThingKey, TestThingIndex> implements ITestThing {
+    str?: string;
+    num?: number;
+    bool?: boolean;
+    constructor(thing: ITestThing, key: TestThingKey, index?: TestThingIndex);
+    static create(thing: ITestThing, key: string, index?: number): Result<BrandedCollectibleTestThing>;
+}
+export declare class CollectibleTestThing extends Collectible<string, number> implements ITestThing {
+    str?: string;
+    num?: number;
+    bool?: boolean;
+    constructor(thing: ITestThing, key: string, index?: number);
+    static create(thing: ITestThing, key: string, index?: number): Result<CollectibleTestThing>;
+}
+export declare class BrokenCollectibleTestThing extends CollectibleTestThing {
+    constructor(thing: ITestThing, key: string, index?: number);
+    setIndex(index: number): Result<number>;
+}
+export declare class TestCollector extends ConvertingCollector<CollectibleTestThing, ITestThing> {
+    constructor(things?: ITestThing[]);
+    protected static _factory(key: string, index: number, item: ITestThing): Result<CollectibleTestThing>;
+}
+export declare function getTestThings(): {
+    things: ITestThing[];
+    collectibles: CollectibleTestThing[];
+};
+export declare function getBrandedTestThings(): {
+    things: ITestThing[];
+    collectibles: BrandedCollectibleTestThing[];
+};
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1,115 @@
+"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.TestCollector = exports.BrokenCollectibleTestThing = exports.CollectibleTestThing = exports.BrandedCollectibleTestThing = exports.testThing = exports.testThingIndex = exports.testThingKey = void 0;
+exports.getTestThings = getTestThings;
+exports.getBrandedTestThings = getBrandedTestThings;
+const base_1 = require("../../../packlets/base");
+const collections_1 = require("../../../packlets/collections");
+const conversion_1 = require("../../../packlets/conversion");
+exports.testThingKey = conversion_1.Converters.string
+    .withConstraint((s) => /^thing\d{1,4}$/.test(s))
+    .withFormattedError((val) => `${val} is not a valid TestThingKey`)
+    .withBrand('TestThingKey');
+exports.testThingIndex = conversion_1.Converters.number
+    .withConstraint((n) => n >= 0)
+    .withBrand('TestThingIndex');
+exports.testThing = conversion_1.Converters.strictObject({
+    str: conversion_1.Converters.string.optional(),
+    num: conversion_1.Converters.number.optional(),
+    bool: conversion_1.Converters.boolean.optional()
+});
+class BrandedCollectibleTestThing extends collections_1.Collectible {
+    constructor(thing, key, index) {
+        super({ key, index, indexConverter: exports.testThingIndex });
+        this.str = thing.str;
+        this.num = thing.num;
+        this.bool = thing.bool;
+    }
+    static create(thing, key, index) {
+        return exports.testThingKey.convert(key).onSuccess((convertedKey) => {
+            return exports.testThingIndex.convert(index).onSuccess((convertedIndex) => {
+                return (0, base_1.captureResult)(() => new BrandedCollectibleTestThing(thing, convertedKey, convertedIndex));
+            });
+        });
+    }
+}
+exports.BrandedCollectibleTestThing = BrandedCollectibleTestThing;
+class CollectibleTestThing extends collections_1.Collectible {
+    constructor(thing, key, index) {
+        super({ key, index, indexConverter: conversion_1.Converters.number });
+        this.str = thing.str;
+        this.num = thing.num;
+        this.bool = thing.bool;
+    }
+    static create(thing, key, index) {
+        return (0, base_1.captureResult)(() => new CollectibleTestThing(thing, key, index));
+    }
+}
+exports.CollectibleTestThing = CollectibleTestThing;
+class BrokenCollectibleTestThing extends CollectibleTestThing {
+    constructor(thing, key, index) {
+        super(thing, key, index ? (index + 1) : undefined);
+    }
+    setIndex(index) {
+        this._index = index + 1;
+        return (0, base_1.succeed)(this.index);
+    }
+}
+exports.BrokenCollectibleTestThing = BrokenCollectibleTestThing;
+class TestCollector extends collections_1.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 (0, base_1.succeed)(new CollectibleTestThing(item, key, index));
+    }
+}
+exports.TestCollector = TestCollector;
+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 };
+}
+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/lib/test/unit/collections/resultMap.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=resultMap.test.d.ts.map

package/lib/test/unit/collections/validatingCollector.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=validatingCollector.test.d.ts.map

package/lib/test/unit/collections/validatingConvertingCollector.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=validatingConvertingCollector.test.d.ts.map

package/lib/test/unit/collections/validatingResultMap.test.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/jest';
+//# sourceMappingURL=validatingResultMap.test.d.ts.map

package/lib/test/unit/converter.test.d.ts

@@ -0,0 +1,2 @@
+import '../helpers/jest';
+//# sourceMappingURL=converter.test.d.ts.map

package/lib/test/unit/converters.test.d.ts

@@ -0,0 +1,2 @@
+import '../helpers/jest';
+//# sourceMappingURL=converters.test.d.ts.map

package/lib/test/unit/defaultingConverter.test.d.ts

@@ -0,0 +1,2 @@
+import '../helpers/jest';
+//# sourceMappingURL=defaultingConverter.test.d.ts.map