furukotest 1.0.0 → 4.6.6

package/package.json

@@ -1,11 +1,130 @@
 {
   "name": "furukotest",
-  "version": "1.0.0",
   "description": "Furoko test package",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "version": "4.6.6",
+  "type": "module",
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "sideEffects": [
+    "./compile.js",
+    "./compile.cjs",
+    "./src/compile.ts"
+  ],
+  "files": [
+    "src",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs",
+    "**/*.d.ts",
+    "**/*.d.mts",
+    "**/*.d.cts",
+    "**/package.json"
+  ],
+  "keywords": [
+    "typescript",
+    "schema",
+    "validation",
+    "type",
+    "inference"
+  ],
+  "main": "./index.cjs",
+  "types": "./index.d.cts",
+  "module": "./index.js",
+  "zshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts",
+      "./mini": "./src/mini/index.ts",
+      "./compile": "./src/compile.ts",
+      "./locales": "./src/locales/index.ts",
+      "./v3": "./src/v3/index.ts",
+      "./v4": "./src/v4/index.ts",
+      "./v4-mini": "./src/v4-mini/index.ts",
+      "./v4/mini": "./src/v4/mini/index.ts",
+      "./v4/core": "./src/v4/core/index.ts",
+      "./v4/locales": "./src/v4/locales/index.ts",
+      "./v4/locales/*": "./src/v4/locales/*"
+    },
+    "conditions": {
+      "@furukotest/source": "src"
+    },
+    "sealCjsExports": true
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@furukotest/source": "./src/index.ts",
+      "types": "./index.d.cts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./mini": {
+      "@furukotest/source": "./src/mini/index.ts",
+      "types": "./mini/index.d.cts",
+      "import": "./mini/index.js",
+      "require": "./mini/index.cjs"
+    },
+    "./compile": {
+      "@furukotest/source": "./src/compile.ts",
+      "types": "./compile.d.cts",
+      "import": "./compile.js",
+      "require": "./compile.cjs"
+    },
+    "./locales": {
+      "@furukotest/source": "./src/locales/index.ts",
+      "types": "./locales/index.d.cts",
+      "import": "./locales/index.js",
+      "require": "./locales/index.cjs"
+    },
+    "./v3": {
+      "@furukotest/source": "./src/v3/index.ts",
+      "types": "./v3/index.d.cts",
+      "import": "./v3/index.js",
+      "require": "./v3/index.cjs"
+    },
+    "./v4": {
+      "@furukotest/source": "./src/v4/index.ts",
+      "types": "./v4/index.d.cts",
+      "import": "./v4/index.js",
+      "require": "./v4/index.cjs"
+    },
+    "./v4-mini": {
+      "@furukotest/source": "./src/v4-mini/index.ts",
+      "types": "./v4-mini/index.d.cts",
+      "import": "./v4-mini/index.js",
+      "require": "./v4-mini/index.cjs"
+    },
+    "./v4/mini": {
+      "@furukotest/source": "./src/v4/mini/index.ts",
+      "types": "./v4/mini/index.d.cts",
+      "import": "./v4/mini/index.js",
+      "require": "./v4/mini/index.cjs"
+    },
+    "./v4/core": {
+      "@furukotest/source": "./src/v4/core/index.ts",
+      "types": "./v4/core/index.d.cts",
+      "import": "./v4/core/index.js",
+      "require": "./v4/core/index.cjs"
+    },
+    "./v4/locales": {
+      "@furukotest/source": "./src/v4/locales/index.ts",
+      "types": "./v4/locales/index.d.cts",
+      "import": "./v4/locales/index.js",
+      "require": "./v4/locales/index.cjs"
+    },
+    "./v4/locales/*": {
+      "@furukotest/source": "./src/v4/locales/*",
+      "types": "./v4/locales/*",
+      "import": "./v4/locales/*",
+      "require": "./v4/locales/*"
+    }
+  },
+  "scripts": {
+    "clean": "git clean -xdf . -e node_modules",
+    "build": "nub exec --node zshy --project tsconfig.build.json",
+    "postbuild": "nub ../../scripts/write-stub-package-jsons.ts && nub exec --node biome check --write .",
+    "test:watch": "nub exec --node vitest",
+    "test": "nub exec --node vitest run",
+    "prepublishOnly": "nub ../../scripts/check-versions.ts"
+  }
 }

package/src/compile.ts

@@ -0,0 +1,56 @@
+// Side-effect-only: installs the post-processor on `globalConfig`. Listed in `package.json`'s `sideEffects`, and nothing else references it, so apps that never import it drop the compiler.
+//
+// Usage:
+//
+//   import "yatsp/compile";
+//   import * as z from "yatsp";
+//   // every schema constructed below this is compiled on first parse
+//
+// Module evaluation order matters: schemas constructed in modules that evaluate before this import will not be compiled. Place this import in the app entry point, before any module that constructs schemas at top level.
+//
+// Failure handling: if the compiler refuses a schema (async refinement, unsupported feature, etc.) the shim permanently restores the runtime `_yatsp.run` for that schema. The schema continues to work via the regular runtime parser — no observable difference to the caller.
+
+import { compile } from "./v4/core/compile.js";
+import * as core from "./v4/core/index.js";
+
+let compiling = false;
+
+core.globalConfig.postProcessor = (inst: any) => {
+  if (compiling) return;
+  const originalRun = inst._yatsp?.run;
+  if (typeof originalRun !== "function") return;
+
+  const shim = (payload: any, ctx: any): any => {
+    // Bypass the fast path for any non-forward / non-sync / check-skipping call. The runtime owns those contracts.
+    if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks) {
+      return originalRun(payload, ctx);
+    }
+
+    compiling = true;
+    try {
+      // Respect the jitless config: it exists precisely so CSP/no-eval environments never reach `new Function`. Global mode must not bypass it (explicit z.compile calls remain an explicit opt-in).
+      if (core.globalConfig.jitless) {
+        inst._yatsp.run = originalRun;
+        return originalRun(payload, ctx);
+      }
+      // Strict: the shim owns its own fallback below, and a non-strict compile would hand back `inst` — whose run is this shim — and reinstall it on itself.
+      const compiled = compile(inst, { strict: true });
+      // Only the run wrapper. Copying the compiled parse/safeParse closures would make their fallback re-enter this instance and run user callbacks a third time.
+      inst._yatsp.run = compiled._yatsp.run;
+      inst._yatsp.bag.fallbackRun = compiled._yatsp.bag.fallbackRun;
+      inst._yatsp.bag.validator = compiled._yatsp.bag.validator;
+    } catch {
+      // Permanent fallback for unsupported schemas.
+      inst._yatsp.run = originalRun;
+    } finally {
+      compiling = false;
+    }
+
+    return inst._yatsp.run(payload, ctx);
+  };
+
+  // Expose the pre-shim runtime so `compile()` invoked elsewhere can unwrap past the shim and capture the source-of-truth runtime. Without this, a user calling `z.compile(s)` after global mode is enabled would capture the shim itself, which would feed the wrapper into itself on fallback.
+  (shim as any).__originalRun = originalRun;
+
+  inst._yatsp.run = shim;
+};

package/src/index.ts

@@ -0,0 +1,7 @@
+import * as z from "./v4/classic/external.js";
+export * from "./v4/classic/external.js";
+// Aliasing the binding, instead of `export default z`, keeps the default export a
+// re-export of `z` rather than a fresh namespace value. Rollup and Webpack can then
+// shake `import z from "yatsp"` as they already shake `import { z } from "yatsp"` — without
+// this they pull in every locale. See #6050.
+export { z, z as default };

package/src/locales/index.ts

@@ -0,0 +1 @@
+export * from "../v4/locales/index.js";

package/src/mini/index.ts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/src/v3/ZodError.ts

@@ -0,0 +1,340 @@
+import type { Primitive } from "./helpers/typeAliases.js";
+import { util, type YatspParsedType } from "./helpers/util.js";
+import type { TypeOf, YatspType } from "./index.js";
+
+type allKeys<T> = T extends any ? keyof T : never;
+
+export type inferFlattenedErrors<T extends YatspType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export type typeToFlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: {
+    [P in allKeys<T>]?: U[];
+  };
+};
+
+export const YatspIssueCode = util.arrayToEnum([
+  "invalid_type",
+  "invalid_literal",
+  "custom",
+  "invalid_union",
+  "invalid_union_discriminator",
+  "invalid_enum_value",
+  "unrecognized_keys",
+  "invalid_arguments",
+  "invalid_return_type",
+  "invalid_date",
+  "invalid_string",
+  "too_small",
+  "too_big",
+  "invalid_intersection_types",
+  "not_multiple_of",
+  "not_finite",
+]);
+
+export type YatspIssueCode = keyof typeof YatspIssueCode;
+
+export type YatspIssueBase = {
+  path: (string | number)[];
+  message?: string | undefined;
+};
+
+export interface YatspInvalidTypeIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_type;
+  expected: YatspParsedType;
+  received: YatspParsedType;
+}
+
+export interface YatspInvalidLiteralIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_literal;
+  expected: unknown;
+  received: unknown;
+}
+
+export interface YatspUnrecognizedKeysIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.unrecognized_keys;
+  keys: string[];
+}
+
+export interface YatspInvalidUnionIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_union;
+  unionErrors: YatspError[];
+}
+
+export interface YatspInvalidUnionDiscriminatorIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_union_discriminator;
+  options: Primitive[];
+}
+
+export interface YatspInvalidEnumValueIssue extends YatspIssueBase {
+  received: string | number;
+  code: typeof YatspIssueCode.invalid_enum_value;
+  options: (string | number)[];
+}
+
+export interface YatspInvalidArgumentsIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_arguments;
+  argumentsError: YatspError;
+}
+
+export interface YatspInvalidReturnTypeIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_return_type;
+  returnTypeError: YatspError;
+}
+
+export interface YatspInvalidDateIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_date;
+}
+
+export type StringValidation =
+  | "email"
+  | "url"
+  | "emoji"
+  | "uuid"
+  | "nanoid"
+  | "regex"
+  | "cuid"
+  | "cuid2"
+  | "ulid"
+  | "datetime"
+  | "date"
+  | "time"
+  | "duration"
+  | "ip"
+  | "cidr"
+  | "base64"
+  | "jwt"
+  | "base64url"
+  | { includes: string; position?: number | undefined }
+  | { startsWith: string }
+  | { endsWith: string };
+
+export interface YatspInvalidStringIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_string;
+  validation: StringValidation;
+}
+
+export interface YatspTooSmallIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.too_small;
+  minimum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+
+export interface YatspTooBigIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.too_big;
+  maximum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+
+export interface YatspInvalidIntersectionTypesIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.invalid_intersection_types;
+}
+
+export interface YatspNotMultipleOfIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.not_multiple_of;
+  multipleOf: number | bigint;
+}
+
+export interface YatspNotFiniteIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.not_finite;
+}
+
+export interface YatspCustomIssue extends YatspIssueBase {
+  code: typeof YatspIssueCode.custom;
+  params?: { [k: string]: any };
+}
+
+export type DenormalizedError = { [k: string]: DenormalizedError | string[] };
+
+export type YatspIssueOptionalMessage =
+  | YatspInvalidTypeIssue
+  | YatspInvalidLiteralIssue
+  | YatspUnrecognizedKeysIssue
+  | YatspInvalidUnionIssue
+  | YatspInvalidUnionDiscriminatorIssue
+  | YatspInvalidEnumValueIssue
+  | YatspInvalidArgumentsIssue
+  | YatspInvalidReturnTypeIssue
+  | YatspInvalidDateIssue
+  | YatspInvalidStringIssue
+  | YatspTooSmallIssue
+  | YatspTooBigIssue
+  | YatspInvalidIntersectionTypesIssue
+  | YatspNotMultipleOfIssue
+  | YatspNotFiniteIssue
+  | YatspCustomIssue;
+
+export type YatspIssue = YatspIssueOptionalMessage & {
+  fatal?: boolean | undefined;
+  message: string;
+};
+
+export const quotelessJson = (obj: any) => {
+  const json = JSON.stringify(obj, null, 2);
+  return json.replace(/"([^"]+)":/g, "$1:");
+};
+
+type recursiveYatspFormattedError<T> = T extends [any, ...any[]]
+  ? { [K in keyof T]?: YatspFormattedError<T[K]> }
+  : T extends any[]
+    ? { [k: number]: YatspFormattedError<T[number]> }
+    : T extends object
+      ? { [K in keyof T]?: YatspFormattedError<T[K]> }
+      : unknown;
+
+export type YatspFormattedError<T, U = string> = {
+  _errors: U[];
+} & recursiveYatspFormattedError<NonNullable<T>>;
+
+export type inferFormattedError<T extends YatspType<any, any, any>, U = string> = YatspFormattedError<TypeOf<T>, U>;
+
+export class YatspError<T = any> extends Error {
+  issues: YatspIssue[] = [];
+
+  get errors() {
+    return this.issues;
+  }
+
+  constructor(issues: YatspIssue[]) {
+    super();
+
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      // eslint-disable-next-line ban/ban
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      (this as any).__proto__ = actualProto;
+    }
+    this.name = "YatspError";
+    this.issues = issues;
+  }
+
+  format(): YatspFormattedError<T>;
+  format<U>(mapper: (issue: YatspIssue) => U): YatspFormattedError<T, U>;
+  format(_mapper?: any) {
+    const mapper: (issue: YatspIssue) => any =
+      _mapper ||
+      function (issue: YatspIssue) {
+        return issue.message;
+      };
+    const fieldErrors: YatspFormattedError<T> = { _errors: [] } as any;
+    const processError = (error: YatspError) => {
+      for (const issue of error.issues) {
+        if (issue.code === "invalid_union") {
+          issue.unionErrors.map(processError);
+        } else if (issue.code === "invalid_return_type") {
+          processError(issue.returnTypeError);
+        } else if (issue.code === "invalid_arguments") {
+          processError(issue.argumentsError);
+        } else if (issue.path.length === 0) {
+          (fieldErrors as any)._errors.push(mapper(issue));
+        } else {
+          let curr: any = fieldErrors;
+          let i = 0;
+          while (i < issue.path.length) {
+            const el = issue.path[i]!;
+            const terminal = i === issue.path.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;
+            }
+
+            // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
+            if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+              if (el === "__proto__") {
+                Object.defineProperty(curr, el, {
+                  value: { _errors: [] },
+                  writable: true,
+                  enumerable: true,
+                  configurable: true,
+                });
+              } else {
+                curr[el] = { _errors: [] };
+              }
+            }
+
+            curr = curr[el];
+            if (terminal) {
+              curr._errors.push(mapper(issue));
+            }
+            i++;
+          }
+        }
+      }
+    };
+
+    processError(this);
+    return fieldErrors;
+  }
+
+  static create = (issues: YatspIssue[]) => {
+    const error = new YatspError(issues);
+    return error;
+  };
+
+  static assert(value: unknown): asserts value is YatspError {
+    if (!(value instanceof YatspError)) {
+      throw new Error(`Not a YatspError: ${value}`);
+    }
+  }
+
+  override toString() {
+    return this.message;
+  }
+  override get message() {
+    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+  }
+
+  get isEmpty(): boolean {
+    return this.issues.length === 0;
+  }
+
+  addIssue = (sub: YatspIssue) => {
+    this.issues = [...this.issues, sub];
+  };
+
+  addIssues = (subs: YatspIssue[] = []) => {
+    this.issues = [...this.issues, ...subs];
+  };
+
+  flatten(): typeToFlattenedError<T>;
+  flatten<U>(mapper?: (issue: YatspIssue) => U): typeToFlattenedError<T, U>;
+  flatten<U = string>(mapper: (issue: YatspIssue) => U = (issue: YatspIssue) => issue.message as any): any {
+    const fieldErrors: any = Object.create(null);
+    const formErrors: U[] = [];
+    for (const sub of this.issues) {
+      if (sub.path.length > 0) {
+        const firstEl = sub.path[0]!;
+        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
+        fieldErrors[firstEl].push(mapper(sub));
+      } else {
+        formErrors.push(mapper(sub));
+      }
+    }
+    return { formErrors, fieldErrors };
+  }
+
+  get formErrors() {
+    return this.flatten();
+  }
+}
+
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+
+export type IssueData = stripPath<YatspIssueOptionalMessage> & {
+  path?: (string | number)[];
+  fatal?: boolean | undefined;
+};
+
+export type ErrorMapCtx = {
+  defaultError: string;
+  data: any;
+};
+
+export type YatspErrorMap = (issue: YatspIssueOptionalMessage, _ctx: ErrorMapCtx) => { message: string };

package/src/v3/benchmarks/datetime.ts

@@ -0,0 +1,58 @@
+import Benchmark from "benchmark";
+
+const datetimeValidationSuite = new Benchmark.Suite("datetime");
+
+const DATA = "2021-01-01";
+const MONTHS_31 = new Set([1, 3, 5, 7, 8, 10, 12]);
+const MONTHS_30 = new Set([4, 6, 9, 11]);
+
+const simpleDatetimeRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+const datetimeRegexNoLeapYearValidation =
+  /^\d{4}-((0[13578]|10|12)-31|(0[13-9]|1[0-2])-30|(0[1-9]|1[0-2])-(0[1-9]|1\d|2\d))$/;
+const datetimeRegexWithLeapYearValidation =
+  /^((\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\d|3[01])|(0[469]|11)-(0[1-9]|[12]\d|30)|(02)-(0[1-9]|1\d|2[0-8])))$/;
+
+datetimeValidationSuite
+  .add("new Date()", () => {
+    return !Number.isNaN(new Date(DATA).getTime());
+  })
+  .add("regex (no validation)", () => {
+    return simpleDatetimeRegex.test(DATA);
+  })
+  .add("regex (no leap year)", () => {
+    return datetimeRegexNoLeapYearValidation.test(DATA);
+  })
+  .add("regex (w/ leap year)", () => {
+    return datetimeRegexWithLeapYearValidation.test(DATA);
+  })
+  .add("capture groups + code", () => {
+    const match = DATA.match(simpleDatetimeRegex);
+    if (!match) return false;
+
+    // Extract year, month, and day from the capture groups
+    const year = Number.parseInt(match[1], 10);
+    const month = Number.parseInt(match[2], 10); // month is 0-indexed in JavaScript Date, so subtract 1
+    const day = Number.parseInt(match[3], 10);
+
+    if (month === 2) {
+      if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
+        return day <= 29;
+      }
+      return day <= 28;
+    }
+    if (MONTHS_30.has(month)) {
+      return day <= 30;
+    }
+    if (MONTHS_31.has(month)) {
+      return day <= 31;
+    }
+    return false;
+  })
+
+  .on("cycle", (e: Benchmark.Event) => {
+    console.log(`${datetimeValidationSuite.name!}: ${e.target}`);
+  });
+
+export default {
+  suites: [datetimeValidationSuite],
+};

package/src/v3/benchmarks/discriminatedUnion.ts

@@ -0,0 +1,80 @@
+import Benchmark from "benchmark";
+
+import { z } from "yatsp/v3";
+
+const doubleSuite = new Benchmark.Suite("z.discriminatedUnion: double");
+const manySuite = new Benchmark.Suite("z.discriminatedUnion: many");
+
+const aSchema = z.object({
+  type: z.literal("a"),
+});
+const objA = {
+  type: "a",
+};
+
+const bSchema = z.object({
+  type: z.literal("b"),
+});
+const objB = {
+  type: "b",
+};
+
+const cSchema = z.object({
+  type: z.literal("c"),
+});
+const objC = {
+  type: "c",
+};
+
+const dSchema = z.object({
+  type: z.literal("d"),
+});
+
+const double = z.discriminatedUnion("type", [aSchema, bSchema]);
+const many = z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
+
+doubleSuite
+  .add("valid: a", () => {
+    double.parse(objA);
+  })
+  .add("valid: b", () => {
+    double.parse(objB);
+  })
+  .add("invalid: null", () => {
+    try {
+      double.parse(null);
+    } catch (_err) {}
+  })
+  .add("invalid: wrong shape", () => {
+    try {
+      double.parse(objC);
+    } catch (_err) {}
+  })
+  .on("cycle", (e: Benchmark.Event) => {
+    console.log(`${(doubleSuite as any).name}: ${e.target}`);
+  });
+
+manySuite
+  .add("valid: a", () => {
+    many.parse(objA);
+  })
+  .add("valid: c", () => {
+    many.parse(objC);
+  })
+  .add("invalid: null", () => {
+    try {
+      many.parse(null);
+    } catch (_err) {}
+  })
+  .add("invalid: wrong shape", () => {
+    try {
+      many.parse({ type: "unknown" });
+    } catch (_err) {}
+  })
+  .on("cycle", (e: Benchmark.Event) => {
+    console.log(`${(manySuite as any).name}: ${e.target}`);
+  });
+
+export default {
+  suites: [doubleSuite, manySuite],
+};