ts-data-forge 3.3.1 → 4.1.0

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

@@ -0,0 +1,22 @@
+/**
+ * Extracts the value type `S` from an {@link Some}<S>. If the
+ * {@link Optional} is {@link None}, resolves to `never`.
+ *
+ * @template O The {@link UnknownOptional} type to unwrap.
+ */
+export type Unwrap<O extends UnknownOptional> = O extends Some<infer S> ? S : never;
+/**
+ * Narrows an {@link UnknownOptional} type to {@link Some}<S> if it is a
+ * {@link Some}. If the {@link Optional} is {@link None}, resolves to `never`.
+ *
+ * @template O The {@link UnknownOptional} type to narrow.
+ */
+export type NarrowToSome<O extends UnknownOptional> = O extends None ? never : O;
+/**
+ * Narrows an {@link UnknownOptional} type to {@link None} if it is a
+ * {@link None}. If the {@link Optional} is {@link Some}<S>, resolves to never.
+ *
+ * @template O The {@link UnknownOptional} type to narrow.
+ */
+export type NarrowToNone<O extends UnknownOptional> = O extends None ? O : never;
+//# sourceMappingURL=types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../../../src/functional/optional/impl/types.mts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,eAAe,IAC1C,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,SAAS,IAAI,GAChE,KAAK,GACL,CAAC,CAAC;AAEN;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,eAAe,IAAI,CAAC,SAAS,IAAI,GAChE,CAAC,GACD,KAAK,CAAC"}

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

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

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

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

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

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

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

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

package/dist/functional/optional/index.mjs

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

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

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

package/dist/functional/pipe.d.mts

@@ -1,4 +1,4 @@
-import { Optional } from './optional.mjs';
+import { Optional } from './optional/index.mjs';
 /**
  * Creates a new pipe object that allows for chaining operations on a value.
  *
@@ -17,9 +17,9 @@ import { Optional } from './optional.mjs';
  * @param a The initial value to wrap in a pipe.
  * @returns A pipe object with chaining methods appropriate for the value type.
  */
-export declare function pipe<const A extends Optional.Base>(a: A): PipeWithMapOptional<A>;
+export declare function pipe<const A extends UnknownOptional>(a: A): PipeWithMapOptional<A>;
 export declare function pipe<const A>(a: A): PipeBase<A>;
-type Pipe<A> = A extends Optional.Base ? PipeWithMapOptional<A> : PipeBase<A>;
+type Pipe<A> = A extends UnknownOptional ? PipeWithMapOptional<A> : PipeBase<A>;
 /**
  * @template A The type of the current value in the pipe.
  * @internal
@@ -80,7 +80,7 @@ type PipeBase<A> = Readonly<{
  * Pipe interface for Optional values, providing Optional-aware mapping.
  * Extends PipeBase with mapOptional functionality for monadic operations.
  */
-type PipeWithMapOptional<A extends Optional.Base> = MergeIntersection<PipeBase<A> & Readonly<{
+type PipeWithMapOptional<A extends UnknownOptional> = MergeIntersection<PipeBase<A> & Readonly<{
     /**
      * Maps the value inside an Optional using Optional.map semantics. If the
      * Optional is None, the transformation is skipped and None is propagated.

package/dist/functional/pipe.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,EAChD,CAAC,EAAE,CAAC,GACH,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE1B,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAkBjD,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,IAAI,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,IAAI,iBAAiB,CACnE,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CACL,CAAC"}
+{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,eAAe,EAClD,CAAC,EAAE,CAAC,GACH,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE1B,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAkBjD,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,eAAe,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,eAAe,IAAI,iBAAiB,CACrE,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CACL,CAAC"}

package/dist/functional/pipe.mjs

@@ -1,11 +1,12 @@
-import { Optional } from './optional.mjs';
+import { isOptional } from './optional/impl/optional-is-optional.mjs';
+import { map } from './optional/impl/optional-map.mjs';
 
 function pipe(a) {
-    if (Optional.isOptional(a)) {
+    if (isOptional(a)) {
         return {
             value: a,
             map: (fn) => pipe(fn(a)),
-            mapOptional: (fn) => pipe(Optional.map(a, fn)),
+            mapOptional: (fn) => pipe(map(a, fn)),
         };
     }
     else {

package/dist/functional/pipe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA0BM,SAAU,IAAI,CAAU,CAAI,EAAA;AAChC,IAAA,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE;QAC1B,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACxB,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;IACH;SAAO;QACL,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;IACH;AACF;;;;"}
+{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":["Optional.isOptional","Optional.map"],"mappings":";;;AA0BM,SAAU,IAAI,CAAU,CAAI,EAAA;AAChC,IAAA,IAAIA,UAAmB,CAAC,CAAC,CAAC,EAAE;QAC1B,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACxB,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAACC,GAAY,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;IACH;SAAO;QACL,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;IACH;AACF;;;;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/index.mts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

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

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

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

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

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

@@ -0,0 +1,25 @@
+/**
+ * Creates a `Result.Err` containing the given error value.
+ *
+ * Use this constructor when an operation fails and you want to wrap the error
+ * information in a Result type for consistent error handling.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.ok({ id: 1 });
+ * const failure = Result.err(new Error('missing data'));
+ *
+ * assert.deepStrictEqual(success, {
+ *   $$tag: 'ts-data-forge::Result.ok',
+ *   value: { id: 1 },
+ * });
+ * assert.ok(Result.isErr(failure));
+ * ```
+ *
+ * @template E The type of the error value.
+ * @param value The error value.
+ * @returns A `Result.Err<E>` containing the value.
+ */
+export declare const err: <E>(value: E) => Err<E>;
+//# sourceMappingURL=result-err.d.mts.map

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

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

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

@@ -0,0 +1,32 @@
+import { ErrTypeTagName } from './tag.mjs';
+
+/**
+ * Creates a `Result.Err` containing the given error value.
+ *
+ * Use this constructor when an operation fails and you want to wrap the error
+ * information in a Result type for consistent error handling.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.ok({ id: 1 });
+ * const failure = Result.err(new Error('missing data'));
+ *
+ * assert.deepStrictEqual(success, {
+ *   $$tag: 'ts-data-forge::Result.ok',
+ *   value: { id: 1 },
+ * });
+ * assert.ok(Result.isErr(failure));
+ * ```
+ *
+ * @template E The type of the error value.
+ * @param value The error value.
+ * @returns A `Result.Err<E>` containing the value.
+ */
+const err = (value) => ({
+    $$tag: ErrTypeTagName,
+    value,
+});
+
+export { err };
+//# sourceMappingURL=result-err.mjs.map

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

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

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

@@ -0,0 +1,27 @@
+import { type UnwrapOk } from './types.mjs';
+/**
+ * Unwraps a `Result`, returning the success value or throwing an error with
+ * the provided message.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok('data');
+ *
+ * assert(Result.expectToBe(okValue, 'should have value') === 'data');
+ *
+ * const expectResult = Result.expectToBe<string>('missing result');
+ *
+ * assert.throws(() => expectResult(Result.err('boom')), /missing result/u);
+ * assert(expectResult(Result.ok('value')) === 'value');
+ * ```
+ *
+ * @template R The `UnknownResult` type to unwrap.
+ * @param result The `Result` to unwrap.
+ * @param message The error message to throw if the `Result` is `Result.Err`.
+ * @returns The success value if `Result.Ok`.
+ * @throws Error with the provided message if the `Result` is `Result.Err`.
+ */
+export declare function expectToBe<R extends UnknownResult>(result: R, message: string): UnwrapOk<R>;
+export declare function expectToBe<S>(message: string): <E>(result: Result<S, E>) => S;
+//# sourceMappingURL=result-expect-to-be.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-expect-to-be.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,aAAa,EAChD,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,MAAM,GACd,QAAQ,CAAC,CAAC,CAAC,CAAC;AAGf,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC"}

package/dist/functional/result/impl/result-expect-to-be.mjs

@@ -0,0 +1,26 @@
+import { isOk } from './result-is-ok.mjs';
+import { unwrapOk } from './result-unwrap-ok.mjs';
+
+function expectToBe(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, message] = args;
+            return expectToBeImpl(result, message);
+        }
+        case 1: {
+            // Curried version: first argument is message
+            const [message] = args;
+            return (result) => expectToBeImpl(result, message);
+        }
+    }
+}
+const expectToBeImpl = (result, message) => {
+    if (isOk(result)) {
+        return unwrapOk(result);
+    }
+    throw new Error(message);
+};
+
+export { expectToBe };
+//# sourceMappingURL=result-expect-to-be.mjs.map

package/dist/functional/result/impl/result-expect-to-be.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-expect-to-be.mjs","sources":["../../../../src/functional/result/impl/result-expect-to-be.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAmCM,SAAU,UAAU,CACxB,GAAG,IAAwE,EAAA;AAE3E,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;AAC9B,YAAA,OAAO,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACxC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI;YACtB,OAAO,CAAC,MAAS,KAAkB,cAAc,CAAC,MAAM,EAAE,OAAO,CAAC;QACpE;;AAEJ;AAEA,MAAM,cAAc,GAAG,CACrB,MAAS,EACT,OAAe,KACA;AACf,IAAA,IAAI,IAAI,CAAC,MAAM,CAAC,EAAE;AAChB,QAAA,OAAO,QAAQ,CAAC,MAAM,CAAC;IACzB;AAEA,IAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;AAC1B,CAAC;;;;"}

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

@@ -0,0 +1,39 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Applies a function that returns a `Result` to the success value of a
+ * `Result`. If the input is `Err`, returns the original `Err`. This is the
+ * monadic bind operation for `Result`.
+ *
+ * @example
+ *
+ * ```ts
+ * const parseNumber = (input: string): Result<number, string> => {
+ *   const num = Number.parseInt(input, 10);
+ *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);
+ * };
+ *
+ * const parsed = Result.flatMap(Result.ok('42'), parseNumber);
+ * const failure = Result.flatMap(Result.ok('abc'), parseNumber);
+ * const passthrough = Result.flatMap(Result.err('fail'), parseNumber);
+ *
+ * assert.deepStrictEqual(parsed, Result.ok(42));
+ * assert.deepStrictEqual(failure, Result.err('not a number'));
+ * assert.deepStrictEqual(passthrough, Result.err('fail'));
+ *
+ * const parseThenDouble = Result.flatMap((input: string) =>
+ *   Result.map(parseNumber(input), (value) => value * 2),
+ * );
+ *
+ * assert.deepStrictEqual(parseThenDouble(Result.ok('10')), Result.ok(20));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @template S2 The success type of the `Result` returned by the function.
+ * @template E2 The error type of the `Result` returned by the function.
+ * @param result The `Result` to flat map.
+ * @param flatMapFn The function to apply that returns a `Result`.
+ * @returns The result of applying the function, or the original `Err`.
+ */
+export declare function flatMap<R extends UnknownResult, S2, E2>(result: R, flatMapFn: (value: UnwrapOk<R>) => Result<S2, E2>): Result<S2, E2 | UnwrapErr<R>>;
+export declare function flatMap<S, S2, E2>(flatMapFn: (value: S) => Result<S2, E2>): <E>(result: Result<S, E>) => Result<S2, E | E2>;
+//# sourceMappingURL=result-flat-map.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-flat-map.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-flat-map.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAAE,EAAE,EACrD,MAAM,EAAE,CAAC,EACT,SAAS,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAChD,MAAM,CAAC,EAAE,EAAE,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAGjC,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAC/B,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GACtC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,24 @@
+import { isErr } from './result-is-err.mjs';
+
+function flatMap(...args) {
+    switch (args.length) {
+        case 2: {
+            // Direct version: first argument is result
+            const [result, flatMapFn] = args;
+            return flatMapImpl(result, flatMapFn);
+        }
+        case 1: {
+            // Curried version
+            const [flatMapFn] = args;
+            return (result) => flatMapImpl(result, flatMapFn);
+        }
+    }
+}
+const flatMapImpl = (result, flatMapFn) => isErr(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        flatMapFn(result.value);
+
+export { flatMap };
+//# sourceMappingURL=result-flat-map.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-flat-map.mjs","sources":["../../../../src/functional/result/impl/result-flat-map.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAgDM,SAAU,OAAO,CACrB,GAAG,IAE6D,EAAA;AAIhE,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,IAAI;AAChC,YAAA,OAAO,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC;QACvC;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,SAAS,CAAC,GAAG,IAAI;YACxB,OAAO,CAAC,MAAS,KAAK,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC;QACtD;;AAEJ;AAEA,MAAM,WAAW,GAAG,CAClB,MAAS,EACT,SAAiD,KAEjD,KAAK,CAAC,MAAM;AACV;QACG;AACH;AACE,QAAA,SAAS,CAAC,MAAM,CAAC,KAAoB,CAAC;;;;"}

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

@@ -0,0 +1,45 @@
+import { type UnwrapErr, type UnwrapOk } from './types.mjs';
+/**
+ * Applies one of two functions depending on whether the `Result` is `Ok` or
+ * `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = Result.ok(2);
+ * const errValue = Result.err('bad');
+ *
+ * const foldedOk = Result.fold(
+ *   okValue,
+ *   (value) => value * 2,
+ *   (error) => error,
+ * );
+ * const foldedErr = Result.fold(
+ *   errValue,
+ *   (value: number) => value * 2,
+ *   (error) => error.toUpperCase(),
+ * );
+ *
+ * assert.deepStrictEqual(foldedOk, Result.ok(4));
+ * assert.deepStrictEqual(foldedErr, Result.err('BAD'));
+ *
+ * const foldNumbers = Result.fold(
+ *   (value: number) => value * 3,
+ *   (error: string) => error.length,
+ * );
+ *
+ * assert.deepStrictEqual(foldNumbers(Result.ok(3)), Result.ok(9));
+ * assert.deepStrictEqual(foldNumbers(Result.err('oops')), Result.err(4));
+ * ```
+ *
+ * @template R The input `UnknownResult` type.
+ * @template S2 The type of the success value returned by `mapFn`.
+ * @template E2 The type of the error value returned by `mapErrFn`.
+ * @param result The `Result` to fold.
+ * @param mapFn The function to apply if `result` is `Ok`.
+ * @param mapErrFn The function to apply if `result` is `Err`.
+ * @returns A new `Result<S2, E2>` based on the applied function.
+ */
+export declare function fold<R extends UnknownResult, S2, E2>(result: R, mapFn: (value: UnwrapOk<R>) => S2, mapErrFn: (error: UnwrapErr<R>) => E2): Result<S2, E2>;
+export declare function fold<S, E, S2, E2>(mapFn: (value: S) => S2, mapErrFn: (error: E) => E2): (result: Result<S, E>) => Result<S2, E2>;
+//# sourceMappingURL=result-fold.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-fold.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-fold.mts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,aAAa,EAAE,EAAE,EAAE,EAAE,EAClD,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,EACjC,QAAQ,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,EAAE,GACpC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AAGlB,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAC/B,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,GACzB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,26 @@
+import { err } from './result-err.mjs';
+import { isOk } from './result-is-ok.mjs';
+import { ok } from './result-ok.mjs';
+
+function fold(...args) {
+    switch (args.length) {
+        case 3: {
+            // Direct version: first argument is result
+            const [result, mapFn, mapErrFn] = args;
+            return foldImpl(result, mapFn, mapErrFn);
+        }
+        case 2: {
+            // Curried version
+            const [mapFn, mapErrFn] = args;
+            return (result) => foldImpl(result, mapFn, mapErrFn);
+        }
+    }
+}
+const foldImpl = (result, mapFn, mapErrFn) => isOk(result)
+    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        ok(mapFn(result.value))
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        err(mapErrFn(result.value));
+
+export { fold };
+//# sourceMappingURL=result-fold.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-fold.mjs","sources":["../../../../src/functional/result/impl/result-fold.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AA0DM,SAAU,IAAI,CAClB,GAAG,IASE,EAAA;AAEL,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;;YAEN,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI;YACtC,OAAO,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC;QAC1C;QAEA,KAAK,CAAC,EAAE;;AAEN,YAAA,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,IAAI;AAC9B,YAAA,OAAO,CAAC,MAAS,KAAK,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,CAAC;QACzD;;AAEJ;AAEA,MAAM,QAAQ,GAAG,CACf,MAAS,EACT,KAAiC,EACjC,QAAqC,KAErC,IAAI,CAAC,MAAM;AACT;AACE,QAAA,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAoB,CAAC;AACvC;QACE,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAqB,CAAC,CAAC;;;;"}

package/dist/functional/result/impl/result-from-promise.d.mts

@@ -0,0 +1,32 @@
+/**
+ * @template P The Promise type.
+ * @internal
+ * Utility type to extract the resolved value type from a Promise.
+ */
+type UnwrapPromise<P extends Promise<unknown>> = P extends Promise<infer V> ? V : never;
+/**
+ * Converts a Promise into a Promise that resolves to a `Result`. If the input
+ * Promise resolves, the `Result` will be `Ok` with the resolved value. If the
+ * input Promise rejects, the `Result` will be `Err` with the rejection
+ * reason.
+ *
+ * @example
+ *
+ * ```ts
+ * const successPromise = Result.fromPromise(Promise.resolve('ok'));
+ * const failurePromise = Result.fromPromise(Promise.reject(new Error('fail')));
+ *
+ * const resolved = await successPromise;
+ * const rejected = await failurePromise;
+ *
+ * assert.deepStrictEqual(resolved, Result.ok('ok'));
+ * assert.ok(Result.isErr(rejected));
+ * ```
+ *
+ * @template P The type of the input Promise.
+ * @param promise The Promise to convert.
+ * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.
+ */
+export declare const fromPromise: <P extends Promise<unknown>>(promise: P) => Promise<Result<UnwrapPromise<P>, unknown>>;
+export {};
+//# sourceMappingURL=result-from-promise.d.mts.map

package/dist/functional/result/impl/result-from-promise.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-from-promise.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,KAAK,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,EACpD,SAAS,CAAC,KACT,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAEmB,CAAC"}

package/dist/functional/result/impl/result-from-promise.mjs

@@ -0,0 +1,32 @@
+import { err } from './result-err.mjs';
+import { ok } from './result-ok.mjs';
+
+/**
+ * Converts a Promise into a Promise that resolves to a `Result`. If the input
+ * Promise resolves, the `Result` will be `Ok` with the resolved value. If the
+ * input Promise rejects, the `Result` will be `Err` with the rejection
+ * reason.
+ *
+ * @example
+ *
+ * ```ts
+ * const successPromise = Result.fromPromise(Promise.resolve('ok'));
+ * const failurePromise = Result.fromPromise(Promise.reject(new Error('fail')));
+ *
+ * const resolved = await successPromise;
+ * const rejected = await failurePromise;
+ *
+ * assert.deepStrictEqual(resolved, Result.ok('ok'));
+ * assert.ok(Result.isErr(rejected));
+ * ```
+ *
+ * @template P The type of the input Promise.
+ * @param promise The Promise to convert.
+ * @returns A Promise that resolves to `Result<UnwrapPromise<P>, unknown>`.
+ */
+const fromPromise = (promise) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+promise.then((v) => ok(v)).catch(err);
+
+export { fromPromise };
+//# sourceMappingURL=result-from-promise.mjs.map

package/dist/functional/result/impl/result-from-promise.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-from-promise.mjs","sources":["../../../../src/functional/result/impl/result-from-promise.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,WAAW,GAAG,CACzB,OAAU;AAEV;AACA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAyB,CAAC,CAAC,KAAK,CAAC,GAAG;;;;"}

package/dist/functional/result/impl/result-from-throwable.d.mts

@@ -0,0 +1,29 @@
+/**
+ * Wraps a function that may throw an exception in a `Result`.
+ *
+ * This is a fundamental utility for converting traditional exception-based
+ * error handling into Result-based error handling. Any thrown value is
+ * converted to an Error object for consistent error handling.
+ *
+ * If the function executes successfully, returns `Result.Ok` with the result.
+ * If the function throws, returns `Result.Err` with the caught error.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.fromThrowable(() => 1 + 1);
+ * const failure = Result.fromThrowable(() => {
+ *   throw new Error('boom');
+ * });
+ *
+ * assert.deepStrictEqual(success, Result.ok(2));
+ * assert.ok(Result.isErr(failure));
+ * ```
+ *
+ * @template T The return type of the function.
+ * @param fn The function to execute that may throw.
+ * @returns A `Result<T, Error>` containing either the successful result or
+ *   the caught error.
+ */
+export declare const fromThrowable: <T>(fn: () => T) => Result<T, Error>;
+//# sourceMappingURL=result-from-throwable.d.mts.map

package/dist/functional/result/impl/result-from-throwable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-from-throwable.d.mts","sourceRoot":"","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAG,IAAI,MAAM,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,KAAK,CAU9D,CAAC"}

package/dist/functional/result/impl/result-from-throwable.mjs

@@ -0,0 +1,46 @@
+import { unknownToString } from '../../../others/unknown-to-string.mjs';
+import { err } from './result-err.mjs';
+import { ok } from './result-ok.mjs';
+
+/**
+ * Wraps a function that may throw an exception in a `Result`.
+ *
+ * This is a fundamental utility for converting traditional exception-based
+ * error handling into Result-based error handling. Any thrown value is
+ * converted to an Error object for consistent error handling.
+ *
+ * If the function executes successfully, returns `Result.Ok` with the result.
+ * If the function throws, returns `Result.Err` with the caught error.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = Result.fromThrowable(() => 1 + 1);
+ * const failure = Result.fromThrowable(() => {
+ *   throw new Error('boom');
+ * });
+ *
+ * assert.deepStrictEqual(success, Result.ok(2));
+ * assert.ok(Result.isErr(failure));
+ * ```
+ *
+ * @template T The return type of the function.
+ * @param fn The function to execute that may throw.
+ * @returns A `Result<T, Error>` containing either the successful result or
+ *   the caught error.
+ */
+const fromThrowable = (fn) => {
+    try {
+        return ok(fn());
+    }
+    catch (error) {
+        if (Error.isError(error)) {
+            return err(error);
+        }
+        const msg = unknownToString(error);
+        return err(new Error(msg));
+    }
+};
+
+export { fromThrowable };
+//# sourceMappingURL=result-from-throwable.mjs.map

package/dist/functional/result/impl/result-from-throwable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-from-throwable.mjs","sources":["../../../../src/functional/result/impl/result-from-throwable.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,aAAa,GAAG,CAAK,EAAW,KAAsB;AACjE,IAAA,IAAI;AACF,QAAA,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;IACjB;IAAE,OAAO,KAAK,EAAE;AACd,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;AACxB,YAAA,OAAO,GAAG,CAAC,KAAK,CAAC;QACnB;AACA,QAAA,MAAM,GAAG,GAAG,eAAe,CAAC,KAAK,CAAC;QAClC,OAAO,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC;IAC5B;AACF;;;;"}

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

@@ -0,0 +1,20 @@
+import { type NarrowToErr } from './types.mjs';
+/**
+ * Type guard for the error variant.
+ *
+ * @example
+ *
+ * ```ts
+ * const operation = Result.ok(3);
+ * const failure = Result.err('error');
+ *
+ * if (Result.isOk(operation)) {
+ *   const value: number = operation.value;
+ *   assert(value === 3);
+ * }
+ *
+ * assert.ok(Result.isErr(failure));
+ * ```
+ */
+export declare const isErr: <R extends UnknownResult>(result: R) => result is NarrowToErr<R>;
+//# sourceMappingURL=result-is-err.d.mts.map