@pithos/core 2.0.0

package/dist/zygos/result/result.js

@@ -0,0 +1,438 @@
+/**
+ * Micro implementation of Neverthrow's Result type.
+ *
+ * This is a lightweight alternative to Neverthrow 8.2.0 that is:
+ * - 8x smaller (~0.79KB vs ~6.62KB from Neverthrow 8.2.0)
+ * - 100% API compatible with Neverthrow 8.2.0 - can be seamlessly replaced without code changes
+ * - Zero `any` types for better type safety
+ *
+ * This module provides a lightweight implementation of the Result monad pattern,
+ * offering a type-safe way to handle operations that can either succeed or fail.
+ * All functions are tree-shakable and framework-agnostic.
+ *
+ * Features:
+ * - Zero `any` types for maximum type safety
+ * - Full TypeScript 5 support with modern syntax
+ * - Comprehensive error handling and chaining
+ *
+ * @example
+ * ```typescript
+ * import { ok, err, Result } from './result';
+ *
+ * // Success case
+ * const success: Result<number, string> = ok(42);
+ * if (success.isOk()) {
+ *   console.log(success.value); // 42
+ * }
+ *
+ * // Error case
+ * const failure: Result<number, string> = err("Invalid input");
+ * if (failure.isErr()) {
+ *   console.log(failure.error); // "Invalid input"
+ * }
+ * ```
+ *
+ * @since 1.1.0
+ */
+import { isSomeOption } from "../../arkhe/types/utilities/is-some-option";
+/**
+ * Represents a successful result containing a value.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value (unused in Ok)
+ * @since 2.0.0
+ */
+export class Ok {
+    /**
+     * Creates a new Ok result.
+     *
+     * @param value - The success value to wrap
+     */
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Always returns true for Ok instances.
+     *
+     * @returns `true`
+     */
+    isOk() {
+        return true;
+    }
+    /**
+     * Always returns false for Ok instances.
+     * Optimized to return the constant value directly.
+     *
+     * @returns `false`
+     */
+    isErr() {
+        return false;
+    }
+    /**
+     * Transforms the success value using the provided function.
+     *
+     * @template A - The type of the transformed value
+     * @param f - Function to transform the success value
+     * @returns A new Ok result with the transformed value
+     */
+    map(f) {
+        return ok(f(this.value));
+    }
+    /**
+     * No-op for Ok instances - the error transformation function is ignored.
+     *
+     * @template U - The type of the transformed error (unused)
+     * @param _f - Error transformation function (ignored)
+     * @returns A new Ok result with the original value
+     */
+    mapErr(_f) {
+        return ok(this.value);
+    }
+    andThen(f) {
+        return f(this.value);
+    }
+    /**
+     * Always returns the success value for Ok instances.
+     *
+     * @template A - The type of the default value (unused)
+     * @param _v - Default value (ignored)
+     * @returns The success value
+     */
+    unwrapOr(_v) {
+        return this.value;
+    }
+    /**
+     * Executes the success function with the success value.
+     *
+     * @template A - The return type for the success case
+     * @template B - The return type for the error case (unused)
+     * @param ok - Function to execute with the success value
+     * @param _err - Error function (ignored)
+     * @returns The result of executing the success function
+     */
+    match(ok, _err) {
+        return ok(this.value);
+    }
+}
+/**
+ * Represents an error result containing an error value.
+ *
+ * @template T - The type of the success value (unused in Err)
+ * @template E - The type of the error value
+ * @since 2.0.0
+ */
+export class Err {
+    /**
+     * Creates a new Err result.
+     *
+     * @param error - The error value to wrap
+     */
+    constructor(error) {
+        this.error = error;
+    }
+    /**
+     * Always returns false for Err instances.
+     *
+     * @returns `false`
+     */
+    isOk() {
+        return false;
+    }
+    /**
+     * Always returns true for Err instances.
+     * Optimized to return the constant value directly.
+     *
+     * @returns `true`
+     */
+    isErr() {
+        return true;
+    }
+    /**
+     * No-op for Err instances - the value transformation function is ignored.
+     *
+     * @template A - The type of the transformed value (unused)
+     * @param _f - Transformation function (ignored)
+     * @returns A new Err result with the original error
+     */
+    map(_f) {
+        return err(this.error);
+    }
+    /**
+     * Transforms the error value using the provided function.
+     *
+     * @template U - The type of the transformed error
+     * @param f - Function to transform the error value
+     * @returns A new Err result with the transformed error
+     */
+    mapErr(f) {
+        return err(f(this.error));
+    }
+    andThen() {
+        return err(this.error);
+    }
+    /**
+     * Always returns the default value for Err instances.
+     *
+     * @template A - The type of the default value
+     * @param v - Default value to return
+     * @returns The default value
+     */
+    unwrapOr(v) {
+        return v;
+    }
+    /**
+     * Executes the error function with the error value.
+     *
+     * @template A - The return type for the success case (unused)
+     * @template B - The return type for the error case
+     * @param _ok - Success function (ignored)
+     * @param err - Function to execute with the error value
+     * @returns The result of executing the error function
+     */
+    match(_ok, err) {
+        return err(this.error);
+    }
+}
+/**
+ * Creates a new successful result.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value (defaults to never)
+ * @param value - The value to wrap in a successful result
+ * @returns A new Ok result containing the value
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const result = ok(42);
+ * result.isOk(); // true
+ * result.value; // 42
+ * ```
+ */
+export function ok(value) {
+    return new Ok(value);
+}
+/**
+ * Creates a new error result.
+ *
+ * @template T - The type of the success value (defaults to never)
+ * @template E - The type of the error value (defaults to unknown)
+ * @param error - The error to wrap in an error result
+ * @returns A new Err result containing the error
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const result = err("Something went wrong");
+ * result.isErr(); // true
+ * result.error; // "Something went wrong"
+ * ```
+ */
+export function err(error) {
+    return new Err(error);
+}
+/**
+ * Executes a generator function that can yield error results and return a final result.
+ * This provides a way to handle errors in a more functional style.
+ *
+ * @template T - The type of the success value
+ * @template E - The type of the error value
+ * @param body - Generator function that yields errors and returns a final result, or a function that returns a Result directly
+ * @returns The final result from the generator or function
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * const result = safeTry(function* () {
+ *   const user = yield validateUser(input);
+ *   const profile = yield fetchProfile(user.id);
+ *   return ok({ user, profile });
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const result = safeTry(() => ok(42));
+ * ```
+ */
+export function safeTry(body) {
+    const result = body();
+    // Check if it's a generator by checking for the next method
+    if (result &&
+        typeof result === "object" &&
+        "next" in result &&
+        typeof result.next ===
+            "function") {
+        const generator = result;
+        const nextResult = generator.next();
+        return nextResult.value;
+    }
+    // It's a direct Result
+    return result;
+}
+/**
+ * Namespace containing utility functions for working with Result types.
+ * TypeScript allows type and namespace with the same name (declaration merging).
+ */
+// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/no-namespace
+export var Result;
+(function (Result) {
+    /**
+     * Wraps a function with try-catch error handling, creating a new function
+     * that returns a Result instead of throwing exceptions.
+     *
+     * Uses `unknown` types for maximum type safety and modern TypeScript syntax.
+     *
+     * @template Fn - The type of the function to wrap
+     * @template E - The type of the error value
+     * @param fn - Function to wrap with error handling
+     * @param errorFn - Optional function to transform thrown errors
+     * @returns A new function that returns a Result instead of throwing
+     *
+     * @example
+     * ```typescript
+     * const safeParse = Result.fromThrowable(
+     *   JSON.parse,
+     *   (error) => `Parse error: ${error}`
+     * );
+     *
+     * const result = safeParse('{"valid": "json"}');
+     * // result is Ok({valid: "json"})
+     *
+     * const error = safeParse('invalid json');
+     * // error is Err("Parse error: SyntaxError: ...")
+     * ```
+     */
+    function fromThrowable(fn, errorFn) {
+        return (...args) => {
+            try {
+                const result = fn(...args);
+                return ok(result);
+            }
+            catch (e) {
+                return err(errorFn ? errorFn(e) : e);
+            }
+        };
+    }
+    Result.fromThrowable = fromThrowable;
+    /**
+     * Combines multiple Results into a single Result containing an array of values.
+     * Returns the first error encountered, or all values if all Results are Ok.
+     * This is useful for collecting multiple operations that can fail.
+     *
+     * Uses `unknown` types for maximum type safety and compatibility.
+     *
+     * @template T - The type of the Results to combine
+     * @param resultList - Array of Results to combine
+     * @returns A Result containing an array of all values, or the first error
+     *
+     * @example
+     * ```typescript
+     * const results = [
+     *   ok(1),
+     *   ok(2),
+     *   ok(3)
+     * ];
+     *
+     * const combined = Result.combine(results);
+     * // combined is Ok([1, 2, 3])
+     *
+     * @example
+     * ```typescript
+     * const withError = [
+     *   ok(1),
+     *   err("second failed"),
+     *   ok(3)
+     * ];
+     *
+     * const failed = Result.combine(withError);
+     * // failed is Err("second failed")
+     * ```
+     */
+    function combine(resultList) {
+        const results = [];
+        for (const result of resultList) {
+            if (result.isErr()) {
+                return err(result.error);
+            }
+            results.push(result.value);
+        }
+        return ok(results);
+    }
+    Result.combine = combine;
+})(Result || (Result = {}));
+/**
+ * Wraps an async function with try-catch error handling, returning a Promise
+ * that resolves to a Result instead of rejecting.
+ *
+ * Uses `unknown` for error types to maintain maximum type safety and flexibility.
+ *
+ * @template T - The type of the value returned by the async function
+ * @param fn - Async function to wrap with error handling
+ * @returns A Promise that resolves to a Result
+ * @since 1.1.0
+ *
+ * @example
+ * ```typescript
+ * const fetchUser = async (id: string) => {
+ *   const response = await fetch(`/api/users/${id}`);
+ *   return response.json();
+ * };
+ *
+ * const result = await safeAsyncTry(() => fetchUser("123"));
+ * if (result.isOk()) {
+ *   console.log(result.value); // User data
+ * } else {
+ *   console.log(result.error); // Error details
+ * }
+ * ```
+ */
+export async function safeAsyncTry(fn) {
+    try {
+        const value = await fn();
+        return ok(value);
+    }
+    catch (error) {
+        return err(error);
+    }
+}
+// -------------------------------------------------------------------------------------
+// Conversion bridges
+// -------------------------------------------------------------------------------------
+/**
+ * Converts an Option to a Result.
+ *
+ * @template E - The error type
+ * @param onNone - Function to create error when Option is None
+ * @returns A function that converts an Option to a Result
+ * @since 2.0.0
+ */
+export const fromOption = (onNone) => (fa) => isSomeOption(fa) ? ok(fa.value) : err(onNone());
+const isRight = (fa) => fa._tag === "Right";
+/**
+ * Converts an Either to a Result.
+ *
+ * @template E - The error type
+ * @template A - The success type
+ * @param fa - The Either to convert
+ * @returns A Result
+ * @since 2.0.0
+ */
+export const fromEither = (fa) => (isRight(fa) ? ok(fa.right) : err(fa.left));
+/**
+ * Converts a Result to an Either.
+ *
+ * @template A - The success type
+ * @template E - The error type
+ * @param fa - The Result to convert
+ * @returns An Either
+ * @since 2.0.0
+ */
+export const toEither = (fa) => fa.isOk()
+    ? { _tag: "Right", right: fa.value }
+    : { _tag: "Left", left: fa.error };
+// Export async functionality
+export * from "./result-async";
+// Explicit exports for better compatibility
+export { okAsync, errAsync, ResultAsync, fromPromise, fromSafePromise, fromAsyncThrowable, } from "./result-async";
+//# sourceMappingURL=result.js.map

package/dist/zygos/result/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../../src/zygos/result/result.ts"],"names":[],"mappings":"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"}

package/dist/zygos/safe.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "./result/result";
+/**
+ * Wraps a function to return a Result instead of throwing errors.
+ * @template TArgs - The argument types.
+ * @template TReturn - The return type.
+ * @param fn - The function to wrap.
+ * @returns A new function that returns a `Result<TReturn, Error>`.
+ * @since 2.0.0
+ * @example
+ * ```typescript
+ * import { chunk } from './chunk';
+ *
+ * const safeChunk = safe(chunk);
+ * const result = safeChunk([1, 2, 3, 4, 5], -1);
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Array of chunks
+ * } else {
+ *   console.log(result.error.message); // "Chunk size must be strictly positive"
+ * }
+ * ```
+ */
+export declare const safe: <TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn) => (...args: TArgs) => Result<TReturn, Error>;
+//# sourceMappingURL=safe.d.ts.map

package/dist/zygos/safe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["../../src/zygos/safe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAW,MAAM,sBAAsB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACnD,IAAI,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,MAEvB,GAAG,MAAM,KAAK,KAAG,MAAM,CAAC,OAAO,EAAE,KAAK,CAO/C,CAAC"}

package/dist/zygos/safe.js

@@ -0,0 +1,33 @@
+import { err, ok } from "./result/result";
+/**
+ * Wraps a function to return a Result instead of throwing errors.
+ * @template TArgs - The argument types.
+ * @template TReturn - The return type.
+ * @param fn - The function to wrap.
+ * @returns A new function that returns a `Result<TReturn, Error>`.
+ * @since 2.0.0
+ * @example
+ * ```typescript
+ * import { chunk } from './chunk';
+ *
+ * const safeChunk = safe(chunk);
+ * const result = safeChunk([1, 2, 3, 4, 5], -1);
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Array of chunks
+ * } else {
+ *   console.log(result.error.message); // "Chunk size must be strictly positive"
+ * }
+ * ```
+ */
+export const safe = (fn) => {
+    return (...args) => {
+        try {
+            return ok(fn(...args));
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+};
+//# sourceMappingURL=safe.js.map

package/dist/zygos/safe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe.js","sourceRoot":"","sources":["../../src/zygos/safe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,GAAG,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,EAA+B,EAC/B,EAAE;IACF,OAAO,CAAC,GAAG,IAAW,EAA0B,EAAE;QAChD,IAAI,CAAC;YACH,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACzB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,GAAG,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC;IACH,CAAC,CAAC;AACJ,CAAC,CAAC"}