errore 0.8.1 → 0.8.2

package/dist/core.d.ts

@@ -0,0 +1,69 @@
+import { UnhandledError } from './error.js';
+/**
+ * Type guard: checks if value is an Error.
+ * After this check, TypeScript narrows the type to the error types in the union.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isError(result)) {
+ *   // result is narrowed to the error type
+ *   return result
+ * }
+ * // result is narrowed to User
+ * console.log(result.name)
+ */
+export declare function isError<V>(value: V): value is Extract<V, Error>;
+/**
+ * Type guard: checks if value is NOT an Error.
+ * Inverse of isError for convenience.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isOk(result)) {
+ *   console.log(result.name) // result is User
+ * }
+ */
+export declare function isOk<V>(value: V): value is Exclude<V, Error>;
+/**
+ * Execute a sync function and return either the value or an error.
+ *
+ * @overload Simple form - wraps exceptions in UnhandledError
+ * @example
+ * const result = tryFn(() => JSON.parse(input))
+ * // result: UnhandledError | unknown
+ *
+ * @overload With custom catch - you control the error type
+ * @example
+ * const result = tryFn({
+ *   try: () => JSON.parse(input),
+ *   catch: (e) => new ParseError({ cause: e })
+ * })
+ * // result: ParseError | unknown
+ */
+export declare function tryFn<T>(fn: () => T): UnhandledError | T;
+export declare function tryFn<T, E extends Error>(opts: {
+    try: () => T;
+    catch: (e: unknown) => E;
+}): E | T;
+/**
+ * Execute an async function and return either the value or an error.
+ *
+ * @overload Simple form - wraps exceptions in UnhandledError
+ * @example
+ * const result = await tryAsync(() => fetch(url).then(r => r.json()))
+ * // result: UnhandledError | unknown
+ *
+ * @overload With custom catch - you control the error type
+ * @example
+ * const result = await tryAsync({
+ *   try: () => fetch(url),
+ *   catch: (e) => new NetworkError({ cause: e })
+ * })
+ * // result: NetworkError | Response
+ */
+export declare function tryAsync<T>(fn: () => Promise<T>): Promise<UnhandledError | T>;
+export declare function tryAsync<T, E extends Error>(opts: {
+    try: () => Promise<T>;
+    catch: (e: unknown) => E | Promise<E>;
+}): Promise<E | T>;
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAE5D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,cAAc,GAAG,CAAC,CAAA;AACzD,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,CAAC,CAAA;AAmBlG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,cAAc,GAAG,CAAC,CAAC,CAAA;AAC9E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE;IACjD,GAAG,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;IACrB,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CACtC,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA"}

package/dist/core.js

@@ -0,0 +1,62 @@
+import { UnhandledError } from './error.js';
+/**
+ * Type guard: checks if value is an Error.
+ * After this check, TypeScript narrows the type to the error types in the union.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isError(result)) {
+ *   // result is narrowed to the error type
+ *   return result
+ * }
+ * // result is narrowed to User
+ * console.log(result.name)
+ */
+export function isError(value) {
+    return value instanceof Error;
+}
+/**
+ * Type guard: checks if value is NOT an Error.
+ * Inverse of isError for convenience.
+ *
+ * @example
+ * const result = await fetchUser(id)
+ * if (isOk(result)) {
+ *   console.log(result.name) // result is User
+ * }
+ */
+export function isOk(value) {
+    return !(value instanceof Error);
+}
+export function tryFn(fnOrOpts) {
+    if (typeof fnOrOpts === 'function') {
+        try {
+            return fnOrOpts();
+        }
+        catch (cause) {
+            return new UnhandledError({ cause });
+        }
+    }
+    try {
+        return fnOrOpts.try();
+    }
+    catch (cause) {
+        return fnOrOpts.catch(cause);
+    }
+}
+export async function tryAsync(fnOrOpts) {
+    if (typeof fnOrOpts === 'function') {
+        try {
+            return await fnOrOpts();
+        }
+        catch (cause) {
+            return new UnhandledError({ cause });
+        }
+    }
+    try {
+        return await fnOrOpts.try();
+    }
+    catch (cause) {
+        return await fnOrOpts.catch(cause);
+    }
+}

package/dist/error.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Any tagged error (for generic constraints)
+ */
+type AnyTaggedError = Error & {
+    readonly _tag: string;
+};
+/**
+ * Any class that extends Error
+ */
+type ErrorClass = new (...args: any[]) => Error;
+/**
+ * Instance type produced by TaggedError factory
+ */
+export type TaggedErrorInstance<Tag extends string, Props, Base extends Error = Error> = Base & {
+    readonly _tag: Tag;
+    toJSON(): object;
+} & Readonly<Props>;
+/**
+ * Class type produced by TaggedError factory
+ */
+export type TaggedErrorClass<Tag extends string, Props, Base extends Error = Error> = {
+    new (...args: keyof Props extends never ? [args?: {}] : [args: Props]): TaggedErrorInstance<Tag, Props, Base>;
+    /** Type guard for this error class */
+    is(value: unknown): value is TaggedErrorInstance<Tag, Props, Base>;
+};
+/**
+ * Factory for tagged error classes with discriminated _tag property.
+ * Enables exhaustive pattern matching on error unions.
+ *
+ * @example
+ * class NotFoundError extends TaggedError("NotFoundError")<{
+ *   id: string;
+ *   message: string;
+ * }>() {}
+ *
+ * const err = new NotFoundError({ id: "123", message: "Not found" });
+ * err._tag    // "NotFoundError"
+ * err.id      // "123"
+ *
+ * // Type guard
+ * NotFoundError.is(err) // true
+ * TaggedError.is(err)   // true (any tagged error)
+ *
+ * @example
+ * // With custom base class
+ * class AppError extends Error {
+ *   statusCode: number = 500
+ *   report() { console.log(this.message) }
+ * }
+ *
+ * class NotFoundError extends TaggedError("NotFoundError", AppError)<{
+ *   id: string;
+ *   message: string;
+ * }>() {
+ *   statusCode = 404
+ * }
+ *
+ * const err = new NotFoundError({ id: "123", message: "Not found" });
+ * err.statusCode // 404
+ * err.report()   // works
+ */
+export declare const TaggedError: {
+    <Tag extends string, BaseClass extends ErrorClass = typeof Error>(tag: Tag, BaseClass?: BaseClass): <Props extends Record<string, unknown> = {}>() => TaggedErrorClass<Tag, Props, InstanceType<BaseClass>>;
+    /** Type guard for any TaggedError instance */
+    is(value: unknown): value is AnyTaggedError;
+};
+/**
+ * Type guard for tagged error instances.
+ *
+ * @example
+ * if (isTaggedError(value)) { value._tag }
+ */
+export declare const isTaggedError: (value: unknown) => value is AnyTaggedError;
+/**
+ * Handler map that includes `_` for plain Error (untagged)
+ */
+type MatchHandlersWithPlain<E extends Error, R> = {
+    [K in Extract<E, AnyTaggedError>['_tag']]: (err: Extract<E, {
+        _tag: K;
+    }>) => R;
+} & (Exclude<E, AnyTaggedError> extends never ? {} : {
+    _: (err: Exclude<E, AnyTaggedError>) => R;
+});
+/**
+ * Exhaustive pattern match on error union by _tag.
+ * Use `_` handler for plain Error instances without _tag.
+ *
+ * @example
+ * // Tagged errors only
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   ValidationError: (e) => `Invalid: ${e.field}`,
+ * });
+ *
+ * @example
+ * // Mixed tagged and plain Error
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   _: (e) => `Unknown error: ${e.message}`,
+ * });
+ */
+export declare function matchError<E extends Error, R>(err: E, handlers: MatchHandlersWithPlain<E, R>): R;
+/**
+ * Partial pattern match with fallback for unhandled tags.
+ *
+ * @example
+ * matchErrorPartial(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ * }, (e) => `Unknown: ${e.message}`);
+ */
+export declare function matchErrorPartial<E extends Error, R>(err: E, handlers: Partial<MatchHandlersWithPlain<E, R>>, fallback: (e: E) => R): R;
+declare const UnhandledError_base: TaggedErrorClass<"UnhandledError", {
+    message: string;
+    cause: unknown;
+}, Error>;
+/**
+ * Default error type when catching unknown exceptions.
+ */
+export declare class UnhandledError extends UnhandledError_base {
+    constructor(args: {
+        cause: unknown;
+    });
+}
+export {};
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

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

package/dist/error.js

@@ -0,0 +1,160 @@
+/**
+ * Serialize cause for JSON output
+ */
+const serializeCause = (cause) => {
+    if (cause instanceof Error) {
+        return { name: cause.name, message: cause.message, stack: cause.stack };
+    }
+    return cause;
+};
+/**
+ * Type guard for any tagged error
+ */
+const isAnyTaggedError = (value) => {
+    return value instanceof Error && '_tag' in value && typeof value._tag === 'string';
+};
+/**
+ * Factory for tagged error classes with discriminated _tag property.
+ * Enables exhaustive pattern matching on error unions.
+ *
+ * @example
+ * class NotFoundError extends TaggedError("NotFoundError")<{
+ *   id: string;
+ *   message: string;
+ * }>() {}
+ *
+ * const err = new NotFoundError({ id: "123", message: "Not found" });
+ * err._tag    // "NotFoundError"
+ * err.id      // "123"
+ *
+ * // Type guard
+ * NotFoundError.is(err) // true
+ * TaggedError.is(err)   // true (any tagged error)
+ *
+ * @example
+ * // With custom base class
+ * class AppError extends Error {
+ *   statusCode: number = 500
+ *   report() { console.log(this.message) }
+ * }
+ *
+ * class NotFoundError extends TaggedError("NotFoundError", AppError)<{
+ *   id: string;
+ *   message: string;
+ * }>() {
+ *   statusCode = 404
+ * }
+ *
+ * const err = new NotFoundError({ id: "123", message: "Not found" });
+ * err.statusCode // 404
+ * err.report()   // works
+ */
+export const TaggedError = Object.assign((tag, BaseClass) => () => {
+    const ActualBase = (BaseClass ?? Error);
+    class Tagged extends ActualBase {
+        _tag = tag;
+        /** Type guard for this error class */
+        static is(value) {
+            return value instanceof Tagged;
+        }
+        constructor(args) {
+            const message = args && 'message' in args && typeof args.message === 'string' ? args.message : undefined;
+            const cause = args && 'cause' in args ? args.cause : undefined;
+            super(message, cause !== undefined ? { cause } : undefined);
+            if (args) {
+                Object.assign(this, args);
+            }
+            Object.setPrototypeOf(this, new.target.prototype);
+            this.name = tag;
+            if (cause instanceof Error && cause.stack) {
+                const indented = cause.stack.replace(/\n/g, '\n  ');
+                this.stack = `${this.stack}\nCaused by: ${indented}`;
+            }
+        }
+        toJSON() {
+            return {
+                ...this,
+                _tag: this._tag,
+                name: this.name,
+                message: this.message,
+                cause: serializeCause(this.cause),
+                stack: this.stack,
+            };
+        }
+    }
+    return Tagged;
+}, { is: isAnyTaggedError });
+/**
+ * Type guard for tagged error instances.
+ *
+ * @example
+ * if (isTaggedError(value)) { value._tag }
+ */
+export const isTaggedError = isAnyTaggedError;
+/**
+ * Exhaustive pattern match on error union by _tag.
+ * Use `_` handler for plain Error instances without _tag.
+ *
+ * @example
+ * // Tagged errors only
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   ValidationError: (e) => `Invalid: ${e.field}`,
+ * });
+ *
+ * @example
+ * // Mixed tagged and plain Error
+ * matchError(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ *   _: (e) => `Unknown error: ${e.message}`,
+ * });
+ */
+export function matchError(err, handlers) {
+    const h = handlers;
+    if ('_tag' in err && typeof err._tag === 'string') {
+        const handler = h[err._tag];
+        if (handler) {
+            return handler(err);
+        }
+    }
+    // Fall through to _ handler for plain Error
+    const fallbackHandler = h['_'];
+    if (fallbackHandler) {
+        return fallbackHandler(err);
+    }
+    throw new Error(`No handler for error: ${err.message}`);
+}
+/**
+ * Partial pattern match with fallback for unhandled tags.
+ *
+ * @example
+ * matchErrorPartial(err, {
+ *   NotFoundError: (e) => `Missing: ${e.id}`,
+ * }, (e) => `Unknown: ${e.message}`);
+ */
+export function matchErrorPartial(err, handlers, fallback) {
+    const h = handlers;
+    if ('_tag' in err && typeof err._tag === 'string') {
+        const handler = h[err._tag];
+        if (handler) {
+            return handler(err);
+        }
+    }
+    // Check for _ handler before fallback
+    const underscoreHandler = h['_'];
+    if (underscoreHandler) {
+        return underscoreHandler(err);
+    }
+    return fallback(err);
+}
+/**
+ * Default error type when catching unknown exceptions.
+ */
+export class UnhandledError extends TaggedError('UnhandledError')() {
+    constructor(args) {
+        const message = args.cause instanceof Error
+            ? `Unhandled exception: ${args.cause.message}`
+            : `Unhandled exception: ${String(args.cause)}`;
+        super({ message, cause: args.cause });
+    }
+}

package/dist/extract.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Extract the value or throw if it's an error.
+ *
+ * @example
+ * const user = unwrap(result) // throws if result is an error
+ * console.log(user.name)
+ *
+ * @example With custom message
+ * const user = unwrap(result, 'Failed to get user')
+ */
+export declare function unwrap<V>(value: V, message?: string): Exclude<V, Error>;
+/**
+ * Extract the value or return a fallback if it's an error.
+ *
+ * @example
+ * const name = unwrapOr(result, 'Anonymous')
+ * // If result is User, returns user
+ * // If result is Error, returns 'Anonymous'
+ */
+export declare function unwrapOr<V, U>(value: V, fallback: U): Exclude<V, Error> | U;
+/**
+ * Pattern match on an errore value.
+ * Handles both success and error cases.
+ *
+ * @example
+ * const message = match(result, {
+ *   ok: user => `Hello, ${user.name}`,
+ *   err: error => `Failed: ${error.message}`
+ * })
+ */
+export declare function match<V, R>(value: V, handlers: {
+    ok: (v: Exclude<V, Error>) => R;
+    err: (e: Extract<V, Error>) => R;
+}): R;
+/**
+ * Partition an array of errore values into [successes, errors].
+ *
+ * @example
+ * const results = await Promise.all(ids.map(fetchUser))
+ * const [users, errors] = partition(results)
+ */
+export declare function partition<V>(values: V[]): [Exclude<V, Error>[], Extract<V, Error>[]];
+/**
+ * Flatten a nested errore: (E1 | (E2 | T)) becomes (E1 | E2 | T).
+ * Useful when chaining operations that can fail.
+ *
+ * @example
+ * const nested: NetworkError | (ParseError | User) = await fetchAndParse()
+ * const flat: NetworkError | ParseError | User = flatten(nested)
+ */
+export declare function flatten<V>(value: V): V;
+//# sourceMappingURL=extract.d.ts.map

package/dist/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../src/extract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,CAKvE;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAK3E;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EACxB,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE;IACR,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IAC/B,GAAG,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;CACjC,GACA,CAAC,CAKH;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,CAWpF;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEtC"}

package/dist/extract.js

@@ -0,0 +1,77 @@
+/**
+ * Extract the value or throw if it's an error.
+ *
+ * @example
+ * const user = unwrap(result) // throws if result is an error
+ * console.log(user.name)
+ *
+ * @example With custom message
+ * const user = unwrap(result, 'Failed to get user')
+ */
+export function unwrap(value, message) {
+    if (value instanceof Error) {
+        throw new Error(message ?? `Unwrap called on error: ${value.message}`, { cause: value });
+    }
+    return value;
+}
+/**
+ * Extract the value or return a fallback if it's an error.
+ *
+ * @example
+ * const name = unwrapOr(result, 'Anonymous')
+ * // If result is User, returns user
+ * // If result is Error, returns 'Anonymous'
+ */
+export function unwrapOr(value, fallback) {
+    if (value instanceof Error) {
+        return fallback;
+    }
+    return value;
+}
+/**
+ * Pattern match on an errore value.
+ * Handles both success and error cases.
+ *
+ * @example
+ * const message = match(result, {
+ *   ok: user => `Hello, ${user.name}`,
+ *   err: error => `Failed: ${error.message}`
+ * })
+ */
+export function match(value, handlers) {
+    if (value instanceof Error) {
+        return handlers.err(value);
+    }
+    return handlers.ok(value);
+}
+/**
+ * Partition an array of errore values into [successes, errors].
+ *
+ * @example
+ * const results = await Promise.all(ids.map(fetchUser))
+ * const [users, errors] = partition(results)
+ */
+export function partition(values) {
+    const oks = [];
+    const errs = [];
+    for (const v of values) {
+        if (v instanceof Error) {
+            errs.push(v);
+        }
+        else {
+            oks.push(v);
+        }
+    }
+    return [oks, errs];
+}
+/**
+ * Flatten a nested errore: (E1 | (E2 | T)) becomes (E1 | E2 | T).
+ * Useful when chaining operations that can fail.
+ *
+ * @example
+ * const nested: NetworkError | (ParseError | User) = await fetchAndParse()
+ * const flat: NetworkError | ParseError | User = flatten(nested)
+ */
+export function flatten(value) {
+    return value;
+}