ts-data-forge 3.3.1 → 4.1.0

package/dist/functional/result/impl/result-unwrap-err-throw.mjs

@@ -0,0 +1,47 @@
+import { unknownToString } from '../../../others/unknown-to-string.mjs';
+import { match } from '../../match.mjs';
+import { isErr } from './result-is-err.mjs';
+
+/**
+ * Unwraps a `Result`, returning the error value. Throws an error if the
+ * `Result` is `Result.Ok`.
+ *
+ * This function is used when you expect a Result to be an error and want to
+ * extract the error value. If the Result is unexpectedly Ok, it will throw an
+ * error with information about the unexpected success value.
+ *
+ * @example
+ *
+ * ```ts
+ * const errResult = Result.err(new Error('broken'));
+ * const okResult = Result.ok('value');
+ *
+ * assert(Result.unwrapErrThrow(errResult).message === 'broken');
+ * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @param toStr An optional function to convert the success value to a string
+ *   for the error message when the Result is unexpectedly Ok. Defaults to
+ *   `String`.
+ * @returns The error value if `Result.Err`.
+ * @throws {Error} Error with message "Expected Err but got Ok: {value}" if
+ *   the `Result` is `Result.Ok`.
+ */
+const unwrapErrThrow = (result, toStr = unknownToString) => {
+    if (isErr(result)) {
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return result.value;
+    }
+    const variant = match(result.$$tag, {
+        'ts-data-forge::Result.ok': 'Ok',
+        'ts-data-forge::Result.err': 'Err',
+    });
+    throw new Error(`Expected Err but got ${variant}: ${toStr(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    result.value)}`);
+};
+
+export { unwrapErrThrow };
+//# sourceMappingURL=result-unwrap-err-throw.mjs.map

package/dist/functional/result/impl/result-unwrap-err-throw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err-throw.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,cAAc,GAAG,CAC5B,MAAS,EACT,KAAA,GAAoC,eAAe,KACnC;AAChB,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;;QAEjB,OAAO,MAAM,CAAC,KAAqB;IACrC;AAEA,IAAA,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE;AAClC,QAAA,0BAA0B,EAAE,IAAI;AAChC,QAAA,2BAA2B,EAAE,KAAK;AACnC,KAAA,CAAC;AAEF,IAAA,MAAM,IAAI,KAAK,CACb,CAAA,qBAAA,EAAwB,OAAO,KAAK,KAAK;;AAEvC,IAAA,MAAM,CAAC,KAAoB,CAC5B,CAAA,CAAE,CACJ;AACH;;;;"}

package/dist/functional/result/impl/result-unwrap-err.d.mts

@@ -0,0 +1,31 @@
+import { type UnwrapErr } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the error value or `undefined` if it is
+ * `Result.Ok`.
+ *
+ * This provides a safe way to extract error values from Results without
+ * throwing exceptions. Useful for error handling patterns where you want to
+ * check for specific error conditions.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('data');
+ * const errResult = Result.err('problem');
+ *
+ * // Result.unwrapErr returns undefined for Ok results
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+ * assert(Result.unwrapErr(okResult) === undefined);
+ *
+ * // Result.unwrapErr returns the error value for Err results
+ *
+ * assert(Result.unwrapErr(errResult) === 'problem');
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @returns The error value if `Result.Err`, otherwise `undefined`.
+ */
+export declare const unwrapErr: <R extends UnknownResult>(result: R) => UnwrapErr<R> | undefined;
+//# sourceMappingURL=result-unwrap-err.d.mts.map

package/dist/functional/result/impl/result-unwrap-err.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,aAAa,EAC/C,QAAQ,CAAC,KACR,SAAS,CAAC,CAAC,CAAC,GAAG,SAE0C,CAAC"}

package/dist/functional/result/impl/result-unwrap-err.mjs

@@ -0,0 +1,36 @@
+import { isErr } from './result-is-err.mjs';
+
+/**
+ * Unwraps a `Result`, returning the error value or `undefined` if it is
+ * `Result.Ok`.
+ *
+ * This provides a safe way to extract error values from Results without
+ * throwing exceptions. Useful for error handling patterns where you want to
+ * check for specific error conditions.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('data');
+ * const errResult = Result.err('problem');
+ *
+ * // Result.unwrapErr returns undefined for Ok results
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+ * assert(Result.unwrapErr(okResult) === undefined);
+ *
+ * // Result.unwrapErr returns the error value for Err results
+ *
+ * assert(Result.unwrapErr(errResult) === 'problem');
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @returns The error value if `Result.Err`, otherwise `undefined`.
+ */
+const unwrapErr = (result) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+isErr(result) ? result.value : undefined;
+
+export { unwrapErr };
+//# sourceMappingURL=result-unwrap-err.mjs.map

package/dist/functional/result/impl/result-unwrap-err.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-err.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,SAAS,GAAG,CACvB,MAAS;AAET;AACA,KAAK,CAAC,MAAM,CAAC,GAAI,MAAM,CAAC,KAAsB,GAAG;;;;"}

package/dist/functional/result/impl/result-unwrap-ok-or.d.mts

@@ -0,0 +1,29 @@
+import { type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the success value or a default value if it is
+ * `Result.Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok(10);
+ * const errValue = Result.err('fail');
+ *
+ * assert(Result.unwrapOkOr(okValue, 0) === 10);
+ * assert(Result.unwrapOkOr(errValue, 0) === 0);
+ *
+ * const unwrapWithDefault = Result.unwrapOkOr(5);
+ *
+ * assert(unwrapWithDefault(Result.ok(3)) === 3);
+ * assert(unwrapWithDefault(Result.err('no data')) === 5);
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @template D The type of the default value.
+ * @param result The `Result` to unwrap.
+ * @param defaultValue The value to return if `result` is `Result.Err`.
+ * @returns The success value if `Result.Ok`, otherwise `defaultValue`.
+ */
+export declare function unwrapOkOr<R extends UnknownResult, D>(result: R, defaultValue: D): D | UnwrapOk<R>;
+export declare function unwrapOkOr<S, D>(defaultValue: D): <E>(result: Result<S, E>) => D | S;
+//# sourceMappingURL=result-unwrap-ok-or.d.mts.map

package/dist/functional/result/impl/result-unwrap-ok-or.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-ok-or.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-ok-or.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,EACnD,MAAM,EAAE,CAAC,EACT,YAAY,EAAE,CAAC,GACd,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGnB,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC"}

package/dist/functional/result/impl/result-unwrap-ok-or.mjs

@@ -0,0 +1,20 @@
+import { unwrapOk } from './result-unwrap-ok.mjs';
+
+function unwrapOkOr(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, defaultValue] = args;
+            return unwrapOkOrImpl(result, defaultValue);
+        }
+        case 1: {
+            // Curried version
+            const [defaultValue] = args;
+            return (result) => unwrapOkOrImpl(result, defaultValue);
+        }
+    }
+}
+const unwrapOkOrImpl = (result, defaultValue) => unwrapOk(result) ?? defaultValue;
+
+export { unwrapOkOr };
+//# sourceMappingURL=result-unwrap-ok-or.mjs.map

package/dist/functional/result/impl/result-unwrap-ok-or.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-ok-or.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-ok-or.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAsCM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,IAAI;AACnC,YAAA,OAAO,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC;QAC7C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,YAAY,CAAC,GAAG,IAAI;YAC3B,OAAO,CAAC,MAAS,KAAK,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC;QAC5D;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,YAAe,KACK,QAAQ,CAAC,MAAM,CAAC,IAAI,YAAY;;;;"}

package/dist/functional/result/impl/result-unwrap-ok.d.mts

@@ -0,0 +1,23 @@
+import { type UnwrapOk } from './types.mjs';
+/**
+ * Safely unwraps the success value, returning `undefined` for failures.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok(42);
+ * const errResult = Result.err('oops');
+ *
+ * // Result.unwrapOk returns the value for Ok results
+ *
+ * assert(Result.unwrapOk(okResult) === 42);
+ *
+ * // Result.unwrapOk returns undefined for Err results
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+ * assert(Result.unwrapOk(errResult) === undefined);
+ * ```
+ */
+export declare function unwrapOk<R extends Ok<unknown>>(result: R): UnwrapOk<R>;
+export declare function unwrapOk<R extends UnknownResult>(result: R): UnwrapOk<R> | undefined;
+//# sourceMappingURL=result-unwrap-ok.d.mts.map

package/dist/functional/result/impl/result-unwrap-ok.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-ok.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-ok.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AACxE,wBAAgB,QAAQ,CAAC,CAAC,SAAS,aAAa,EAC9C,MAAM,EAAE,CAAC,GACR,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC"}

package/dist/functional/result/impl/result-unwrap-ok.mjs

@@ -0,0 +1,11 @@
+import { isOk } from './result-is-ok.mjs';
+
+function unwrapOk(result) {
+    return isOk(result)
+        ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            result.value
+        : undefined;
+}
+
+export { unwrapOk };
+//# sourceMappingURL=result-unwrap-ok.mjs.map

package/dist/functional/result/impl/result-unwrap-ok.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-ok.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA2BM,SAAU,QAAQ,CACtB,MAAS,EAAA;IAET,OAAO,IAAI,CAAC,MAAM;AAChB;AACG,YAAA,MAAM,CAAC;UACR,SAAS;AACf;;;;"}

package/dist/functional/result/impl/result-unwrap-throw.d.mts

@@ -0,0 +1,30 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the success value. Throws an error if the
+ * `Result` is `Result.Err`.
+ *
+ * This is useful when you're confident that a Result should contain a success
+ * value and want to treat errors as exceptional conditions. The error message
+ * will be constructed from the error value using the provided string
+ * conversion function.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('data');
+ * const errResult = Result.err(new Error('fail'));
+ *
+ * assert(Result.unwrapThrow(okResult) === 'data');
+ * assert.throws(() => Result.unwrapThrow(errResult), /fail/u);
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @param toStr An optional function to convert the error value to a string
+ *   for the error message. Defaults to `String`.
+ * @returns The success value if `Result.Ok`.
+ * @throws {Error} Error with the stringified error value if the `Result` is
+ *   `Result.Err`.
+ */
+export declare const unwrapThrow: <R extends UnknownResult>(result: R, toStr?: (e: UnwrapErr<R>) => string) => UnwrapOk<R>;
+//# sourceMappingURL=result-unwrap-throw.d.mts.map

package/dist/functional/result/impl/result-unwrap-throw.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-throw.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-unwrap-throw.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,aAAa,EACjD,QAAQ,CAAC,EACT,QAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,MAAwB,KACnD,QAAQ,CAAC,CAAC,CAQZ,CAAC"}

package/dist/functional/result/impl/result-unwrap-throw.mjs

@@ -0,0 +1,41 @@
+import { unknownToString } from '../../../others/unknown-to-string.mjs';
+import { isErr } from './result-is-err.mjs';
+
+/**
+ * Unwraps a `Result`, returning the success value. Throws an error if the
+ * `Result` is `Result.Err`.
+ *
+ * This is useful when you're confident that a Result should contain a success
+ * value and want to treat errors as exceptional conditions. The error message
+ * will be constructed from the error value using the provided string
+ * conversion function.
+ *
+ * @example
+ *
+ * ```ts
+ * const okResult = Result.ok('data');
+ * const errResult = Result.err(new Error('fail'));
+ *
+ * assert(Result.unwrapThrow(okResult) === 'data');
+ * assert.throws(() => Result.unwrapThrow(errResult), /fail/u);
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @param toStr An optional function to convert the error value to a string
+ *   for the error message. Defaults to `String`.
+ * @returns The success value if `Result.Ok`.
+ * @throws {Error} Error with the stringified error value if the `Result` is
+ *   `Result.Err`.
+ */
+const unwrapThrow = (result, toStr = unknownToString) => {
+    if (isErr(result)) {
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        throw new Error(toStr(result.value));
+    }
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return result.value;
+};
+
+export { unwrapThrow };
+//# sourceMappingURL=result-unwrap-throw.mjs.map

package/dist/functional/result/impl/result-unwrap-throw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-unwrap-throw.mjs","sources":["../../../../src/functional/result/impl/result-unwrap-throw.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,WAAW,GAAG,CACzB,MAAS,EACT,KAAA,GAAqC,eAAe,KACrC;AACf,IAAA,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;;QAEjB,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC;IACtD;;IAGA,OAAO,MAAM,CAAC,KAAoB;AACpC;;;;"}

package/dist/functional/result/impl/result-zip.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Combines two `Result` values into a single `Result` containing a tuple. If
+ * either `Result` is `Err`, returns the first `Err` encountered.
+ *
+ * @example
+ *
+ * ```ts
+ * const first = Result.ok('left');
+ * const second = Result.ok(1);
+ *
+ * const expected: readonly [string, number] = ['left', 1];
+ *
+ * assert.deepStrictEqual(Result.zip(first, second), Result.ok(expected));
+ * assert.deepStrictEqual(
+ *   Result.zip(first, Result.err('error')),
+ *   Result.err('error'),
+ * );
+ * ```
+ *
+ * @template S1 The success type of the first `Result`.
+ * @template E1 The error type of the first `Result`.
+ * @template S2 The success type of the second `Result`.
+ * @template E2 The error type of the second `Result`.
+ * @param resultA The first `Result`.
+ * @param resultB The second `Result`.
+ * @returns A `Result` containing a tuple of both values, or the first `Err`.
+ */
+export declare const zip: <S1, E1, S2, E2>(resultA: Result<S1, E1>, resultB: Result<S2, E2>) => Result<readonly [S1, S2], E1 | E2>;
+//# sourceMappingURL=result-zip.d.mts.map

package/dist/functional/result/impl/result-zip.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-zip.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-zip.mts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,GAAG,GAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAChC,SAAS,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,EACvB,SAAS,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,KACtB,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAKvB,CAAC"}

package/dist/functional/result/impl/result-zip.mjs

@@ -0,0 +1,38 @@
+import { isOk } from './result-is-ok.mjs';
+import { ok } from './result-ok.mjs';
+
+/**
+ * Combines two `Result` values into a single `Result` containing a tuple. If
+ * either `Result` is `Err`, returns the first `Err` encountered.
+ *
+ * @example
+ *
+ * ```ts
+ * const first = Result.ok('left');
+ * const second = Result.ok(1);
+ *
+ * const expected: readonly [string, number] = ['left', 1];
+ *
+ * assert.deepStrictEqual(Result.zip(first, second), Result.ok(expected));
+ * assert.deepStrictEqual(
+ *   Result.zip(first, Result.err('error')),
+ *   Result.err('error'),
+ * );
+ * ```
+ *
+ * @template S1 The success type of the first `Result`.
+ * @template E1 The error type of the first `Result`.
+ * @template S2 The success type of the second `Result`.
+ * @template E2 The error type of the second `Result`.
+ * @param resultA The first `Result`.
+ * @param resultB The second `Result`.
+ * @returns A `Result` containing a tuple of both values, or the first `Err`.
+ */
+const zip = (resultA, resultB) => isOk(resultA)
+    ? isOk(resultB)
+        ? ok([resultA.value, resultB.value])
+        : resultB
+    : resultA;
+
+export { zip };
+//# sourceMappingURL=result-zip.mjs.map

package/dist/functional/result/impl/result-zip.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-zip.mjs","sources":["../../../../src/functional/result/impl/result-zip.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,GAAG,GAAG,CACjB,OAAuB,EACvB,OAAuB,KAEvB,IAAI,CAAC,OAAO;AACV,MAAE,IAAI,CAAC,OAAO;AACZ,UAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAU;AAC5C,UAAE;MACF;;;;"}

package/dist/functional/result/impl/tag.d.mts

@@ -0,0 +1,5 @@
+/** @internal Tag identifying the Ok variant. */
+export declare const OkTypeTagName: Ok<unknown>['$$tag'];
+/** @internal Tag identifying the Err variant. */
+export declare const ErrTypeTagName: Err<unknown>['$$tag'];
+//# sourceMappingURL=tag.d.mts.map

package/dist/functional/result/impl/tag.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/tag.mts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,OAAO,CAA8B,CAAC;AAE9E,iDAAiD;AACjD,eAAO,MAAM,cAAc,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,OAAO,CACpB,CAAC"}

package/dist/functional/result/impl/tag.mjs

@@ -0,0 +1,7 @@
+/** @internal Tag identifying the Ok variant. */
+const OkTypeTagName = 'ts-data-forge::Result.ok';
+/** @internal Tag identifying the Err variant. */
+const ErrTypeTagName = 'ts-data-forge::Result.err';
+
+export { ErrTypeTagName, OkTypeTagName };
+//# sourceMappingURL=tag.mjs.map

package/dist/functional/result/impl/tag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/result/impl/tag.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACO,MAAM,aAAa,GAAyB;AAEnD;AACO,MAAM,cAAc,GACzB;;;;"}

package/dist/functional/result/impl/types.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Extracts the success value type `S` from a `Result.Ok<S>`. If the `Result`
+ * is `Result.Err<E>`, resolves to `never`.
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ */
+export type UnwrapOk<R extends UnknownResult> = R extends Ok<infer S> ? S : never;
+/**
+ * Extracts the error value type `E` from a `Result.Err<E>`. If the `Result`
+ * is `Result.Ok<S>`, resolves to `never`.
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ */
+export type UnwrapErr<R extends UnknownResult> = R extends Err<infer E> ? E : never;
+/**
+ * Narrows a `UnknownResult` type to `Result.Ok<S>` if it is an `Ok`. If the
+ * `Result` is `Result.Err<E>`, resolves to `never`.
+ *
+ * @template R The `UnknownResult` type to narrow.
+ */
+export type NarrowToOk<R extends UnknownResult> = R extends Ok<unknown> ? R : never;
+/**
+ * Narrows a `UnknownResult` type to `Result.Err<E>` if it is an `Err`. If the
+ * `Result` is `Result.Ok<S>`, resolves to `never`.
+ *
+ * @template R The `UnknownResult` type to narrow.
+ */
+export type NarrowToErr<R extends UnknownResult> = R extends Err<unknown> ? R : never;
+//# sourceMappingURL=types.d.mts.map

package/dist/functional/result/impl/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/types.mts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,aAAa,IAC1C,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,aAAa,IAC3C,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAErC;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,aAAa,IAC5C,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEpC;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,aAAa,IAC7C,CAAC,SAAS,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC"}

package/dist/functional/result/impl/types.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.mjs.map

package/dist/functional/result/impl/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/functional/result/index.d.mts

@@ -0,0 +1,2 @@
+export * as Result from './impl/index.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/functional/result/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/functional/result/index.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC"}

package/dist/functional/result/index.mjs

@@ -0,0 +1,3 @@
+import * as index from './impl/index.mjs';
+export { index as Result };
+//# sourceMappingURL=index.mjs.map

package/dist/functional/result/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/functional/ternary-result/impl/index.d.mts

@@ -0,0 +1,29 @@
+export * from './ternary-result-err.mjs';
+export * from './ternary-result-expect-to-be.mjs';
+export * from './ternary-result-flat-map.mjs';
+export * from './ternary-result-fold.mjs';
+export * from './ternary-result-from-promise.mjs';
+export * from './ternary-result-from-throwable.mjs';
+export * from './ternary-result-is-err.mjs';
+export * from './ternary-result-is-ok.mjs';
+export * from './ternary-result-is-ternary-result.mjs';
+export * from './ternary-result-is-warn.mjs';
+export * from './ternary-result-map-err.mjs';
+export * from './ternary-result-map-warn.mjs';
+export * from './ternary-result-map.mjs';
+export * from './ternary-result-ok.mjs';
+export * from './ternary-result-or-else.mjs';
+export * from './ternary-result-to-optional.mjs';
+export * from './ternary-result-unwrap-err-or.mjs';
+export * from './ternary-result-unwrap-err-throw.mjs';
+export * from './ternary-result-unwrap-err.mjs';
+export * from './ternary-result-unwrap-ok-or.mjs';
+export * from './ternary-result-unwrap-ok.mjs';
+export * from './ternary-result-unwrap-throw.mjs';
+export * from './ternary-result-unwrap-warn-or.mjs';
+export * from './ternary-result-unwrap-warn-throw.mjs';
+export * from './ternary-result-unwrap-warn.mjs';
+export * from './ternary-result-warn.mjs';
+export * from './ternary-result-zip.mjs';
+export * from './types.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/functional/ternary-result/impl/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wCAAwC,CAAC;AACvD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qCAAqC,CAAC;AACpD,cAAc,wCAAwC,CAAC;AACvD,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAC"}

package/dist/functional/ternary-result/impl/index.mjs

@@ -0,0 +1,28 @@
+export { err } from './ternary-result-err.mjs';
+export { expectToBe } from './ternary-result-expect-to-be.mjs';
+export { flatMap } from './ternary-result-flat-map.mjs';
+export { fold } from './ternary-result-fold.mjs';
+export { fromPromise } from './ternary-result-from-promise.mjs';
+export { fromThrowable } from './ternary-result-from-throwable.mjs';
+export { isErr } from './ternary-result-is-err.mjs';
+export { isOk } from './ternary-result-is-ok.mjs';
+export { isTernaryResult } from './ternary-result-is-ternary-result.mjs';
+export { isWarn } from './ternary-result-is-warn.mjs';
+export { mapErr } from './ternary-result-map-err.mjs';
+export { mapWarn } from './ternary-result-map-warn.mjs';
+export { map } from './ternary-result-map.mjs';
+export { ok } from './ternary-result-ok.mjs';
+export { orElse } from './ternary-result-or-else.mjs';
+export { toOptional } from './ternary-result-to-optional.mjs';
+export { unwrapErrOr } from './ternary-result-unwrap-err-or.mjs';
+export { unwrapErrThrow } from './ternary-result-unwrap-err-throw.mjs';
+export { unwrapErr } from './ternary-result-unwrap-err.mjs';
+export { unwrapOkOr } from './ternary-result-unwrap-ok-or.mjs';
+export { unwrapOk } from './ternary-result-unwrap-ok.mjs';
+export { unwrapThrow } from './ternary-result-unwrap-throw.mjs';
+export { unwrapWarnOr } from './ternary-result-unwrap-warn-or.mjs';
+export { unwrapWarnThrow } from './ternary-result-unwrap-warn-throw.mjs';
+export { unwrapWarn } from './ternary-result-unwrap-warn.mjs';
+export { warn } from './ternary-result-warn.mjs';
+export { zip } from './ternary-result-zip.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functional/ternary-result/impl/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/functional/ternary-result/impl/tag.d.mts

@@ -0,0 +1,7 @@
+/** @internal Tag identifying the Ok variant. */
+export declare const OkTypeTagName: TernaryOk<unknown>['$$tag'];
+/** @internal Tag identifying the Warn variant. */
+export declare const WarnTypeTagName: TernaryWarn<unknown, unknown>['$$tag'];
+/** @internal Tag identifying the Err variant. */
+export declare const ErrTypeTagName: TernaryErr<unknown>['$$tag'];
+//# sourceMappingURL=tag.d.mts.map

package/dist/functional/ternary-result/impl/tag.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/tag.mts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,eAAO,MAAM,aAAa,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,OAAO,CAC1B,CAAC;AAE7B,kDAAkD;AAClD,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,OAAO,CACrC,CAAC;AAE/B,iDAAiD;AACjD,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAC3B,CAAC"}

package/dist/functional/ternary-result/impl/tag.mjs

@@ -0,0 +1,9 @@
+/** @internal Tag identifying the Ok variant. */
+const OkTypeTagName = 'ts-data-forge::Result.ok';
+/** @internal Tag identifying the Warn variant. */
+const WarnTypeTagName = 'ts-data-forge::Result.warn';
+/** @internal Tag identifying the Err variant. */
+const ErrTypeTagName = 'ts-data-forge::Result.err';
+
+export { ErrTypeTagName, OkTypeTagName, WarnTypeTagName };
+//# sourceMappingURL=tag.mjs.map

package/dist/functional/ternary-result/impl/tag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.mjs","sources":["../../../../src/functional/ternary-result/impl/tag.mts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACO,MAAM,aAAa,GACxB;AAEF;AACO,MAAM,eAAe,GAC1B;AAEF;AACO,MAAM,cAAc,GACzB;;;;"}

package/dist/functional/ternary-result/impl/ternary-result-err.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Creates a `TernaryResult.Err` containing the provided error value.
+ *
+ * @example
+ *
+ * ```ts
+ * const failure = TernaryResult.err(new Error('missing data'));
+ *
+ * assert.strictEqual(failure.$$tag, 'ts-data-forge::Result.err');
+ * assert.ok(TernaryResult.isErr(failure));
+ * ```
+ */
+export declare const err: <E>(value: E) => TernaryErr<E>;
+//# sourceMappingURL=ternary-result-err.d.mts.map

package/dist/functional/ternary-result/impl/ternary-result-err.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ternary-result-err.d.mts","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-err.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAG,OAAO,CAAC,KAAG,UAAU,CAAC,CAAC,CAG7C,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-err.mjs

@@ -0,0 +1,21 @@
+import { ErrTypeTagName } from './tag.mjs';
+
+/**
+ * Creates a `TernaryResult.Err` containing the provided error value.
+ *
+ * @example
+ *
+ * ```ts
+ * const failure = TernaryResult.err(new Error('missing data'));
+ *
+ * assert.strictEqual(failure.$$tag, 'ts-data-forge::Result.err');
+ * assert.ok(TernaryResult.isErr(failure));
+ * ```
+ */
+const err = (value) => ({
+    $$tag: ErrTypeTagName,
+    value,
+});
+
+export { err };
+//# sourceMappingURL=ternary-result-err.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-err.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ternary-result-err.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-err.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;AAWG;MACU,GAAG,GAAG,CAAK,KAAQ,MAAqB;AACnD,IAAA,KAAK,EAAE,cAAc;IACrB,KAAK;AACN,CAAA;;;;"}

package/dist/functional/ternary-result/impl/ternary-result-expect-to-be.d.mts

@@ -0,0 +1,18 @@
+import { type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps the Ok value or throws with the provided message.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = TernaryResult.ok('ready');
+ *
+ * assert.strictEqual(TernaryResult.expectToBe(okValue, 'missing'), 'ready');
+ * const expectResult = TernaryResult.expectToBe<string>('needs value');
+ *
+ * assert.throws(() => expectResult(TernaryResult.err('oops')), /needs value/u);
+ * ```
+ */
+export declare function expectToBe<R extends UnknownTernaryResult>(result: R, message: string): UnwrapOk<R>;
+export declare function expectToBe<S>(message: string): <W, E>(result: TernaryResult<S, E, W>) => S;
+//# sourceMappingURL=ternary-result-expect-to-be.d.mts.map