resultfier 0.4.0 → 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Vitor Koch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1 +1,48 @@
 # resultfier
+
+A TypeScript/JavaScript library that brings Rust's `Result<T, E>` type to your projects. Provides robust error handling with type safety and functional programming patterns.
+
+## Features
+
+- 🦀 Rust-inspired `Result<T, E>` type
+- 🛡️ Type-safe error handling
+- ⚡ Zero dependencies
+- 🔄 Functional programming methods (map, andThen, etc.)
+- 📦 TypeScript-first with full type support
+- 🎯 Simple and intuitive API
+
+## Installation
+
+```bash
+npm install @vikoch/resultfier
+# or
+yarn add @vikoch/resultfier
+# or
+bun add @vikoch/resultfier
+```
+
+## Quick Start
+
+```typescript
+import type { Result } from '@vikoch/resultfier'
+import { err, ok } from '@vikoch/resultfier'
+
+function divide(a: number, b: number): Result<number, string> {
+	if (b === 0) {
+		return err('Cannot divide by zero')
+	}
+	return ok(a / b)
+}
+
+const result = divide(10, 2)
+
+// Type Narrowing
+if (result.isOk) {
+	console.log('Result:', result.value) // 5
+	// ^? Ok<number>
+}
+else {
+	console.log('Error:', result.error) // Cannot divide by zero
+	// ^? Err<string>
+}
+```

package/dist/action/index.d.mts

@@ -0,0 +1,6 @@
+import { t as AsyncResult } from "../result-DIdNM9rp.mjs";
+
+//#region src/action/action.d.ts
+type AsyncAction<TData, TError, TParams = null> = (params: TParams extends null ? void : TParams) => AsyncResult<TData, TError>;
+//#endregion
+export { type AsyncAction };

package/dist/action/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/core/index.mjs

@@ -0,0 +1,2 @@
+import { a as err, i as Err, n as Ok, r as ok, t as toAsyncResult } from "../core-BdRFoSfb.mjs";
+export { Err, Ok, err, ok, toAsyncResult };

package/dist/core-BdRFoSfb.mjs

@@ -0,0 +1,101 @@
+var ResultBase = class {};
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+var Err = class Err extends ResultBase {
+	constructor(error) {
+		super();
+		this.error = error;
+		_defineProperty(this, "_tag", "err");
+		_defineProperty(this, "isOk", false);
+		_defineProperty(this, "isErr", true);
+	}
+	map(_fn) {
+		return this;
+	}
+	mapErr(fn) {
+		return new Err(fn(this.error));
+	}
+	valueOr(defaultValue) {
+		return defaultValue;
+	}
+	valueOrElse(fn) {
+		return fn(this.error);
+	}
+	andThen(_fn) {
+		return this;
+	}
+	contains(_value) {
+		return false;
+	}
+	containsErr(error) {
+		return this.error === error;
+	}
+};
+function err(error) {
+	return new Err(error);
+}
+var Ok = class Ok extends ResultBase {
+	constructor(value) {
+		super();
+		this.value = value;
+		_defineProperty(this, "_tag", "ok");
+		_defineProperty(this, "isOk", true);
+		_defineProperty(this, "isErr", false);
+	}
+	map(fn) {
+		return new Ok(fn(this.value));
+	}
+	mapErr(_fn) {
+		return this;
+	}
+	valueOr(_defaultValue) {
+		return this.value;
+	}
+	valueOrElse(_fn) {
+		return this.value;
+	}
+	andThen(fn) {
+		return fn(this.value);
+	}
+	contains(value) {
+		return this.value === value;
+	}
+	containsErr(_error) {
+		return false;
+	}
+};
+function ok(value) {
+	return new Ok(value);
+}
+async function toAsyncResult(callback) {
+	return Promise.resolve(callback()).then((value) => ok(value)).catch((error) => err(error));
+}
+export { err as a, Err as i, Ok as n, ok as r, toAsyncResult as t };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { a as ok, i as Ok, n as Result, o as Err, r as ResultBase, s as err, t as AsyncResult } from "./result-DIdNM9rp.mjs";
+
+//#region src/core/utils.d.ts
+declare function toAsyncResult<T, E>(callback: () => Promise<T> | T): AsyncResult<T, E>;
+//#endregion
+export { AsyncResult, Err, Ok, Result, ResultBase, err, ok, toAsyncResult };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { a as err, i as Err, n as Ok, r as ok, t as toAsyncResult } from "./core-BdRFoSfb.mjs";
+export { Err, Ok, err, ok, toAsyncResult };

package/dist/result-DIdNM9rp.d.mts

@@ -0,0 +1,147 @@
+//#region src/core/err.d.ts
+
+/**
+ * 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>;
+  /**
+   * Returns the provided default value since this is `Err`.
+   */
+  valueOr<T>(defaultValue: T): T;
+  /**
+   * Computes and returns the fallback value using the provided function.
+   */
+  valueOrElse<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>;
+//#endregion
+//#region src/core/ok.d.ts
+/**
+ * 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, ignoring the default.
+   */
+  valueOr(_defaultValue: T): T;
+  /**
+   * Returns the contained value, ignoring the fallback function.
+   */
+  valueOrElse(_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>;
+//#endregion
+//#region src/core/result.d.ts
+/**
+ * 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 or a provided default.
+   */
+  abstract valueOr(defaultValue: T): T;
+  /**
+   * Returns the contained `Ok` value or computes it from a closure.
+   */
+  abstract valueOrElse(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>>;
+//#endregion
+export { ok as a, Ok as i, Result as n, Err as o, ResultBase as r, err as s, AsyncResult as t };

package/package.json

@@ -1,54 +1,43 @@
 {
-  "name": "resultfier",
-  "type": "module",
-  "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",
-  "homepage": "https://github.com/vitorkoch/resultfier#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vitorkoch/resultfier.git"
-  },
-  "bugs": {
-    "url": "https://github.com/vitorkoch/resultfier/issues"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core/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",
-    "@types/bun": "latest",
-    "eslint": "^9.36.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
-  },
-  "scripts": {
-    "build": "tsup",
-    "lint": "eslint",
-    "lint:fix": "eslint --fix"
-  }
-}
+	"name": "resultfier",
+	"type": "module",
+	"version": "3.0.0",
+	"private": "false",
+	"packageManager": "bun@1.3.5",
+	"description": "A TypeScript/JavaScript library that brings Rust's Result<T, E> type for robust error handling",
+	"author": "Vitor Koch",
+	"license": "MIT",
+	"keywords": ["rust", "error handling", "result", "typescript"],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.mts",
+			"import": "./dist/index.mjs"
+		},
+		"./core": {
+			"types": "./dist/core/index.d.mts",
+			"import": "./dist/core/index.mjs"
+		},
+		"./action": {
+			"types": "./dist/action/index.d.mts",
+			"import": "./dist/action/index.mjs"
+		}
+	},
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.mts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"lint": "eslint",
+		"lint:fix": "eslint --fix",
+		"build": "tsdown",
+		"prepublishOnly": "npm run build"
+	},
+	"devDependencies": {
+		"@antfu/eslint-config": "^6.7.3",
+		"eslint": "^9.39.2",
+		"eslint-plugin-format": "^1.1.0",
+		"tsdown": "^0.18.2"
+	}
+}

package/.changeset/config.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
-  "changelog": "@changesets/cli/changelog",
-  "commit": true,
-  "fixed": [],
-  "linked": [],
-  "access": "public",
-  "baseBranch": "main",
-  "updateInternalDependencies": "patch",
-  "ignore": []
-}

package/CHANGELOG.md

@@ -1,31 +0,0 @@
-# resultfier
-
-## 0.4.0
-
-### Minor Changes
-
-- 2f11d84: add zod integration and reorganize the project
-
-## 0.3.0
-
-### Minor Changes
-
-- 7d5a07f: remove deprecated 'isOk' and 'isError' and add new module 'extra' with Action type
-
-## 0.2.0
-
-### Minor Changes
-
-- 1575817: fix exports
-
-## 0.1.1
-
-### Patch Changes
-
-- fix resolution bug
-
-## 0.1.0
-
-### Minor Changes
-
-- first release

package/dist/action/action.d.ts

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

package/dist/action/action.js

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

package/dist/action/action.js.map

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

package/dist/action/index.d.ts

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

package/dist/action/index.js

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

package/dist/action/index.js.map

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

package/dist/chunk-7CTLLC5F.js

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

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

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

package/dist/chunk-D2DM2EYA.js

@@ -1,7 +0,0 @@
-// 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

@@ -1 +0,0 @@
-{"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

@@ -1,74 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,75 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,17 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

package/dist/chunk-SQ4P2HRX.js.map

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

package/dist/core/err.d.ts

@@ -1 +0,0 @@
-export { Err, err } from './index.js';

package/dist/core/err.js

@@ -1,4 +0,0 @@
-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 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"err.js"}

package/dist/core/index.d.ts

@@ -1,169 +0,0 @@
-/**
- * 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,6 +0,0 @@
-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 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/core/ok.d.ts

@@ -1 +0,0 @@
-export { Ok, ok } from './index.js';

package/dist/core/ok.js

@@ -1,4 +0,0 @@
-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 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"ok.js"}

package/dist/core/result.d.ts

@@ -1 +0,0 @@
-export { AsyncResult, Result, ResultBase } from './index.js';

package/dist/core/result.js

@@ -1,3 +0,0 @@
-export { ResultBase } from '../chunk-D2DM2EYA.js';
-//# sourceMappingURL=result.js.map
-//# sourceMappingURL=result.js.map

package/dist/core/result.js.map

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

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

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

package/dist/zod-wrapper/index.js

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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