@nice-code/error 0.8.0 → 0.9.0

package/build/types/NiceError/NiceErrorHydrated.d.ts

@@ -1,51 +0,0 @@
-import type { NiceErrorDomain } from "../NiceErrorDefined/NiceErrorDefined";
-import { type INiceErrorOptions, NiceError } from "./NiceError";
-import type { ExtractFromIdContextArg, INiceErrorDomainProps, TDomainNiceErrorId, TFromContextInput, TUnknownNiceErrorDef } from "./NiceError.types";
-/**
- * Resolves the args tuple for `addId` — mirrors `FromIdArgs` exactly so that
- * optional vs required context is consistent across both `fromId` and `addId`.
- *
- * - No context on this id                   → `[id]`
- * - Context defined, `required: true`       → `[id, context]`
- * - Context defined, `required` absent/false → `[id] | [id, context]`
- */
-type AddIdArgs<ERR_DEF extends INiceErrorDomainProps, K extends TDomainNiceErrorId<ERR_DEF>> = [
-    ExtractFromIdContextArg<ERR_DEF["schema"][K]>
-] extends [undefined] ? [id: K] : [undefined] extends [ExtractFromIdContextArg<ERR_DEF["schema"][K]>] ? [id: K] | [id: K, context: NonNullable<ExtractFromIdContextArg<ERR_DEF["schema"][K]>>] : [id: K, context: ExtractFromIdContextArg<ERR_DEF["schema"][K]>];
-/** Full-featured construction from NiceErrorDefined.fromId / fromContext. */
-export interface INiceErrorHydratedOptions<ERR_DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<ERR_DEF>> extends INiceErrorOptions<ERR_DEF, ID> {
-    def: ERR_DEF;
-    niceErrorDefined: NiceErrorDomain<ERR_DEF>;
-}
-export declare class NiceErrorHydrated<ERR_DEF extends INiceErrorDomainProps = TUnknownNiceErrorDef, 
-/**
- * Union of active error-id keys.
- * - After `fromId(id)`: exactly one key.
- * - After `fromContext({...})`: a union of all supplied keys.
- * - After `hasOneOfIds([a,b])`: narrows to that subset.
- * - Default (bare construction / castNiceError): `TUnknownNiceErrorId`.
- */
-ACTIVE_IDS extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>> extends NiceError<ERR_DEF, ACTIVE_IDS> {
-    readonly def: ERR_DEF;
-    private readonly niceErrorDefined;
-    constructor(options: INiceErrorHydratedOptions<ERR_DEF, ACTIVE_IDS>);
-    /**
-     * Returns a **new** `NiceErrorHydrated` with additional id+context entries merged in.
-     * The returned error's `ACTIVE_IDS` is the union of the original ids and the
-     * newly supplied keys.
-     *
-     * ```ts
-     * const err = errDef.fromId("id_a", { a: 1 })
-     *   .addContext({ id_b: { b: "x" } });
-     * err.getIds(); // ["id_a", "id_b"]
-     * ```
-     */
-    addContext<INPUT extends TFromContextInput<ERR_DEF["schema"]>>(context: INPUT & Record<Exclude<keyof INPUT, keyof ERR_DEF["schema"] & string>, never>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS | (keyof INPUT & string)>;
-    /**
-     * Returns a **new** `NiceErrorHydrated` with an additional error id (and its context,
-     * if the schema requires one). Equivalent to `addContext({ [id]: context })`
-     * but mirrors the `fromId` ergonomics for single-id additions.
-     */
-    addId<K extends TDomainNiceErrorId<ERR_DEF>>(...args: AddIdArgs<ERR_DEF, K>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS | K>;
-}
-export {};

package/build/types/NiceError/nice_error.static.d.ts

@@ -1,2 +0,0 @@
-export declare const DUR_OBJ_PACK_PREFIX = "NE_DUROBJ[[";
-export declare const DUR_OBJ_PACK_SUFFIX = "]]NE_DUROBJ";

package/build/types/NiceErrorDefined/NiceErrorDefined.d.ts

@@ -1,135 +0,0 @@
-import { NiceError } from "../NiceError/NiceError";
-import { type FromIdArgs, type IDefineNewNiceErrorDomainOptions, type INiceErrorDomainProps, type INiceErrorJsonObject, type TDomainNiceErrorId, type TErrorReconciledData, type TFromContextInput } from "../NiceError/NiceError.types";
-import { NiceErrorHydrated } from "../NiceError/NiceErrorHydrated";
-import { type EErrorPackType } from "../utils/packError/packError.enums";
-type ChildDef<PARENT_DEF extends INiceErrorDomainProps, SUB extends IDefineNewNiceErrorDomainOptions> = {
-    domain: SUB["domain"];
-    allDomains: [SUB["domain"], ...PARENT_DEF["allDomains"]];
-    schema: SUB["schema"];
-};
-/**
- * Extracts the union of keys present in a `TFromContextInput` object.
- * e.g. `{ invalid_credentials: {...} }` → `"invalid_credentials"`
- */
-type KeysOfContextInput<INPUT> = keyof INPUT & string;
-/**
- * Infers the strongly-typed `NiceError` class type from a `NiceErrorDefined` instance.
- *
- * `ACTIVE_IDS` is set to the full union of all schema keys. Use `hasId` /
- * `hasOneOfIds` to narrow further at the call site.
- *
- * @example
- * ```ts
- * const err_user_auth = defineNiceError({ domain: "err_user_auth", schema: { ... } });
- * type TUserAuthError = InferNiceError<typeof err_user_auth>;
- * // → NiceError<{ domain: "err_user_auth"; ... }, keyof schema>
- * ```
- */
-export type InferNiceError<T extends NiceErrorDomain<any>> = T extends NiceErrorDomain<infer ERR_DEF> ? NiceError<ERR_DEF, keyof ERR_DEF["schema"] & string> : never;
-/**
- * Infers the strongly-typed `NiceErrorHydrated` class type from a `NiceErrorDefined` instance.
- *
- * Use this when you need the builder methods (`addId`, `addContext`) as part of
- * the inferred type — e.g. for function return types or variable annotations.
- *
- * @example
- * ```ts
- * const err_user_auth = defineNiceError({ domain: "err_user_auth", schema: { ... } });
- * type TUserAuthErrorHydrated = InferNiceErrorHydrated<typeof err_user_auth>;
- * // → NiceErrorHydrated<{ domain: "err_user_auth"; ... }, keyof schema>
- * ```
- */
-export type InferNiceErrorHydrated<T extends NiceErrorDomain<any>> = T extends NiceErrorDomain<infer ERR_DEF> ? NiceErrorHydrated<ERR_DEF, keyof ERR_DEF["schema"] & string> : never;
-export declare class NiceErrorDomain<ERR_DEF extends INiceErrorDomainProps = INiceErrorDomainProps> {
-    readonly domain: ERR_DEF["domain"];
-    readonly allDomains: ERR_DEF["allDomains"];
-    readonly defaultHttpStatusCode?: number;
-    readonly defaultMessage?: string;
-    /** Kept for runtime use (message resolution, httpStatusCode, context serialization, etc.). */
-    private readonly _schema;
-    private _definedChildNiceErrors;
-    private _definedParentNiceError?;
-    /** Set by `.packAs()` — explicit per-instance override, takes priority over `_packAsFn`. */
-    private _setPack?;
-    /** Set at definition time — called dynamically each time an error is created. */
-    private _packAsFn?;
-    constructor(definition: ERR_DEF);
-    /**
-     * Creates a child domain that inherits this domain in `allDomains`.
-     * The child has its own schema and its own domain string.
-     */
-    createChildDomain<SUB extends IDefineNewNiceErrorDomainOptions>(subErrorDef: SUB & {
-        [K in Exclude<keyof SUB, keyof IDefineNewNiceErrorDomainOptions>]: never;
-    }): NiceErrorDomain<ChildDef<ERR_DEF, SUB>>;
-    protected addParentNiceErrorDefined<PARENT_DEF extends INiceErrorDomainProps>(parentError: NiceErrorDomain<PARENT_DEF>): void;
-    protected addChildNiceErrorDefined<CHILD_DEF extends INiceErrorDomainProps>(child: NiceErrorDomain<CHILD_DEF>): void;
-    packAs(pack: EErrorPackType): this;
-    private createError;
-    /**
-     * Promotes a plain `NiceError<ERR_DEF>` back into a `NiceErrorHydrated` so
-     * that builder methods (`addId`, `addContext`, etc.) are available again.
-     *
-     * For each active id, if the context is in the `"unhydrated"` state (i.e. the
-     * error was reconstructed from a JSON payload), `hydrate` calls
-     * `fromJsonSerializable` to reconstruct the typed value and advances the state
-     * to `"hydrated"`. Ids already in `"hydrated"` or `"raw_unset"` state
-     * are passed through unchanged.
-     *
-     * @throws If `error.def.domain` does not match this definition's domain. Use
-     * `niceErrorDefined.is(error)` before calling `hydrate` to ensure compatibility.
-     *
-     * ```ts
-     * const raw = castNiceError(apiResponseBody);
-     *
-     * if (err_user_auth.is(raw)) {
-     *   const hydrated = err_user_auth.hydrate(raw);
-     *   // hydrated.getContext("invalid_credentials") — fully typed, no throw
-     *   // hydrated.addId / addContext — available again
-     * }
-     * ```
-     */
-    hydrate<ACTIVE_IDS extends TDomainNiceErrorId<ERR_DEF> = TDomainNiceErrorId<ERR_DEF>>(error: NiceError<ERR_DEF, ACTIVE_IDS> | INiceErrorJsonObject<ERR_DEF, ACTIVE_IDS>): NiceErrorHydrated<ERR_DEF, ACTIVE_IDS>;
-    /**
-     * Creates a `NiceErrorHydrated` for a single error id.
-     *
-     * - `id` autocompletes to the schema keys.
-     * - The second argument `context` is required / optional / absent based on
-     *   whether the schema entry declares `context.required: true`.
-     * - The returned error has `ACTIVE_IDS` narrowed to exactly `K`, so
-     *   `getContext(id)` is immediately strongly typed.
-     */
-    fromId<K extends keyof ERR_DEF["schema"] & string>(...args: FromIdArgs<ERR_DEF, K>): NiceErrorHydrated<ERR_DEF, K>;
-    fromContext<INPUT extends TFromContextInput<ERR_DEF["schema"]>>(context: INPUT & Record<Exclude<keyof INPUT, keyof ERR_DEF["schema"]>, never>): NiceErrorHydrated<ERR_DEF, KeysOfContextInput<INPUT>>;
-    /**
-     * Returns `true` if `error` is a `NiceError` whose `def.domain` exactly matches
-     * this definition's domain.
-     *
-     * Use this after `castNiceError` to narrow an unknown error to this specific
-     * domain before accessing its typed ids/context:
-     *
-     * ```ts
-     * const caught = castNiceError(e);
-     *
-     * if (err_user_auth.is(caught)) {
-     *   // caught is now NiceError<typeof err_user_auth's ERR_DEF>
-     *   const hydrated = err_user_auth.hydrate(caught);
-     *   const { username } = hydrated.getContext("invalid_credentials");
-     * }
-     * ```
-     */
-    isExact(error: unknown): error is NiceError<ERR_DEF, keyof ERR_DEF["schema"] & string>;
-    isThisOrChild(error: unknown): boolean;
-    /**
-     * Returns `true` if this domain appears anywhere in the target's ancestry
-     * chain (including an exact domain match).
-     *
-     * Accepts either a `NiceErrorDefined` (domain definition) or a `NiceError`
-     * instance (extracts the domain from its `def`).
-     */
-    isParentOf(target: NiceErrorDomain<any> | NiceError<any, any>): boolean;
-    private _buildDef;
-    private _resolveMessage;
-    private _resolveHttpStatusCode;
-    reconcileErrorDataForId(id: keyof ERR_DEF["schema"] & string, context: TFromContextInput<ERR_DEF["schema"]>[typeof id]): TErrorReconciledData<ERR_DEF["schema"], typeof id>;
-}
-export {};

package/build/types/NiceErrorDefined/defineNiceError.d.ts

@@ -1,7 +0,0 @@
-import type { IDefineNewNiceErrorDomainOptions, TNiceErrorSchema } from "../NiceError/NiceError.types";
-import { NiceErrorDomain } from "./NiceErrorDefined";
-export declare const defineNiceError: <ERR_DOMAIN extends string, SCHEMA extends TNiceErrorSchema>(definition: IDefineNewNiceErrorDomainOptions<ERR_DOMAIN, SCHEMA>) => NiceErrorDomain<{
-    domain: ERR_DOMAIN;
-    allDomains: [ERR_DOMAIN];
-    schema: SCHEMA;
-}>;

package/build/types/NiceErrorDefined/err.d.ts

@@ -1,59 +0,0 @@
-import type { INiceErrorContextDefinition, INiceErrorIdMetadata, JSONSerializableValue } from "../NiceError/NiceError.types";
-/**
- * Schema entry factory — the idiomatic way to define a single error id in a
- * `NiceErrorDefined` schema.
- *
- * Using `err()` instead of writing schema entries as plain object literals
- * ensures TypeScript resolves the context argument as **required** vs **optional**
- * correctly in `fromId` / `addId` call sites.
- *
- * How `required` affects the call site:
- *
- * | Schema entry                       | `fromId("id")` | `fromId("id", ctx)` |
- * |------------------------------------|----------------|---------------------|
- * | `err()`  /  `err({ ... })`         | ✓              | ✗ (no context)      |
- * | `err<C>({ context: {} })`          | ✓              | ✓ (optional ctx)    |
- * | `err<C>({ context: { required: true } })` | ✗     | ✓ (required ctx)    |
- *
- * @example
- * ```ts
- * // No context — `fromId("not_found")` takes no second argument.
- * not_found: err({ message: "Resource not found", httpStatusCode: 404 }),
- *
- * // Optional context — second arg accepted but not required.
- * rate_limited: err<{ retryAfter: number }>({
- *   message: (ctx) => ctx ? `Retry after ${ctx.retryAfter}s` : "Rate limited",
- *   httpStatusCode: 429,
- *   context: {},
- * }),
- *
- * // Required context — `fromId("invalid_input", { field: "email" })` (second arg is required).
- * invalid_input: err<{ field: string }>({
- *   message: ({ field }) => `Invalid value for field: ${field}`,
- *   httpStatusCode: 422,
- *   context: { required: true },
- * }),
- *
- * // Required context with custom serialization (for non-JSON-safe context values).
- * fs_error: err<{ cause: NodeJS.ErrnoException }>({
- *   message: ({ cause }) => `File system error: ${cause.message}`,
- *   context: {
- *     required: true,
- *     serialization: {
- *       toJsonSerializable: ({ cause }) => ({ code: cause.code, message: cause.message }),
- *       fromJsonSerializable: (obj) => ({ cause: Object.assign(new Error(obj.message), obj) }),
- *     },
- *   },
- * }),
- * ```
- */
-export declare function err<C, D extends JSONSerializableValue = Record<string, any>>(meta: INiceErrorIdMetadata<C, D> & {
-    context: INiceErrorContextDefinition<C, D> & {
-        required: true;
-    };
-}): INiceErrorIdMetadata<C> & {
-    context: {
-        required: true;
-    };
-};
-export declare function err<C = never>(meta?: INiceErrorIdMetadata<C>): INiceErrorIdMetadata<C>;

package/build/types/NiceErrorHandler/NiceErrorHandler.d.ts

@@ -1,23 +0,0 @@
-import type { NiceError } from "../NiceError/NiceError";
-import type { INiceErrorDomainProps, TDomainNiceErrorId } from "../NiceError/NiceError.types";
-import type { NiceErrorHydrated } from "../NiceError/NiceErrorHydrated";
-import type { NiceErrorDomain } from "../NiceErrorDefined/NiceErrorDefined";
-import { type IHandleErrorOptions, type MaybePromise, type THandleErrorWithPromiseInspection } from "./NiceErrorHandler.types";
-export declare class NiceErrorHandler<RES_DEF = never, RES = never> {
-    private handlerConfigs;
-    private _defaultRequester?;
-    handleErrorWithPromiseInspection(error: NiceError<any, any>, options?: IHandleErrorOptions): THandleErrorWithPromiseInspection<RES | RES_DEF>;
-    /**
-     * Register a handler that fires for **any** error whose domain matches `domain`.
-     * The handler receives a fully hydrated error — `getContext`, `addId`, and `addContext`
-     * are all available. First matching case wins.
-     */
-    forDomain<DEF extends INiceErrorDomainProps, H_RES = void>(domain: NiceErrorDomain<DEF>, handler: (error: NiceErrorHydrated<DEF, TDomainNiceErrorId<DEF>>) => MaybePromise<H_RES>): NiceErrorHandler<RES_DEF, RES | H_RES>;
-    forId<DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<DEF>, H_RES = void>(domain: NiceErrorDomain<DEF>, id: ID, handler: (error: NiceErrorHydrated<DEF, ID>) => MaybePromise<H_RES>): NiceErrorHandler<RES_DEF, RES | H_RES>;
-    forIds<DEF extends INiceErrorDomainProps, IDS extends TDomainNiceErrorId<DEF>[], H_RES = void>(domain: NiceErrorDomain<DEF>, ids: IDS, handler: (error: NiceErrorHydrated<DEF, IDS[number]>) => MaybePromise<H_RES>): NiceErrorHandler<RES_DEF, RES | H_RES>;
-    /**
-     * Register a fallback handler that fires when no other case matches.
-     * Only one default handler can be registered — calling this twice replaces the previous one.
-     */
-    setDefaultHandler<H_RES>(handler: (error: NiceError<any, any>) => MaybePromise<H_RES>): NiceErrorHandler<H_RES, RES>;
-}

package/build/types/NiceErrorHandler/NiceErrorHandler.types.d.ts

@@ -1,82 +0,0 @@
-import type { NiceError } from "../NiceError/NiceError";
-import type { INiceErrorDomainProps, TDomainNiceErrorId } from "../NiceError/NiceError.types";
-import type { NiceErrorHydrated } from "../NiceError/NiceErrorHydrated";
-export type MaybePromise<T> = T | Promise<T>;
-/**
- * Broad handler signature used internally for storage and dispatch.
- */
-export type TBroadErrorHandler<E extends NiceError = NiceError, RES = unknown> = (action: E) => MaybePromise<RES>;
-/**
- * Handler registered via forDomain.
- *
- * `act.input` is typed as the union of input types for every action in `ACT_DOM`,
- * and `act.coreAction` carries the matching schema — the same narrowing you get
- * from `forActionIds` over all action IDs in the domain.
- */
-export type TErrorHandlerForDomain<ERR_DOM extends INiceErrorDomainProps> = (error: NiceErrorHydrated<ERR_DOM>) => MaybePromise<unknown>;
-/**
- * Handler registered via forActionId — receives a specific action ID, with
- * the primed action's input narrowed to that ID's schema.
- */
-export type TErrorIdHandlerForDomain<ERR_DOM extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<ERR_DOM>> = (error: NiceErrorHydrated<ERR_DOM, ID>) => MaybePromise<unknown>;
-export declare enum EErrorHandlerTargetType {
-    ids = "ids",
-    domain = "domain",
-    default = "default"
-}
-export type TErrorHandlerTarget = ({
-    type: EErrorHandlerTargetType.ids;
-    domain: string;
-    ids: string[];
-} | {
-    type: EErrorHandlerTargetType.domain;
-    domain: string;
-} | {
-    type: EErrorHandlerTargetType.default;
-}) & {
-    identifier: string;
-};
-/**
- * A single case in a `handleWith` / `handleWithAsync` call.
- *
- * Construct via `forDomain` or `forIds` — do not build this object directly.
- */
-export interface IErrorHandlerConfig<ERR extends NiceError<any, any> = NiceError<any, any>, RES = unknown> {
-    readonly _matcher: (action: ERR) => boolean;
-    readonly _requester: TBroadErrorHandler<ERR, RES>;
-}
-export interface IErrorHandleAttempt_Success<RES = void> {
-    handled: true;
-    result: RES;
-    target: TErrorHandlerTarget;
-}
-export interface IErrorHandleAttempt_Failure {
-    handled: false;
-    result?: undefined;
-    targets: TErrorHandlerTarget[];
-}
-export type TErrorHandleAttempt<RES = void> = IErrorHandleAttempt_Success<RES> | IErrorHandleAttempt_Failure;
-export interface IHandleErrorOptions {
-    throwOnUnhandled?: boolean;
-}
-export type THandleErrorWithPromiseInspection<RES = void> = {
-    isPromise: false;
-    matched: true;
-    target: TErrorHandlerTarget;
-    handlerResponse: RES;
-} | {
-    isPromise: true;
-    matched: true;
-    target: TErrorHandlerTarget;
-    handlerPromise: Promise<RES>;
-} | {
-    matched: false;
-    attemptedTargets: TErrorHandlerTarget[];
-};
-export type THandleResponse<RES = unknown> = {
-    handled: false;
-} | {
-    handled: true;
-    isPromise: boolean;
-    response: RES;
-};

package/build/types/NiceErrorHandler/handleWith.d.ts

@@ -1,8 +0,0 @@
-import type { INiceErrorDomainProps, TDomainNiceErrorId } from "../NiceError/NiceError.types";
-import type { NiceErrorHydrated } from "../NiceError/NiceErrorHydrated";
-import type { NiceErrorDomain } from "../NiceErrorDefined/NiceErrorDefined";
-import { NiceErrorHandler } from "./NiceErrorHandler";
-import type { MaybePromise } from "./NiceErrorHandler.types";
-export declare function forDomain<DEF extends INiceErrorDomainProps, H_RES = void>(domain: NiceErrorDomain<DEF>, handler: (error: NiceErrorHydrated<DEF, TDomainNiceErrorId<DEF>>) => MaybePromise<H_RES>): NiceErrorHandler<never, H_RES>;
-export declare function forId<DEF extends INiceErrorDomainProps, ID extends TDomainNiceErrorId<DEF>, H_RES = void>(domain: NiceErrorDomain<DEF>, id: ID, handler: (error: NiceErrorHydrated<DEF, ID>) => MaybePromise<H_RES>): NiceErrorHandler<never, H_RES>;
-export declare function forIds<DEF extends INiceErrorDomainProps, IDS extends TDomainNiceErrorId<DEF>[], H_RES = void>(domain: NiceErrorDomain<DEF>, ids: IDS, handler: (error: NiceErrorHydrated<DEF, IDS[number]>) => MaybePromise<H_RES>): NiceErrorHandler<never, H_RES>;

package/build/types/example/error_usage_example.d.ts

@@ -1,41 +0,0 @@
-export declare const err_example_app: import("..").NiceErrorDomain<{
-    domain: "err_example_app";
-    allDomains: ["err_example_app"];
-    schema: {};
-}>;
-export declare enum EErrId_UserAuth {
-    invalid_credentials = "invalid_credentials",
-    account_locked = "account_locked"
-}
-export declare const err_user_auth: import("..").NiceErrorDomain<{
-    domain: string;
-    allDomains: [string, "err_example_app"];
-    schema: {
-        invalid_credentials: import("..").INiceErrorIdMetadata<{
-            username: string;
-        }, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-        account_locked: import("..").INiceErrorIdMetadata<any, import("..").JSONSerializableValue>;
-    };
-}>;
-export declare enum EErrId_UserAuth_Registration {
-    password_error = "password_error",
-    password_too_short = "password_too_short"
-}
-export declare const err_user_auth_registration: import("..").NiceErrorDomain<{
-    domain: string;
-    allDomains: [string, string, "err_example_app"];
-    schema: {
-        password_too_short: import("..").INiceErrorIdMetadata<{
-            minLength: number;
-        }, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-        password_error: import("..").INiceErrorIdMetadata<any, import("..").JSONSerializableValue>;
-    };
-}>;

package/build/types/index.d.ts

@@ -1,18 +0,0 @@
-export * from "./internal";
-export * from "./NiceError/NiceError";
-export * from "./NiceError/NiceError.types";
-export * from "./NiceError/NiceErrorHydrated";
-export * from "./NiceErrorDefined/defineNiceError";
-export * from "./NiceErrorDefined/err";
-export * from "./NiceErrorDefined/NiceErrorDefined";
-export * from "./NiceErrorHandler/handleWith";
-export * from "./NiceErrorHandler/NiceErrorHandler";
-export * from "./NiceErrorHandler/NiceErrorHandler.types";
-export * from "./utils/castAndHydrate";
-export * from "./utils/castNiceError";
-export * from "./utils/isNiceErrorObject";
-export * from "./utils/isRegularErrorObject";
-export * from "./utils/matchFirst";
-export * from "./utils/packError/causePack";
-export * from "./utils/packError/msgPack";
-export * from "./utils/packError/packError.enums";

package/build/types/internal/index.d.ts

@@ -1 +0,0 @@
-export * from "./nice_core_errors";

package/build/types/internal/nice_core_errors.d.ts

@@ -1,49 +0,0 @@
-import type { IInspectErrorResult_JsError, IInspectErrorResult_JsErrorObject, IInspectErrorResult_JsOther, IInspectErrorResult_Nullish, TInspectErrorResult_JsDataType } from "../utils/inspectPotentialError/inspectPotentialError.types";
-export declare const err_nice: import("..").NiceErrorDomain<{
-    domain: "err_nice";
-    allDomains: ["err_nice"];
-    schema: {};
-}>;
-export declare enum EErrId_CastNotNice {
-    js_error = "native_error",
-    js_error_like_object = "js_error_like_object",
-    nullish_value = "nullish_value",
-    js_data_type = "js_data_type",
-    js_other = "js_other"
-}
-export declare const err_cast_not_nice: import("..").NiceErrorDomain<{
-    domain: string;
-    allDomains: [string, "err_nice"];
-    schema: {
-        native_error: import("..").INiceErrorIdMetadata<IInspectErrorResult_JsError, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-        js_error_like_object: import("..").INiceErrorIdMetadata<IInspectErrorResult_JsErrorObject, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-        nullish_value: import("..").INiceErrorIdMetadata<IInspectErrorResult_Nullish, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-        js_data_type: import("..").INiceErrorIdMetadata<TInspectErrorResult_JsDataType, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-        js_other: import("..").INiceErrorIdMetadata<IInspectErrorResult_JsOther, import("..").JSONSerializableValue> & {
-            context: {
-                required: true;
-            };
-        };
-    };
-}>;
-export declare const err_nice_handler: import("..").NiceErrorDomain<{
-    domain: string;
-    allDomains: [string, "err_nice"];
-    schema: {};
-}>;

package/build/types/test/helpers/nice_error_testing.static.d.ts

@@ -1,3 +0,0 @@
-import type { INiceErrorOptions } from "../../NiceError/NiceError";
-import type { INiceErrorDomainProps } from "../../NiceError/NiceError.types";
-export declare const nice_error_test_options: INiceErrorOptions<INiceErrorDomainProps, keyof INiceErrorDomainProps["schema"]>;

package/build/types/test/helpers/test_utils.d.ts

@@ -1 +0,0 @@
-export declare const isVal: <T>(input: unknown, val: T) => input is T;

package/build/types/utils/castAndHydrate.d.ts

@@ -1,35 +0,0 @@
-import { NiceError } from "../NiceError/NiceError";
-import type { INiceErrorDomainProps } from "../NiceError/NiceError.types";
-import { NiceErrorHydrated } from "../NiceError/NiceErrorHydrated";
-import type { NiceErrorDomain } from "../NiceErrorDefined/NiceErrorDefined";
-/**
- * Combines `castNiceError`, `is()`, and `hydrate()` in a single call — the
- * idiomatic way to handle an unknown value arriving from a remote boundary
- * (API response, message queue, IPC, etc.) when you have a specific domain in mind.
- *
- * - Casts `value` to a `NiceError` using `castNiceError`.
- * - If the result belongs to `niceErrorDefined`'s domain (`is()` returns `true`),
- *   hydrates it and returns a fully-typed `NiceErrorHydrated`.
- * - Otherwise returns the raw cast `NiceError` (which may be a `wasntNice` error
- *   if `value` was not a NiceError at all).
- *
- * @example
- * ```ts
- * // In an Express error handler:
- * app.use((err, req, res, next) => {
- *   const error = castAndHydrate(err, err_user_auth);
- *
- *   if (err_user_auth.is(error)) {
- *     // error is NiceErrorHydrated — getContext / addId available
- *     const result = matchFirst(error, {
- *       invalid_credentials: ({ username }) => res.status(401).json({ username }),
- *       account_locked:      ()             => res.status(403).json({ locked: true }),
- *     });
- *     if (result) return;
- *   }
- *
- *   next(err);
- * });
- * ```
- */
-export declare function castAndHydrate<ERR_DEF extends INiceErrorDomainProps>(value: unknown, niceErrorDefined: NiceErrorDomain<ERR_DEF>): NiceErrorHydrated<ERR_DEF, keyof ERR_DEF["schema"] & string> | NiceError;

package/build/types/utils/castNiceError.d.ts

@@ -1,15 +0,0 @@
-import { NiceError } from "../NiceError/NiceError";
-/**
- * Casts any unknown value into a `NiceError`.
- *
- * - If the value is already a `NiceError` instance, it is returned as-is.
- * - If the value is a plain `Error`, it is wrapped with the original as `originError`.
- * - If the value is a JSON-serialised `NiceError` object (e.g. from an API
- *   response), a best-effort `NiceError` is re-created from it.
- * - For all other values, a generic `NiceError` is created with a descriptive
- *   message.
- *
- * After casting, use `NiceErrorDefined.is(error)` to narrow the error to a
- * specific domain and access its strongly-typed ids and context.
- */
-export declare const castNiceError: (error: unknown) => NiceError;

package/build/types/utils/inspectPotentialError/inspectPotentialError.d.ts

@@ -1,2 +0,0 @@
-import { type TInspectErrorResult } from "./inspectPotentialError.types";
-export declare const inspectPotentialError: (potentialError: unknown) => TInspectErrorResult;

package/build/types/utils/inspectPotentialError/inspectPotentialError.enums.d.ts

@@ -1,9 +0,0 @@
-export declare enum EInspectErrorResultType {
-    nullish = "nullish",
-    niceErrorObject = "niceErrorObject",
-    niceError = "niceError",
-    jsError = "jsError",
-    jsErrorObject = "jsErrorObject",
-    jsDataType = "jsDataType",
-    jsOther = "jsOther"
-}

package/build/types/utils/inspectPotentialError/inspectPotentialError.types.d.ts

@@ -1,51 +0,0 @@
-import type { NiceError } from "../../NiceError/NiceError";
-import type { INiceErrorJsonObject, IRegularErrorJsonObject } from "../../NiceError/NiceError.types";
-import type { EInspectErrorResultType } from "./inspectPotentialError.enums";
-export interface IInspectErrorResult_Base<T extends EInspectErrorResultType> {
-    type: T;
-}
-export interface IInspectErrorResult_Nullish extends IInspectErrorResult_Base<EInspectErrorResultType.nullish> {
-    value: null | undefined;
-}
-export interface IInspectErrorResult_NiceErrorObject extends IInspectErrorResult_Base<EInspectErrorResultType.niceErrorObject> {
-    niceErrorObject: INiceErrorJsonObject;
-}
-export interface IInspectErrorResult_NiceError extends IInspectErrorResult_Base<EInspectErrorResultType.niceError> {
-    niceError: NiceError;
-}
-export interface IInspectErrorResult_JsError extends IInspectErrorResult_Base<EInspectErrorResultType.jsError> {
-    jsError: Error;
-}
-export interface IInspectErrorResult_JsErrorObject extends IInspectErrorResult_Base<EInspectErrorResultType.jsErrorObject> {
-    jsErrorObject: IRegularErrorJsonObject;
-}
-/**
- * JS DATA TYPES
- */
-export interface IInspectErrorResult_JsDataType_String extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
-    jsDataType: "string";
-    jsDataValue: string;
-}
-export interface IInspectErrorResult_JsDataType_Number extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
-    jsDataType: "number";
-    jsDataValue: number;
-}
-export interface IInspectErrorResult_JsDataType_Boolean extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
-    jsDataType: "boolean";
-    jsDataValue: boolean;
-}
-export interface IInspectErrorResult_JsDataType_Object extends IInspectErrorResult_Base<EInspectErrorResultType.jsDataType> {
-    jsDataType: "object";
-    jsDataValue: object;
-}
-export type TInspectErrorResult_JsDataType = IInspectErrorResult_JsDataType_String | IInspectErrorResult_JsDataType_Number | IInspectErrorResult_JsDataType_Boolean | IInspectErrorResult_JsDataType_Object;
-/**
- * Catch-all for any other JS data type that doesn't fit the above categories (e.g. symbol, bigint, function, etc.)
- */
-export interface IInspectErrorResult_JsOther extends IInspectErrorResult_Base<EInspectErrorResultType.jsOther> {
-    jsDataValue: unknown;
-}
-/**
- * Union of all possible results from inspectPotentialError
- */
-export type TInspectErrorResult = IInspectErrorResult_Nullish | IInspectErrorResult_NiceErrorObject | IInspectErrorResult_NiceError | IInspectErrorResult_JsError | IInspectErrorResult_JsErrorObject | TInspectErrorResult_JsDataType | IInspectErrorResult_JsOther;

package/build/types/utils/isNiceErrorObject.d.ts

@@ -1,12 +0,0 @@
-import { type INiceErrorJsonObject } from "../NiceError/NiceError.types";
-/**
- * Returns `true` if `obj` is a JSON-serialised `NiceError` object matching the
- * current wire format (contextState-based errorData entries).
- *
- * Validates:
- * - Top-level shape (`name`, `message`, `wasntNice`, `httpStatusCode`, `def`)
- * - Each `errorData` entry has a `contextState` with a valid `kind` discriminant
- *   (`"no_serialization"` or `"unhydrated"`) — rejecting payloads in the old
- *   format (`context` / `serialized` fields) to prevent silent data corruption.
- */
-export declare function isNiceErrorObject(obj: unknown): obj is INiceErrorJsonObject;

package/build/types/utils/isRegularErrorObject.d.ts

@@ -1,2 +0,0 @@
-import type { IRegularErrorJsonObject } from "../NiceError/NiceError.types";
-export declare function isRegularErrorJsonObject(obj: unknown): obj is IRegularErrorJsonObject;

package/build/types/utils/jsErrorOrCastJsError.d.ts

@@ -1 +0,0 @@
-export declare function jsErrorOrCastJsError(error: unknown, logMessage?: boolean): Error;

package/build/types/utils/logger.d.ts

@@ -1,3 +0,0 @@
-import { Logger } from "tslog";
-export declare const logger_NiceError: Logger<unknown>;
-export declare const logger_NiceError_testing: Logger<unknown>;