@willaimg/yatsp 4.3.6

package/v4/core/errors.cjs

@@ -0,0 +1,317 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$YatspRealError = exports.$YatspError = void 0;
+exports.flattenError = flattenError;
+exports.formatError = formatError;
+exports.treeifyError = treeifyError;
+exports.toDotPath = toDotPath;
+exports.prettifyError = prettifyError;
+const core_js_1 = require("./core.cjs");
+const util = __importStar(require("./util.cjs"));
+/* Computing the message eagerly is expensive (pretty-printed JSON of all
+ * issues), so defer it until first read. The accessor functions and
+ * descriptors are shared across instances to keep error construction
+ * cheap; the computed message is cached on the internals object. The
+ * setter preserves plain assignment semantics for consumers that
+ * overwrite `message`. */
+function _getMessage() {
+    const internals = this._yatsp;
+    internals.message ?? (internals.message = JSON.stringify(internals.def, util.jsonStringifyReplacer, 2));
+    return internals.message;
+}
+function _setMessage(value) {
+    this._yatsp.message = value;
+}
+const _messageDesc = {
+    get: _getMessage,
+    set: _setMessage,
+    enumerable: true,
+    configurable: true,
+};
+const _issuesDesc = { value: undefined, enumerable: false };
+/* Prototypes that already carry the lazy `toString`. Seeded with the
+ * intrinsics so that `init` on a foreign object — it accepts any object —
+ * can never install an accessor onto a prototype we do not own. */
+const _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
+const initializer = (inst, def) => {
+    inst.name = "$YatspError";
+    // `_yatsp` is already non-enumerable: $constructor's init defined it with this same descriptor
+    _issuesDesc.value = def;
+    Object.defineProperty(inst, "issues", _issuesDesc);
+    // Clear the shared slot; a retained `value` pins the last error's issues.
+    _issuesDesc.value = undefined;
+    Object.defineProperty(inst, "message", _messageDesc);
+    /* `toString` lives as a non-enumerable lazy getter on the shared
+     * prototype; on first access it caches a per-instance closure so
+     * detached usage still works. */
+    const proto = Object.getPrototypeOf(inst);
+    if (!_installedToString.has(proto)) {
+        _installedToString.add(proto);
+        Object.defineProperty(proto, "toString", {
+            configurable: true,
+            enumerable: false,
+            get() {
+                const value = () => this.message;
+                Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+                return value;
+            },
+            set(value) {
+                Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+            },
+        });
+    }
+};
+exports.$YatspError = (0, core_js_1.$constructor)("$YatspError", initializer);
+exports.$YatspRealError = (0, core_js_1.$constructor)("$YatspError", initializer, undefined, {
+    Parent: Error,
+});
+/** Get-or-create `obj[key]` as an own data property. A path segment naming an inherited member
+ * ("toString", "constructor") would otherwise read through to the prototype, and assigning
+ * "__proto__" would hit the setter instead of creating a key. */
+function node(obj, key, make) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (key === "__proto__") {
+            Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
+        }
+        else {
+            obj[key] = make();
+        }
+    }
+    return obj[key];
+}
+function flattenError(error, mapper = (issue) => issue.message) {
+    const fieldErrors = {};
+    const formErrors = [];
+    for (const sub of error.issues) {
+        if (sub.path.length > 0) {
+            node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
+        }
+        else {
+            formErrors.push(mapper(sub));
+        }
+    }
+    return { formErrors, fieldErrors };
+}
+function formatError(error, mapper = (issue) => issue.message) {
+    const fieldErrors = { _errors: [] };
+    const processError = (error, path = []) => {
+        for (const issue of error.issues) {
+            if (issue.code === "invalid_union" && issue.errors.length) {
+                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
+            }
+            else if (issue.code === "invalid_key") {
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
+            }
+            else if (issue.code === "invalid_element") {
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
+            }
+            else {
+                const fullpath = [...path, ...issue.path];
+                if (fullpath.length === 0) {
+                    fieldErrors._errors.push(mapper(issue));
+                }
+                else {
+                    let curr = fieldErrors;
+                    let i = 0;
+                    while (i < fullpath.length) {
+                        const el = fullpath[i];
+                        const terminal = i === fullpath.length - 1;
+                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+                        if (el === "_errors") {
+                            if (terminal)
+                                curr._errors.push(mapper(issue));
+                            i++;
+                            continue;
+                        }
+                        // A path element may collide with an inherited property name such as
+                        // "__proto__" or "constructor". Truthiness checks read the prototype
+                        // (so no node is created, then ._errors.push throws), and bracket
+                        // assignment of "__proto__" hits the setter instead of creating an
+                        // own key. Guard the read with hasOwnProperty and create the node
+                        // with defineProperty so any path element becomes a real own key.
+                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+                            Object.defineProperty(curr, el, {
+                                value: { _errors: [] },
+                                enumerable: true,
+                                writable: true,
+                                configurable: true,
+                            });
+                        }
+                        const node = curr[el];
+                        if (terminal) {
+                            node._errors.push(mapper(issue));
+                        }
+                        curr = node;
+                        i++;
+                    }
+                }
+            }
+        }
+    };
+    processError(error);
+    return fieldErrors;
+}
+function treeifyError(error, mapper = (issue) => issue.message) {
+    const result = { errors: [] };
+    const processError = (error, path = []) => {
+        var _a;
+        for (const issue of error.issues) {
+            if (issue.code === "invalid_union" && issue.errors.length) {
+                // regular union error
+                issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
+            }
+            else if (issue.code === "invalid_key") {
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
+            }
+            else if (issue.code === "invalid_element") {
+                processError({ issues: issue.issues }, [...path, ...issue.path]);
+            }
+            else {
+                const fullpath = [...path, ...issue.path];
+                if (fullpath.length === 0) {
+                    result.errors.push(mapper(issue));
+                    continue;
+                }
+                let curr = result;
+                let i = 0;
+                while (i < fullpath.length) {
+                    const el = fullpath[i];
+                    const terminal = i === fullpath.length - 1;
+                    if (typeof el === "string") {
+                        curr.properties ?? (curr.properties = {});
+                        // el may collide with an inherited property name ("__proto__",
+                        // "constructor", ...); ??= reads the prototype so the node is never
+                        // created and curr.errors.push throws. Guard with hasOwnProperty and
+                        // create the node with defineProperty so "__proto__" becomes a real
+                        // own key rather than invoking the prototype setter.
+                        if (!Object.prototype.hasOwnProperty.call(curr.properties, el)) {
+                            Object.defineProperty(curr.properties, el, {
+                                value: { errors: [] },
+                                enumerable: true,
+                                writable: true,
+                                configurable: true,
+                            });
+                        }
+                        curr = curr.properties[el];
+                    }
+                    else {
+                        curr.items ?? (curr.items = []);
+                        (_a = curr.items)[el] ?? (_a[el] = { errors: [] });
+                        curr = curr.items[el];
+                    }
+                    if (terminal) {
+                        curr.errors.push(mapper(issue));
+                    }
+                    i++;
+                }
+            }
+        }
+    };
+    processError(error);
+    return result;
+}
+/** Format a YatspError as a human-readable string in the following form.
+ *
+ * From
+ *
+ * ```ts
+ * YatspError {
+ *   issues: [
+ *     {
+ *       expected: 'string',
+ *       code: 'invalid_type',
+ *       path: [ 'username' ],
+ *       message: 'Invalid input: expected string'
+ *     },
+ *     {
+ *       expected: 'number',
+ *       code: 'invalid_type',
+ *       path: [ 'favoriteNumbers', 1 ],
+ *       message: 'Invalid input: expected number'
+ *     }
+ *   ];
+ * }
+ * ```
+ *
+ * to
+ *
+ * ```
+ * username
+ *   ✖ Expected number, received string at "username
+ * favoriteNumbers[0]
+ *   ✖ Invalid input: expected number
+ * ```
+ */
+function toDotPath(_path) {
+    const segs = [];
+    const path = _path.map((seg) => (typeof seg === "object" ? seg.key : seg));
+    for (const seg of path) {
+        if (typeof seg === "number")
+            segs.push(`[${seg}]`);
+        else if (typeof seg === "symbol")
+            segs.push(`[${JSON.stringify(String(seg))}]`);
+        else if (/[^\w$]/.test(seg))
+            segs.push(`[${JSON.stringify(seg)}]`);
+        else {
+            if (segs.length)
+                segs.push(".");
+            segs.push(seg);
+        }
+    }
+    return segs.join("");
+}
+function prettifyError(error) {
+    const lines = [];
+    // sort by path length
+    const issues = [...error.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
+    // Process each issue
+    for (const issue of issues) {
+        lines.push(`✖ ${issue.message}`);
+        if (issue.path?.length)
+            lines.push(`  → at ${toDotPath(issue.path)}`);
+    }
+    // Convert Map to formatted string
+    return lines.join("\n");
+}
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/v4/core/errors.d.cts

@@ -0,0 +1,225 @@
+import type { $YatspCheck, $YatspStringFormats } from "./checks.cjs";
+import { $constructor } from "./core.cjs";
+import type { $YatspType } from "./schemas.cjs";
+import type { StandardSchemaV1 } from "./standard-schema.cjs";
+import * as util from "./util.cjs";
+export interface $YatspIssueBase {
+    readonly code?: string;
+    readonly input?: unknown;
+    readonly path: PropertyKey[];
+    readonly message: string;
+}
+export type $YatspInvalidTypeExpected = "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "undefined" | "null" | "never" | "void" | "date" | "array" | "object" | "tuple" | "record" | "map" | "set" | "file" | "nonoptional" | "nan" | "function" | (string & {});
+export interface $YatspIssueInvalidType<Input = unknown> extends $YatspIssueBase {
+    readonly code: "invalid_type";
+    readonly expected: $YatspInvalidTypeExpected;
+    readonly input?: Input;
+}
+export interface $YatspIssueTooBig<Input = unknown> extends $YatspIssueBase {
+    readonly code: "too_big";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly maximum: number | bigint;
+    readonly inclusive?: boolean;
+    readonly exact?: boolean;
+    readonly input?: Input;
+}
+export interface $YatspIssueTooSmall<Input = unknown> extends $YatspIssueBase {
+    readonly code: "too_small";
+    readonly origin: "number" | "int" | "bigint" | "date" | "string" | "array" | "set" | "file" | (string & {});
+    readonly minimum: number | bigint;
+    /** True if the allowable range includes the minimum */
+    readonly inclusive?: boolean;
+    /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */
+    readonly exact?: boolean;
+    readonly input?: Input;
+}
+export interface $YatspIssueInvalidStringFormat extends $YatspIssueBase {
+    readonly code: "invalid_format";
+    readonly format: $YatspStringFormats | (string & {});
+    readonly pattern?: string;
+    readonly input?: string;
+}
+export interface $YatspIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $YatspIssueBase {
+    readonly code: "not_multiple_of";
+    readonly divisor: number;
+    readonly input?: Input;
+}
+export interface $YatspIssueUnrecognizedKeys extends $YatspIssueBase {
+    readonly code: "unrecognized_keys";
+    readonly keys: string[];
+    readonly input?: Record<string, unknown>;
+}
+interface $YatspIssueInvalidUnionNoMatch extends $YatspIssueBase {
+    readonly code: "invalid_union";
+    readonly errors: $YatspIssue[][];
+    readonly input?: unknown;
+    readonly discriminator?: string | undefined;
+    readonly options?: util.Primitive[];
+    readonly inclusive?: true;
+}
+interface $YatspIssueInvalidUnionMultipleMatch extends $YatspIssueBase {
+    readonly code: "invalid_union";
+    readonly errors: [];
+    readonly input?: unknown;
+    readonly discriminator?: string | undefined;
+    readonly inclusive: false;
+    /** Indices of the options that matched */
+    readonly matches: number[];
+}
+export type $YatspIssueInvalidUnion = $YatspIssueInvalidUnionNoMatch | $YatspIssueInvalidUnionMultipleMatch;
+export interface $YatspIssueInvalidKey<Input = unknown> extends $YatspIssueBase {
+    readonly code: "invalid_key";
+    readonly origin: "map" | "record";
+    readonly issues: $YatspIssue[];
+    readonly input?: Input;
+}
+export interface $YatspIssueInvalidElement<Input = unknown> extends $YatspIssueBase {
+    readonly code: "invalid_element";
+    readonly origin: "map" | "set";
+    readonly key: unknown;
+    readonly issues: $YatspIssue[];
+    readonly input?: Input;
+}
+export interface $YatspIssueInvalidValue<Input = unknown> extends $YatspIssueBase {
+    readonly code: "invalid_value";
+    readonly values: util.Primitive[];
+    readonly input?: Input;
+}
+export interface $YatspIssueCustom extends $YatspIssueBase {
+    readonly code: "custom";
+    readonly params?: Record<string, any> | undefined;
+    readonly input?: unknown;
+}
+export interface $YatspIssueStringCommonFormats extends $YatspIssueInvalidStringFormat {
+    format: Exclude<$YatspStringFormats, "regex" | "jwt" | "starts_with" | "ends_with" | "includes">;
+}
+export interface $YatspIssueStringInvalidRegex extends $YatspIssueInvalidStringFormat {
+    format: "regex";
+    pattern: string;
+}
+export interface $YatspIssueStringInvalidJWT extends $YatspIssueInvalidStringFormat {
+    format: "jwt";
+    algorithm?: string;
+}
+export interface $YatspIssueStringStartsWith extends $YatspIssueInvalidStringFormat {
+    format: "starts_with";
+    prefix: string;
+}
+export interface $YatspIssueStringEndsWith extends $YatspIssueInvalidStringFormat {
+    format: "ends_with";
+    suffix: string;
+}
+export interface $YatspIssueStringIncludes extends $YatspIssueInvalidStringFormat {
+    format: "includes";
+    includes: string;
+}
+export type $YatspStringFormatIssues = $YatspIssueStringCommonFormats | $YatspIssueStringInvalidRegex | $YatspIssueStringInvalidJWT | $YatspIssueStringStartsWith | $YatspIssueStringEndsWith | $YatspIssueStringIncludes;
+export type $YatspIssue = $YatspIssueInvalidType | $YatspIssueTooBig | $YatspIssueTooSmall | $YatspIssueInvalidStringFormat | $YatspIssueNotMultipleOf | $YatspIssueUnrecognizedKeys | $YatspIssueInvalidUnion | $YatspIssueInvalidKey | $YatspIssueInvalidElement | $YatspIssueInvalidValue | $YatspIssueCustom;
+export type $YatspIssueCode = $YatspIssue["code"];
+export type $YatspInternalIssue<T extends $YatspIssueBase = $YatspIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $YatspIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, "message" | "path"> & {
+    /** The input data */
+    readonly input: unknown;
+    /** The schema or check that originated this issue. */
+    readonly inst?: $YatspType | $YatspCheck;
+    /** The schema that owns the issue. Equal to `inst` when a schema originated the issue, and the schema the check was attached to when a check did. */
+    readonly schema?: $YatspType | undefined;
+    /** If `true`, Yatsp will continue executing checks/refinements after this issue. */
+    readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+export type $YatspRawIssue<T extends $YatspIssueBase = $YatspIssue> = $YatspInternalIssue<T>;
+export interface $YatspErrorMap<T extends $YatspIssueBase = $YatspIssue> {
+    (issue: $YatspRawIssue<T>): {
+        message: string;
+    } | string | undefined | null;
+}
+export interface $YatspError<T = unknown> extends Error {
+    type: T;
+    issues: $YatspIssue[];
+    _yatsp: {
+        output: T;
+        def: $YatspIssue[];
+    };
+    stack?: string;
+    name: string;
+}
+export declare const $YatspError: $constructor<$YatspError>;
+interface $YatspRealError<T = any> extends $YatspError<T> {
+}
+export declare const $YatspRealError: $constructor<$YatspRealError>;
+export type $YatspFlattenedError<T, U = string> = _FlattenedError<T, U>;
+type _FlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in keyof T]?: U[];
+    };
+};
+export declare function flattenError<T>(error: $YatspError<T>): _FlattenedError<T>;
+export declare function flattenError<T, U>(error: $YatspError<T>, mapper?: (issue: $YatspIssue) => U): _FlattenedError<T, U>;
+type _YatspFormattedError<T, U = string> = T extends [any, ...any[]] ? {
+    [K in keyof T]?: $YatspFormattedError<T[K], U>;
+} : T extends any[] ? {
+    [k: number]: $YatspFormattedError<T[number], U>;
+} : T extends object ? util.Flatten<{
+    [K in keyof T]?: $YatspFormattedError<T[K], U>;
+}> : any;
+export type $YatspFormattedError<T, U = string> = {
+    _errors: U[];
+} & util.Flatten<_YatspFormattedError<T, U>>;
+export declare function formatError<T>(error: $YatspError<T>): $YatspFormattedError<T>;
+export declare function formatError<T, U>(error: $YatspError<T>, mapper?: (issue: $YatspIssue) => U): $YatspFormattedError<T, U>;
+export type $YatspErrorTree<T, U = string> = T extends util.Primitive ? {
+    errors: U[];
+} : T extends [any, ...any[]] ? {
+    errors: U[];
+    items?: {
+        [K in keyof T]?: $YatspErrorTree<T[K], U>;
+    };
+} : T extends any[] ? {
+    errors: U[];
+    items?: Array<$YatspErrorTree<T[number], U>>;
+} : T extends object ? {
+    errors: U[];
+    properties?: {
+        [K in keyof T]?: $YatspErrorTree<T[K], U>;
+    };
+} : {
+    errors: U[];
+};
+export declare function treeifyError<T>(error: $YatspError<T>): $YatspErrorTree<T>;
+export declare function treeifyError<T, U>(error: $YatspError<T>, mapper?: (issue: $YatspIssue) => U): $YatspErrorTree<T, U>;
+/** Format a YatspError as a human-readable string in the following form.
+ *
+ * From
+ *
+ * ```ts
+ * YatspError {
+ *   issues: [
+ *     {
+ *       expected: 'string',
+ *       code: 'invalid_type',
+ *       path: [ 'username' ],
+ *       message: 'Invalid input: expected string'
+ *     },
+ *     {
+ *       expected: 'number',
+ *       code: 'invalid_type',
+ *       path: [ 'favoriteNumbers', 1 ],
+ *       message: 'Invalid input: expected number'
+ *     }
+ *   ];
+ * }
+ * ```
+ *
+ * to
+ *
+ * ```
+ * username
+ *   ✖ Expected number, received string at "username
+ * favoriteNumbers[0]
+ *   ✖ Invalid input: expected number
+ * ```
+ */
+export declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;
+export declare function prettifyError(error: StandardSchemaV1.FailureResult): string;
+export {};