resultfier 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # resultfier
 
+## 0.4.0
+
+### Minor Changes
+
+- 2f11d84: add zod integration and reorganize the project
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/{extra → action}/action.d.ts

@@ -1,4 +1,4 @@
-import { A as AsyncResult } from '../index-Dy6VGmoZ.js';
+import { AsyncResult } from '../core/index.js';
 
 type Action<TParams, TData, TError> = (params: TParams) => AsyncResult<TData, TError>;
 

package/dist/action/action.js

@@ -0,0 +1,3 @@
+import '../chunk-7CTLLC5F.js';
+//# sourceMappingURL=action.js.map
+//# sourceMappingURL=action.js.map

package/dist/{extra → action}/index.d.ts

@@ -1,2 +1,2 @@
 export { Action } from './action.js';
-import '../index-Dy6VGmoZ.js';
+import '../core/index.js';

package/dist/action/index.js

@@ -0,0 +1,3 @@
+import '../chunk-7CTLLC5F.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/{extra → action}/index.js.map

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

package/dist/chunk-7CTLLC5F.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=chunk-7CTLLC5F.js.map
+//# sourceMappingURL=chunk-7CTLLC5F.js.map

package/dist/chunk-7CTLLC5F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-7CTLLC5F.js"}

package/dist/chunk-D2DM2EYA.js

@@ -0,0 +1,7 @@
+// src/core/result.ts
+var ResultBase = class {
+};
+
+export { ResultBase };
+//# sourceMappingURL=chunk-D2DM2EYA.js.map
+//# sourceMappingURL=chunk-D2DM2EYA.js.map

package/dist/chunk-D2DM2EYA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/result.ts"],"names":[],"mappings":";AAOO,IAAe,aAAf,MAAgC;AA4DvC","file":"chunk-D2DM2EYA.js","sourcesContent":["import type { Err } from '@/core/err';\nimport type { Ok } from '@/core/ok';\n\n/**\n * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).\n * This is an abstract base class that provides common functionality for both variants.\n */\nexport abstract class ResultBase<T, E> {\n    /**\n     * Type guard to check if the result is an `Ok` variant.\n     */\n    abstract readonly isOk: boolean;\n\n    /**\n     * Type guard to check if the result is an `Err` variant.\n     */\n    abstract readonly isErr: boolean;\n\n    /**\n     * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,\n     * leaving an `Err` value untouched.\n     */\n    abstract map<U>(fn: (value: T) => U): Result<U, E>;\n\n    /**\n     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,\n     * leaving an `Ok` value untouched.\n     */\n    abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;\n\n    /**\n     * Returns the contained `Ok` value, consuming the self value.\n     * Throws an error if the result is `Err`.\n     */\n    abstract unwrap(): T;\n\n    /**\n     * Returns the contained `Err` value, consuming the self value.\n     * Throws an error if the result is Ok.\n     */\n    abstract unwrapErr(): E;\n\n    /**\n     * Returns the contained `Ok` value or a provided default.\n     */\n    abstract unwrapOr(defaultValue: T): T;\n\n    /**\n     * Returns the contained `Ok` value or computes it from a closure.\n     */\n    abstract unwrapOrElse(fn: (error: E) => T): T;\n\n    /**\n     * Calls the provided function with the contained value and returns the result.\n     * If the result is `Err`, the function is not called and the `Err` is returned.\n     */\n    abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;\n\n    /**\n     * Returns true if the result is `Ok` and the value inside of it matches a predicate.\n     */\n    abstract contains(value: T): boolean;\n\n    /**\n     * Returns true if the result is `Err` and the error inside of it matches a predicate.\n     */\n    abstract containsErr(error: E): boolean;\n}\n\n/**\n * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.\n */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/**\n * Type alias for an async `Result` (Promise-wrapped `Result`).\n */\nexport type AsyncResult<T, E> = Promise<Result<T, E>>;\n"]}

package/dist/chunk-GGEJTXXS.js

@@ -0,0 +1,74 @@
+import { ResultBase } from './chunk-D2DM2EYA.js';
+
+// src/core/ok.ts
+var Ok = class _Ok extends ResultBase {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  _tag = "ok";
+  isOk = true;
+  isErr = false;
+  /**
+   * Maps the contained value using the provided function.
+   * Since this is `Ok`, the function is always applied.
+   */
+  map(fn) {
+    return new _Ok(fn(this.value));
+  }
+  /**
+   * Maps the error type, but since this is `Ok`, it's a no-op.
+   */
+  mapErr(_fn) {
+    return this;
+  }
+  /**
+   * Returns the contained value.
+   */
+  unwrap() {
+    return this.value;
+  }
+  /**
+   * Throws an error since this is Ok, not Err.
+   */
+  unwrapErr() {
+    throw new Error(`Called unwrapErr() on an Ok value: ${this.value}`);
+  }
+  /**
+   * Returns the contained value, ignoring the default.
+   */
+  unwrapOr(_defaultValue) {
+    return this.value;
+  }
+  /**
+   * Returns the contained value, ignoring the fallback function.
+   */
+  unwrapOrElse(_fn) {
+    return this.value;
+  }
+  /**
+   * Applies the function to the contained value and returns the result.
+   */
+  andThen(fn) {
+    return fn(this.value);
+  }
+  /**
+   * Checks if the contained value matches the provided value.
+   */
+  contains(value) {
+    return this.value === value;
+  }
+  /**
+   * Always returns false since this is `Ok`, not `Err`.
+   */
+  containsErr(_error) {
+    return false;
+  }
+};
+function ok(value) {
+  return new Ok(value);
+}
+
+export { Ok, ok };
+//# sourceMappingURL=chunk-GGEJTXXS.js.map
+//# sourceMappingURL=chunk-GGEJTXXS.js.map

package/dist/chunk-GGEJTXXS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/ok.ts"],"names":[],"mappings":";;;AAMO,IAAM,EAAA,GAAN,MAAM,GAAA,SAAc,UAAA,CAAqB;AAAA,EAK5C,YAAqB,KAAA,EAAU;AAC3B,IAAA,KAAA,EAAM;AADW,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAErB;AAAA,EANS,IAAA,GAAO,IAAA;AAAA,EACP,IAAA,GAAO,IAAA;AAAA,EACP,KAAA,GAAQ,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUjB,IAAO,EAAA,EAA4B;AAC/B,IAAA,OAAO,IAAI,GAAA,CAAG,EAAA,CAAG,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA,EAKA,OAAU,GAAA,EAAiC;AACvC,IAAA,OAAO,IAAA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,MAAA,GAAY;AACR,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GAAmB;AACf,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,mCAAA,EAAsC,IAAA,CAAK,KAAK,CAAA,CAAE,CAAA;AAAA,EACtE;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,aAAA,EAAqB;AAC1B,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,aAAa,GAAA,EAA6B;AACtC,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAW,EAAA,EAAsD;AAC7D,IAAA,OAAO,EAAA,CAAG,KAAK,KAAK,CAAA;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,KAAA,EAAmB;AACxB,IAAA,OAAO,KAAK,KAAA,KAAU,KAAA;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA,EAKS,YAAY,MAAA,EAAsB;AACvC,IAAA,OAAO,KAAA;AAAA,EACX;AACJ;AAKO,SAAS,GAAM,KAAA,EAAiB;AACnC,EAAA,OAAO,IAAI,GAAG,KAAK,CAAA;AACvB","file":"chunk-GGEJTXXS.js","sourcesContent":["import type { Result } from '@/core/result';\nimport { ResultBase } from '@/core/result';\n\n/**\n * Represents a successful result containing a value.\n */\nexport class Ok<T> extends ResultBase<T, never> {\n    readonly _tag = 'ok' as const;\n    readonly isOk = true;\n    readonly isErr = false;\n\n    constructor(readonly value: T) {\n        super();\n    }\n\n    /**\n     * Maps the contained value using the provided function.\n     * Since this is `Ok`, the function is always applied.\n     */\n    map<U>(fn: (value: T) => U): Ok<U> {\n        return new Ok(fn(this.value));\n    }\n\n    /**\n     * Maps the error type, but since this is `Ok`, it's a no-op.\n     */\n    mapErr<F>(_fn: (error: never) => F): Ok<T> {\n        return this;\n    }\n\n    /**\n     * Returns the contained value.\n     */\n    unwrap(): T {\n        return this.value;\n    }\n\n    /**\n     * Throws an error since this is Ok, not Err.\n     */\n    unwrapErr(): never {\n        throw new Error(`Called unwrapErr() on an Ok value: ${this.value}`);\n    }\n\n    /**\n     * Returns the contained value, ignoring the default.\n     */\n    unwrapOr(_defaultValue: T): T {\n        return this.value;\n    }\n\n    /**\n     * Returns the contained value, ignoring the fallback function.\n     */\n    unwrapOrElse(_fn: (error: never) => T): T {\n        return this.value;\n    }\n\n    /**\n     * Applies the function to the contained value and returns the result.\n     */\n    andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never> {\n        return fn(this.value);\n    }\n\n    /**\n     * Checks if the contained value matches the provided value.\n     */\n    contains(value: T): boolean {\n        return this.value === value;\n    }\n\n    /**\n     * Always returns false since this is `Ok`, not `Err`.\n     */\n    override containsErr(_error: never): false {\n        return false;\n    }\n}\n\n/**\n * Creates a new `Ok` result with the given value.\n */\nexport function ok<T>(value: T): Ok<T> {\n    return new Ok(value);\n}\n"]}

package/dist/chunk-GLSQCN75.js

@@ -0,0 +1,75 @@
+import { ResultBase } from './chunk-D2DM2EYA.js';
+
+// src/core/err.ts
+var Err = class _Err extends ResultBase {
+  // eslint-disable-next-line node/handle-callback-err
+  constructor(error) {
+    super();
+    this.error = error;
+  }
+  _tag = "err";
+  isOk = false;
+  isErr = true;
+  /**
+   * Maps the value type, but since this is `Err`, it's a no-op.
+   */
+  map(_fn) {
+    return this;
+  }
+  /**
+   * Maps the contained error using the provided function.
+   * Since this is `Err`, the function is always applied.
+   */
+  mapErr(fn) {
+    return new _Err(fn(this.error));
+  }
+  /**
+   * Throws an error since this is `Err`, not `Ok`.
+   */
+  unwrap() {
+    throw new Error(`Called unwrap() on an Err value: ${this.error}`);
+  }
+  /**
+   * Returns the contained error.
+   */
+  unwrapErr() {
+    return this.error;
+  }
+  /**
+   * Returns the provided default value since this is `Err`.
+   */
+  unwrapOr(defaultValue) {
+    return defaultValue;
+  }
+  /**
+   * Computes and returns the fallback value using the provided function.
+   */
+  unwrapOrElse(fn) {
+    return fn(this.error);
+  }
+  /**
+   * Returns this `Err` unchanged since there's no value to chain.
+   */
+  andThen(_fn) {
+    return this;
+  }
+  /**
+   * Always returns false since this is `Err`, not `Ok`.
+   */
+  contains(_value) {
+    return false;
+  }
+  /**
+   * Checks if the contained error matches the provided error.
+   */
+  containsErr(error) {
+    return this.error === error;
+  }
+};
+function err(error) {
+  return new Err(error);
+}
+
+export { Err, err };
+//# sourceMappingURL=chunk-GLSQCN75.js.map
+//# sourceMappingURL=chunk-GLSQCN75.js.map

package/dist/chunk-GLSQCN75.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/err.ts"],"names":[],"mappings":";;;AAMO,IAAM,GAAA,GAAN,MAAM,IAAA,SAAe,UAAA,CAAqB;AAAA;AAAA,EAM7C,YAAqB,KAAA,EAAU;AAC3B,IAAA,KAAA,EAAM;AADW,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAErB;AAAA,EAPS,IAAA,GAAO,KAAA;AAAA,EACP,IAAA,GAAO,KAAA;AAAA,EACP,KAAA,GAAQ,IAAA;AAAA;AAAA;AAAA;AAAA,EAUjB,IAAO,GAAA,EAAkC;AACrC,IAAA,OAAO,IAAA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAU,EAAA,EAA6B;AACnC,IAAA,OAAO,IAAI,IAAA,CAAI,EAAA,CAAG,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAA,GAAgB;AACZ,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,iCAAA,EAAoC,IAAA,CAAK,KAAK,CAAA,CAAE,CAAA;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GAAe;AACX,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,SAAY,YAAA,EAAoB;AAC5B,IAAA,OAAO,YAAA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,aAAgB,EAAA,EAAwB;AACpC,IAAA,OAAO,EAAA,CAAG,KAAK,KAAK,CAAA;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAW,GAAA,EAA6C;AACpD,IAAA,OAAO,IAAA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,MAAA,EAAwB;AAC7B,IAAA,OAAO,KAAA;AAAA,EACX;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,KAAA,EAAmB;AAC3B,IAAA,OAAO,KAAK,KAAA,KAAU,KAAA;AAAA,EAC1B;AACJ;AAKO,SAAS,IAAO,KAAA,EAAkB;AACrC,EAAA,OAAO,IAAI,IAAI,KAAK,CAAA;AACxB","file":"chunk-GLSQCN75.js","sourcesContent":["import type { Result } from '@/core/result';\nimport { ResultBase } from '@/core/result';\n\n/**\n * Represents an error result containing an error value.\n */\nexport class Err<E> extends ResultBase<never, E> {\n    readonly _tag = 'err' as const;\n    readonly isOk = false;\n    readonly isErr = true;\n\n    // eslint-disable-next-line node/handle-callback-err\n    constructor(readonly error: E) {\n        super();\n    }\n\n    /**\n     * Maps the value type, but since this is `Err`, it's a no-op.\n     */\n    map<U>(_fn: (value: never) => U): Err<E> {\n        return this;\n    }\n\n    /**\n     * Maps the contained error using the provided function.\n     * Since this is `Err`, the function is always applied.\n     */\n    mapErr<F>(fn: (error: E) => F): Err<F> {\n        return new Err(fn(this.error));\n    }\n\n    /**\n     * Throws an error since this is `Err`, not `Ok`.\n     */\n    unwrap(): never {\n        throw new Error(`Called unwrap() on an Err value: ${this.error}`);\n    }\n\n    /**\n     * Returns the contained error.\n     */\n    unwrapErr(): E {\n        return this.error;\n    }\n\n    /**\n     * Returns the provided default value since this is `Err`.\n     */\n    unwrapOr<T>(defaultValue: T): T {\n        return defaultValue;\n    }\n\n    /**\n     * Computes and returns the fallback value using the provided function.\n     */\n    unwrapOrElse<T>(fn: (error: E) => T): T {\n        return fn(this.error);\n    }\n\n    /**\n     * Returns this `Err` unchanged since there's no value to chain.\n     */\n    andThen<U>(_fn: (value: never) => Result<U, E>): Err<E> {\n        return this;\n    }\n\n    /**\n     * Always returns false since this is `Err`, not `Ok`.\n     */\n    contains(_value: never): boolean {\n        return false;\n    }\n\n    /**\n     * Checks if the contained error matches the provided error.\n     */\n    containsErr(error: E): boolean {\n        return this.error === error;\n    }\n}\n\n/**\n * Creates a new `Err` result with the given error.\n */\nexport function err<E>(error: E): Err<E> {\n    return new Err(error);\n}\n"]}

package/dist/chunk-ITR7ZRJM.js

@@ -0,0 +1,17 @@
+import { err } from './chunk-GLSQCN75.js';
+import { ok } from './chunk-GGEJTXXS.js';
+
+// src/zod-wrapper/zod.ts
+function resultHandlerFromZod(schema) {
+  return (value) => {
+    const result = schema.safeParse(value);
+    if (result.success) {
+      return ok(result.data);
+    }
+    return err(result.error);
+  };
+}
+
+export { resultHandlerFromZod };
+//# sourceMappingURL=chunk-ITR7ZRJM.js.map
+//# sourceMappingURL=chunk-ITR7ZRJM.js.map

package/dist/chunk-ITR7ZRJM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/zod-wrapper/zod.ts"],"names":[],"mappings":";;;;AAIO,SAAS,qBAAwB,MAAA,EAAsB;AAC1D,EAAA,OAAO,CAAC,KAAA,KAA6C;AACjD,IAAA,MAAM,MAAA,GAAS,MAAA,CAAO,SAAA,CAAU,KAAK,CAAA;AACrC,IAAA,IAAI,OAAO,OAAA,EAAS;AAChB,MAAA,OAAO,EAAA,CAAG,OAAO,IAAI,CAAA;AAAA,IACzB;AACA,IAAA,OAAO,GAAA,CAAI,OAAO,KAAK,CAAA;AAAA,EAC3B,CAAA;AACJ","file":"chunk-ITR7ZRJM.js","sourcesContent":["import type z from 'zod';\nimport type { Result } from '@/core';\nimport { err, ok } from '@/core';\n\nexport function resultHandlerFromZod<T>(schema: z.ZodType<T>) {\n    return (value: unknown): Result<T, z.ZodError<T>> => {\n        const result = schema.safeParse(value);\n        if (result.success) {\n            return ok(result.data);\n        }\n        return err(result.error);\n    };\n}\n"]}

package/dist/chunk-SQ4P2HRX.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=chunk-SQ4P2HRX.js.map
+//# sourceMappingURL=chunk-SQ4P2HRX.js.map

package/dist/chunk-SQ4P2HRX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"chunk-SQ4P2HRX.js"}

package/dist/core/err.d.ts

@@ -1 +1 @@
-export { E as Err, e as err } from '../index-Dy6VGmoZ.js';
+export { Err, err } from './index.js';

package/dist/core/err.js

@@ -1,75 +1,4 @@
-import { ResultBase } from 'core/result';
-
-// src/core/err.ts
-var Err = class _Err extends ResultBase {
-  // eslint-disable-next-line node/handle-callback-err
-  constructor(error) {
-    super();
-    this.error = error;
-  }
-  _tag = "err";
-  isOk = false;
-  isErr = true;
-  /**
-   * Maps the value type, but since this is `Err`, it's a no-op.
-   */
-  map(_fn) {
-    return this;
-  }
-  /**
-   * Maps the contained error using the provided function.
-   * Since this is `Err`, the function is always applied.
-   */
-  mapErr(fn) {
-    return new _Err(fn(this.error));
-  }
-  /**
-   * Throws an error since this is `Err`, not `Ok`.
-   */
-  unwrap() {
-    throw new Error(`Called unwrap() on an Err value: ${this.error}`);
-  }
-  /**
-   * Returns the contained error.
-   */
-  unwrapErr() {
-    return this.error;
-  }
-  /**
-   * Returns the provided default value since this is `Err`.
-   */
-  unwrapOr(defaultValue) {
-    return defaultValue;
-  }
-  /**
-   * Computes and returns the fallback value using the provided function.
-   */
-  unwrapOrElse(fn) {
-    return fn(this.error);
-  }
-  /**
-   * Returns this `Err` unchanged since there's no value to chain.
-   */
-  andThen(_fn) {
-    return this;
-  }
-  /**
-   * Always returns false since this is `Err`, not `Ok`.
-   */
-  contains(_value) {
-    return false;
-  }
-  /**
-   * Checks if the contained error matches the provided error.
-   */
-  containsErr(error) {
-    return this.error === error;
-  }
-};
-function err(error) {
-  return new Err(error);
-}
-
-export { Err, err };
+export { Err, err } from '../chunk-GLSQCN75.js';
+import '../chunk-D2DM2EYA.js';
 //# sourceMappingURL=err.js.map
 //# sourceMappingURL=err.js.map

package/dist/core/err.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/err.ts"],"names":[],"mappings":";;;AAMO,IAAM,GAAA,GAAN,MAAM,IAAA,SAAe,UAAA,CAAqB;AAAA;AAAA,EAM/C,YAAqB,KAAA,EAAU;AAC7B,IAAA,KAAA,EAAM;AADa,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAErB;AAAA,EAPS,IAAA,GAAO,KAAA;AAAA,EACP,IAAA,GAAO,KAAA;AAAA,EACP,KAAA,GAAQ,IAAA;AAAA;AAAA;AAAA;AAAA,EAUjB,IAAO,GAAA,EAAkC;AACvC,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAU,EAAA,EAA6B;AACrC,IAAA,OAAO,IAAI,IAAA,CAAI,EAAA,CAAG,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAA,GAAgB;AACd,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,iCAAA,EAAoC,IAAA,CAAK,KAAK,CAAA,CAAE,CAAA;AAAA,EAClE;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GAAe;AACb,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,SAAY,YAAA,EAAoB;AAC9B,IAAA,OAAO,YAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,aAAgB,EAAA,EAAwB;AACtC,IAAA,OAAO,EAAA,CAAG,KAAK,KAAK,CAAA;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAW,GAAA,EAA6C;AACtD,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,MAAA,EAAwB;AAC/B,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,KAAA,EAAmB;AAC7B,IAAA,OAAO,KAAK,KAAA,KAAU,KAAA;AAAA,EACxB;AACF;AAKO,SAAS,IAAO,KAAA,EAAkB;AACvC,EAAA,OAAO,IAAI,IAAI,KAAK,CAAA;AACtB","file":"err.js","sourcesContent":["import type { Result } from 'core/result';\nimport { ResultBase } from 'core/result';\n\n/**\n * Represents an error result containing an error value.\n */\nexport class Err<E> extends ResultBase<never, E> {\n  readonly _tag = 'err' as const;\n  readonly isOk = false;\n  readonly isErr = true;\n\n  // eslint-disable-next-line node/handle-callback-err\n  constructor(readonly error: E) {\n    super();\n  }\n\n  /**\n   * Maps the value type, but since this is `Err`, it's a no-op.\n   */\n  map<U>(_fn: (value: never) => U): Err<E> {\n    return this;\n  }\n\n  /**\n   * Maps the contained error using the provided function.\n   * Since this is `Err`, the function is always applied.\n   */\n  mapErr<F>(fn: (error: E) => F): Err<F> {\n    return new Err(fn(this.error));\n  }\n\n  /**\n   * Throws an error since this is `Err`, not `Ok`.\n   */\n  unwrap(): never {\n    throw new Error(`Called unwrap() on an Err value: ${this.error}`);\n  }\n\n  /**\n   * Returns the contained error.\n   */\n  unwrapErr(): E {\n    return this.error;\n  }\n\n  /**\n   * Returns the provided default value since this is `Err`.\n   */\n  unwrapOr<T>(defaultValue: T): T {\n    return defaultValue;\n  }\n\n  /**\n   * Computes and returns the fallback value using the provided function.\n   */\n  unwrapOrElse<T>(fn: (error: E) => T): T {\n    return fn(this.error);\n  }\n\n  /**\n   * Returns this `Err` unchanged since there's no value to chain.\n   */\n  andThen<U>(_fn: (value: never) => Result<U, E>): Err<E> {\n    return this;\n  }\n\n  /**\n   * Always returns false since this is `Err`, not `Ok`.\n   */\n  contains(_value: never): boolean {\n    return false;\n  }\n\n  /**\n   * Checks if the contained error matches the provided error.\n   */\n  containsErr(error: E): boolean {\n    return this.error === error;\n  }\n}\n\n/**\n * Creates a new `Err` result with the given error.\n */\nexport function err<E>(error: E): Err<E> {\n  return new Err(error);\n}\n"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"err.js"}

package/dist/core/index.d.ts

@@ -1 +1,169 @@
-export { A as AsyncResult, E as Err, O as Ok, a as Result, e as err, o as ok } from '../index-Dy6VGmoZ.js';
+/**
+ * Represents an error result containing an error value.
+ */
+declare class Err<E> extends ResultBase<never, E> {
+    readonly error: E;
+    readonly _tag: "err";
+    readonly isOk = false;
+    readonly isErr = true;
+    constructor(error: E);
+    /**
+     * Maps the value type, but since this is `Err`, it's a no-op.
+     */
+    map<U>(_fn: (value: never) => U): Err<E>;
+    /**
+     * Maps the contained error using the provided function.
+     * Since this is `Err`, the function is always applied.
+     */
+    mapErr<F>(fn: (error: E) => F): Err<F>;
+    /**
+     * Throws an error since this is `Err`, not `Ok`.
+     */
+    unwrap(): never;
+    /**
+     * Returns the contained error.
+     */
+    unwrapErr(): E;
+    /**
+     * Returns the provided default value since this is `Err`.
+     */
+    unwrapOr<T>(defaultValue: T): T;
+    /**
+     * Computes and returns the fallback value using the provided function.
+     */
+    unwrapOrElse<T>(fn: (error: E) => T): T;
+    /**
+     * Returns this `Err` unchanged since there's no value to chain.
+     */
+    andThen<U>(_fn: (value: never) => Result<U, E>): Err<E>;
+    /**
+     * Always returns false since this is `Err`, not `Ok`.
+     */
+    contains(_value: never): boolean;
+    /**
+     * Checks if the contained error matches the provided error.
+     */
+    containsErr(error: E): boolean;
+}
+/**
+ * Creates a new `Err` result with the given error.
+ */
+declare function err<E>(error: E): Err<E>;
+
+/**
+ * Represents a successful result containing a value.
+ */
+declare class Ok<T> extends ResultBase<T, never> {
+    readonly value: T;
+    readonly _tag: "ok";
+    readonly isOk = true;
+    readonly isErr = false;
+    constructor(value: T);
+    /**
+     * Maps the contained value using the provided function.
+     * Since this is `Ok`, the function is always applied.
+     */
+    map<U>(fn: (value: T) => U): Ok<U>;
+    /**
+     * Maps the error type, but since this is `Ok`, it's a no-op.
+     */
+    mapErr<F>(_fn: (error: never) => F): Ok<T>;
+    /**
+     * Returns the contained value.
+     */
+    unwrap(): T;
+    /**
+     * Throws an error since this is Ok, not Err.
+     */
+    unwrapErr(): never;
+    /**
+     * Returns the contained value, ignoring the default.
+     */
+    unwrapOr(_defaultValue: T): T;
+    /**
+     * Returns the contained value, ignoring the fallback function.
+     */
+    unwrapOrElse(_fn: (error: never) => T): T;
+    /**
+     * Applies the function to the contained value and returns the result.
+     */
+    andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never>;
+    /**
+     * Checks if the contained value matches the provided value.
+     */
+    contains(value: T): boolean;
+    /**
+     * Always returns false since this is `Ok`, not `Err`.
+     */
+    containsErr(_error: never): false;
+}
+/**
+ * Creates a new `Ok` result with the given value.
+ */
+declare function ok<T>(value: T): Ok<T>;
+
+/**
+ * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).
+ * This is an abstract base class that provides common functionality for both variants.
+ */
+declare abstract class ResultBase<T, E> {
+    /**
+     * Type guard to check if the result is an `Ok` variant.
+     */
+    abstract readonly isOk: boolean;
+    /**
+     * Type guard to check if the result is an `Err` variant.
+     */
+    abstract readonly isErr: boolean;
+    /**
+     * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,
+     * leaving an `Err` value untouched.
+     */
+    abstract map<U>(fn: (value: T) => U): Result<U, E>;
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,
+     * leaving an `Ok` value untouched.
+     */
+    abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;
+    /**
+     * Returns the contained `Ok` value, consuming the self value.
+     * Throws an error if the result is `Err`.
+     */
+    abstract unwrap(): T;
+    /**
+     * Returns the contained `Err` value, consuming the self value.
+     * Throws an error if the result is Ok.
+     */
+    abstract unwrapErr(): E;
+    /**
+     * Returns the contained `Ok` value or a provided default.
+     */
+    abstract unwrapOr(defaultValue: T): T;
+    /**
+     * Returns the contained `Ok` value or computes it from a closure.
+     */
+    abstract unwrapOrElse(fn: (error: E) => T): T;
+    /**
+     * Calls the provided function with the contained value and returns the result.
+     * If the result is `Err`, the function is not called and the `Err` is returned.
+     */
+    abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
+    /**
+     * Returns true if the result is `Ok` and the value inside of it matches a predicate.
+     */
+    abstract contains(value: T): boolean;
+    /**
+     * Returns true if the result is `Err` and the error inside of it matches a predicate.
+     */
+    abstract containsErr(error: E): boolean;
+}
+/**
+ * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.
+ */
+type Result<T, E> = Ok<T> | Err<E>;
+/**
+ * Type alias for an async `Result` (Promise-wrapped `Result`).
+ */
+type AsyncResult<T, E> = Promise<Result<T, E>>;
+
+export { type AsyncResult, Err, Ok, type Result, ResultBase, err, ok };

package/dist/core/index.js

@@ -1,4 +1,6 @@
-export { Err, err } from 'core/err';
-export { Ok, ok } from 'core/ok';
+import '../chunk-SQ4P2HRX.js';
+export { Err, err } from '../chunk-GLSQCN75.js';
+export { Ok, ok } from '../chunk-GGEJTXXS.js';
+import '../chunk-D2DM2EYA.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/core/index.js.map

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

package/dist/core/ok.d.ts

@@ -1 +1 @@
-export { O as Ok, o as ok } from '../index-Dy6VGmoZ.js';
+export { Ok, ok } from './index.js';

package/dist/core/ok.js

@@ -1,74 +1,4 @@
-import { ResultBase } from 'core/result';
-
-// src/core/ok.ts
-var Ok = class _Ok extends ResultBase {
-  constructor(value) {
-    super();
-    this.value = value;
-  }
-  _tag = "ok";
-  isOk = true;
-  isErr = false;
-  /**
-   * Maps the contained value using the provided function.
-   * Since this is `Ok`, the function is always applied.
-   */
-  map(fn) {
-    return new _Ok(fn(this.value));
-  }
-  /**
-   * Maps the error type, but since this is `Ok`, it's a no-op.
-   */
-  mapErr(_fn) {
-    return this;
-  }
-  /**
-   * Returns the contained value.
-   */
-  unwrap() {
-    return this.value;
-  }
-  /**
-   * Throws an error since this is Ok, not Err.
-   */
-  unwrapErr() {
-    throw new Error(`Called unwrapErr() on an Ok value: ${this.value}`);
-  }
-  /**
-   * Returns the contained value, ignoring the default.
-   */
-  unwrapOr(_defaultValue) {
-    return this.value;
-  }
-  /**
-   * Returns the contained value, ignoring the fallback function.
-   */
-  unwrapOrElse(_fn) {
-    return this.value;
-  }
-  /**
-   * Applies the function to the contained value and returns the result.
-   */
-  andThen(fn) {
-    return fn(this.value);
-  }
-  /**
-   * Checks if the contained value matches the provided value.
-   */
-  contains(value) {
-    return this.value === value;
-  }
-  /**
-   * Always returns false since this is `Ok`, not `Err`.
-   */
-  containsErr(_error) {
-    return false;
-  }
-};
-function ok(value) {
-  return new Ok(value);
-}
-
-export { Ok, ok };
+export { Ok, ok } from '../chunk-GGEJTXXS.js';
+import '../chunk-D2DM2EYA.js';
 //# sourceMappingURL=ok.js.map
 //# sourceMappingURL=ok.js.map

package/dist/core/ok.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/ok.ts"],"names":[],"mappings":";;;AAMO,IAAM,EAAA,GAAN,MAAM,GAAA,SAAc,UAAA,CAAqB;AAAA,EAK9C,YAAqB,KAAA,EAAU;AAC7B,IAAA,KAAA,EAAM;AADa,IAAA,IAAA,CAAA,KAAA,GAAA,KAAA;AAAA,EAErB;AAAA,EANS,IAAA,GAAO,IAAA;AAAA,EACP,IAAA,GAAO,IAAA;AAAA,EACP,KAAA,GAAQ,KAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUjB,IAAO,EAAA,EAA4B;AACjC,IAAA,OAAO,IAAI,GAAA,CAAG,EAAA,CAAG,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA,EAKA,OAAU,GAAA,EAAiC;AACzC,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAA,GAAY;AACV,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,SAAA,GAAmB;AACjB,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,mCAAA,EAAsC,IAAA,CAAK,KAAK,CAAA,CAAE,CAAA;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,aAAA,EAAqB;AAC5B,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,aAAa,GAAA,EAA6B;AACxC,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,QAAW,EAAA,EAAsD;AAC/D,IAAA,OAAO,EAAA,CAAG,KAAK,KAAK,CAAA;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA,EAKA,SAAS,KAAA,EAAmB;AAC1B,IAAA,OAAO,KAAK,KAAA,KAAU,KAAA;AAAA,EACxB;AAAA;AAAA;AAAA;AAAA,EAKS,YAAY,MAAA,EAAsB;AACzC,IAAA,OAAO,KAAA;AAAA,EACT;AACF;AAKO,SAAS,GAAM,KAAA,EAAiB;AACrC,EAAA,OAAO,IAAI,GAAG,KAAK,CAAA;AACrB","file":"ok.js","sourcesContent":["import type { Result } from 'core/result';\nimport { ResultBase } from 'core/result';\n\n/**\n * Represents a successful result containing a value.\n */\nexport class Ok<T> extends ResultBase<T, never> {\n  readonly _tag = 'ok' as const;\n  readonly isOk = true;\n  readonly isErr = false;\n\n  constructor(readonly value: T) {\n    super();\n  }\n\n  /**\n   * Maps the contained value using the provided function.\n   * Since this is `Ok`, the function is always applied.\n   */\n  map<U>(fn: (value: T) => U): Ok<U> {\n    return new Ok(fn(this.value));\n  }\n\n  /**\n   * Maps the error type, but since this is `Ok`, it's a no-op.\n   */\n  mapErr<F>(_fn: (error: never) => F): Ok<T> {\n    return this;\n  }\n\n  /**\n   * Returns the contained value.\n   */\n  unwrap(): T {\n    return this.value;\n  }\n\n  /**\n   * Throws an error since this is Ok, not Err.\n   */\n  unwrapErr(): never {\n    throw new Error(`Called unwrapErr() on an Ok value: ${this.value}`);\n  }\n\n  /**\n   * Returns the contained value, ignoring the default.\n   */\n  unwrapOr(_defaultValue: T): T {\n    return this.value;\n  }\n\n  /**\n   * Returns the contained value, ignoring the fallback function.\n   */\n  unwrapOrElse(_fn: (error: never) => T): T {\n    return this.value;\n  }\n\n  /**\n   * Applies the function to the contained value and returns the result.\n   */\n  andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never> {\n    return fn(this.value);\n  }\n\n  /**\n   * Checks if the contained value matches the provided value.\n   */\n  contains(value: T): boolean {\n    return this.value === value;\n  }\n\n  /**\n   * Always returns false since this is `Ok`, not `Err`.\n   */\n  override containsErr(_error: never): false {\n    return false;\n  }\n}\n\n/**\n * Creates a new `Ok` result with the given value.\n */\nexport function ok<T>(value: T): Ok<T> {\n  return new Ok(value);\n}\n"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ok.js"}

package/dist/core/result.d.ts

@@ -1 +1 @@
-export { A as AsyncResult, a as Result, R as ResultBase } from '../index-Dy6VGmoZ.js';
+export { AsyncResult, Result, ResultBase } from './index.js';

package/dist/core/result.js

@@ -1,7 +1,3 @@
-// src/core/result.ts
-var ResultBase = class {
-};
-
-export { ResultBase };
+export { ResultBase } from '../chunk-D2DM2EYA.js';
 //# sourceMappingURL=result.js.map
 //# sourceMappingURL=result.js.map

package/dist/core/result.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/result.ts"],"names":[],"mappings":";AAOO,IAAe,aAAf,MAAgC;AA4DvC","file":"result.js","sourcesContent":["import type { Err } from 'core/err';\nimport type { Ok } from 'core/ok';\n\n/**\n * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).\n * This is an abstract base class that provides common functionality for both variants.\n */\nexport abstract class ResultBase<T, E> {\n  /**\n   * Type guard to check if the result is an `Ok` variant.\n   */\n  abstract readonly isOk: boolean;\n\n  /**\n   * Type guard to check if the result is an `Err` variant.\n   */\n  abstract readonly isErr: boolean;\n\n  /**\n   * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,\n   * leaving an `Err` value untouched.\n   */\n  abstract map<U>(fn: (value: T) => U): Result<U, E>;\n\n  /**\n   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,\n   * leaving an `Ok` value untouched.\n   */\n  abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;\n\n  /**\n   * Returns the contained `Ok` value, consuming the self value.\n   * Throws an error if the result is `Err`.\n   */\n  abstract unwrap(): T;\n\n  /**\n   * Returns the contained `Err` value, consuming the self value.\n   * Throws an error if the result is Ok.\n   */\n  abstract unwrapErr(): E;\n\n  /**\n   * Returns the contained `Ok` value or a provided default.\n   */\n  abstract unwrapOr(defaultValue: T): T;\n\n  /**\n   * Returns the contained `Ok` value or computes it from a closure.\n   */\n  abstract unwrapOrElse(fn: (error: E) => T): T;\n\n  /**\n   * Calls the provided function with the contained value and returns the result.\n   * If the result is `Err`, the function is not called and the `Err` is returned.\n   */\n  abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;\n\n  /**\n   * Returns true if the result is `Ok` and the value inside of it matches a predicate.\n   */\n  abstract contains(value: T): boolean;\n\n  /**\n   * Returns true if the result is `Err` and the error inside of it matches a predicate.\n   */\n  abstract containsErr(error: E): boolean;\n}\n\n/**\n * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.\n */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/**\n * Type alias for an async `Result` (Promise-wrapped `Result`).\n */\nexport type AsyncResult<T, E> = Promise<Result<T, E>>;\n"]}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"result.js"}

package/dist/zod-wrapper/index.d.ts

@@ -0,0 +1,3 @@
+export { resultHandlerFromZod } from './zod.js';
+import 'zod';
+import '../core/index.js';

package/dist/zod-wrapper/index.js

@@ -0,0 +1,7 @@
+export { resultHandlerFromZod } from '../chunk-ITR7ZRJM.js';
+import '../chunk-SQ4P2HRX.js';
+import '../chunk-GLSQCN75.js';
+import '../chunk-GGEJTXXS.js';
+import '../chunk-D2DM2EYA.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/zod-wrapper/index.js.map

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

package/dist/zod-wrapper/zod.d.ts

@@ -0,0 +1,6 @@
+import z from 'zod';
+import { Result } from '../core/index.js';
+
+declare function resultHandlerFromZod<T>(schema: z.ZodType<T>): (value: unknown) => Result<T, z.ZodError<T>>;
+
+export { resultHandlerFromZod };

package/dist/zod-wrapper/zod.js

@@ -0,0 +1,7 @@
+export { resultHandlerFromZod } from '../chunk-ITR7ZRJM.js';
+import '../chunk-SQ4P2HRX.js';
+import '../chunk-GLSQCN75.js';
+import '../chunk-GGEJTXXS.js';
+import '../chunk-D2DM2EYA.js';
+//# sourceMappingURL=zod.js.map
+//# sourceMappingURL=zod.js.map

package/dist/zod-wrapper/zod.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"zod.js"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "resultfier",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A TypeScript implementation of Rust-like Result type for better error handling",
   "author": "Vitor Koch <vitorgabrielkoch@gmail.com>",
   "license": "MIT",
@@ -18,14 +18,26 @@
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.js"
     },
-    "./extra": {
-      "types": "./dist/extra/index.d.ts",
-      "import": "./dist/extra/index.js"
+    "./action": {
+      "types": "./dist/action/index.d.ts",
+      "import": "./dist/action/index.js"
+    },
+    "./zod": {
+      "types": "./dist/zod-wrapper/zod.d.ts",
+      "import": "./dist/zod-wrapper/zod.js"
     }
   },
   "main": "./dist/core/index.js",
   "module": "./dist/core/index.js",
   "types": "./dist/core/index.d.ts",
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@antfu/eslint-config": "^5.4.1",
     "@changesets/cli": "^2.29.7",

package/dist/extra/action.js

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=action.js.map
-//# sourceMappingURL=action.js.map

package/dist/extra/index.js

@@ -1,3 +0,0 @@
-export * from 'extra/action';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/index-Dy6VGmoZ.d.ts

@@ -1,169 +0,0 @@
-/**
- * Represents a successful result containing a value.
- */
-declare class Ok<T> extends ResultBase<T, never> {
-    readonly value: T;
-    readonly _tag: "ok";
-    readonly isOk = true;
-    readonly isErr = false;
-    constructor(value: T);
-    /**
-     * Maps the contained value using the provided function.
-     * Since this is `Ok`, the function is always applied.
-     */
-    map<U>(fn: (value: T) => U): Ok<U>;
-    /**
-     * Maps the error type, but since this is `Ok`, it's a no-op.
-     */
-    mapErr<F>(_fn: (error: never) => F): Ok<T>;
-    /**
-     * Returns the contained value.
-     */
-    unwrap(): T;
-    /**
-     * Throws an error since this is Ok, not Err.
-     */
-    unwrapErr(): never;
-    /**
-     * Returns the contained value, ignoring the default.
-     */
-    unwrapOr(_defaultValue: T): T;
-    /**
-     * Returns the contained value, ignoring the fallback function.
-     */
-    unwrapOrElse(_fn: (error: never) => T): T;
-    /**
-     * Applies the function to the contained value and returns the result.
-     */
-    andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never>;
-    /**
-     * Checks if the contained value matches the provided value.
-     */
-    contains(value: T): boolean;
-    /**
-     * Always returns false since this is `Ok`, not `Err`.
-     */
-    containsErr(_error: never): false;
-}
-/**
- * Creates a new `Ok` result with the given value.
- */
-declare function ok<T>(value: T): Ok<T>;
-
-/**
- * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).
- * This is an abstract base class that provides common functionality for both variants.
- */
-declare abstract class ResultBase<T, E> {
-    /**
-     * Type guard to check if the result is an `Ok` variant.
-     */
-    abstract readonly isOk: boolean;
-    /**
-     * Type guard to check if the result is an `Err` variant.
-     */
-    abstract readonly isErr: boolean;
-    /**
-     * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,
-     * leaving an `Err` value untouched.
-     */
-    abstract map<U>(fn: (value: T) => U): Result<U, E>;
-    /**
-     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,
-     * leaving an `Ok` value untouched.
-     */
-    abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;
-    /**
-     * Returns the contained `Ok` value, consuming the self value.
-     * Throws an error if the result is `Err`.
-     */
-    abstract unwrap(): T;
-    /**
-     * Returns the contained `Err` value, consuming the self value.
-     * Throws an error if the result is Ok.
-     */
-    abstract unwrapErr(): E;
-    /**
-     * Returns the contained `Ok` value or a provided default.
-     */
-    abstract unwrapOr(defaultValue: T): T;
-    /**
-     * Returns the contained `Ok` value or computes it from a closure.
-     */
-    abstract unwrapOrElse(fn: (error: E) => T): T;
-    /**
-     * Calls the provided function with the contained value and returns the result.
-     * If the result is `Err`, the function is not called and the `Err` is returned.
-     */
-    abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
-    /**
-     * Returns true if the result is `Ok` and the value inside of it matches a predicate.
-     */
-    abstract contains(value: T): boolean;
-    /**
-     * Returns true if the result is `Err` and the error inside of it matches a predicate.
-     */
-    abstract containsErr(error: E): boolean;
-}
-/**
- * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.
- */
-type Result<T, E> = Ok<T> | Err<E>;
-/**
- * Type alias for an async `Result` (Promise-wrapped `Result`).
- */
-type AsyncResult<T, E> = Promise<Result<T, E>>;
-
-/**
- * Represents an error result containing an error value.
- */
-declare class Err<E> extends ResultBase<never, E> {
-    readonly error: E;
-    readonly _tag: "err";
-    readonly isOk = false;
-    readonly isErr = true;
-    constructor(error: E);
-    /**
-     * Maps the value type, but since this is `Err`, it's a no-op.
-     */
-    map<U>(_fn: (value: never) => U): Err<E>;
-    /**
-     * Maps the contained error using the provided function.
-     * Since this is `Err`, the function is always applied.
-     */
-    mapErr<F>(fn: (error: E) => F): Err<F>;
-    /**
-     * Throws an error since this is `Err`, not `Ok`.
-     */
-    unwrap(): never;
-    /**
-     * Returns the contained error.
-     */
-    unwrapErr(): E;
-    /**
-     * Returns the provided default value since this is `Err`.
-     */
-    unwrapOr<T>(defaultValue: T): T;
-    /**
-     * Computes and returns the fallback value using the provided function.
-     */
-    unwrapOrElse<T>(fn: (error: E) => T): T;
-    /**
-     * Returns this `Err` unchanged since there's no value to chain.
-     */
-    andThen<U>(_fn: (value: never) => Result<U, E>): Err<E>;
-    /**
-     * Always returns false since this is `Err`, not `Ok`.
-     */
-    contains(_value: never): boolean;
-    /**
-     * Checks if the contained error matches the provided error.
-     */
-    containsErr(error: E): boolean;
-}
-/**
- * Creates a new `Err` result with the given error.
- */
-declare function err<E>(error: E): Err<E>;
-
-export { type AsyncResult as A, Err as E, Ok as O, ResultBase as R, type Result as a, err as e, ok as o };

package/eslint.config.mjs

@@ -1,10 +0,0 @@
-import antfu from '@antfu/eslint-config';
-
-export default antfu({
-  type: 'lib',
-  stylistic: {
-    semi: true,
-    quotes: 'single',
-  },
-  typescript: true,
-});

package/mise.toml

@@ -1,2 +0,0 @@
-[tools]
-node = "24"

package/pnpm-workspace.yaml

@@ -1,2 +0,0 @@
-onlyBuiltDependencies:
-  - esbuild