@shuttl-io/core 0.2.0

package/node_modules/zod/src/v4/core/standard-schema.ts

@@ -0,0 +1,159 @@
+/** The Standard interface. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+
+export declare namespace StandardTypedV1 {
+  /** The Standard properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+
+  /** The Standard types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+
+  /** Infers the input type of a Standard. */
+  export type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+
+  /** Infers the output type of a Standard. */
+  export type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (
+      value: unknown,
+      options?: StandardSchemaV1.Options | undefined
+    ) => Result<Output> | Promise<Result<Output>>;
+  }
+
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The absence of issues indicates success. */
+    readonly issues?: undefined;
+  }
+
+  export interface Options {
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+
+  /** The Standard types interface. */
+  export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+
+export declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: Converter;
+  }
+
+  /** The Standard JSON Schema converter interface. */
+  export interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+
+  /** The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   *
+   * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   */
+  export type Target =
+    | "draft-2020-12"
+    | "draft-07"
+    | "openapi-3.0"
+    // Accepts any string for future targets while preserving autocomplete
+    | ({} & string);
+
+  /** The options for the input/output methods. */
+  export interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+
+    /** Implicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+
+  /** The Standard types interface. */
+  export interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+
+  /** Infers the input type of a Standard. */
+  export type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+
+  /** Infers the output type of a Standard. */
+  export type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+export interface StandardSchemaWithJSONProps<Input = unknown, Output = Input>
+  extends StandardSchemaV1.Props<Input, Output>,
+    StandardJSONSchemaV1.Props<Input, Output> {}
+
+/**
+ * An interface that combines StandardJSONSchema and StandardSchema.
+ */
+export interface StandardSchemaWithJSON<Input = unknown, Output = Input> {
+  "~standard": StandardSchemaWithJSONProps<Input, Output>;
+}

package/node_modules/zod/src/v4/core/tests/extend.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("extend chaining preserves and overrides properties", () => {
+  const schema1 = z.object({
+    email: z.string(),
+  });
+
+  const schema2 = schema1.extend({
+    email: schema1.shape.email.check(z.email()),
+  });
+
+  const schema3 = schema2.extend({
+    email: schema2.shape.email.or(z.literal("")),
+  });
+
+  schema3.parse({ email: "test@example.com" });
+});
+
+test("extend with constructor field in shape", () => {
+  const baseSchema = z.object({
+    name: z.string(),
+  });
+
+  const extendedSchema = baseSchema.extend({
+    constructor: z.string(),
+    age: z.number(),
+  });
+
+  const result = extendedSchema.parse({
+    name: "John",
+    constructor: "Person",
+    age: 30,
+  });
+
+  expect(result).toEqual({
+    name: "John",
+    constructor: "Person",
+    age: 30,
+  });
+
+  const testCases = [
+    { name: "Test", constructor: 123, age: 25 },
+    { name: "Test", constructor: null, age: 25 },
+    { name: "Test", constructor: true, age: 25 },
+    { name: "Test", constructor: {}, age: 25 },
+  ];
+
+  for (const testCase of testCases) {
+    const anyConstructorSchema = baseSchema.extend({
+      constructor: z.any(),
+      age: z.number(),
+    });
+
+    expect(() => anyConstructorSchema.parse(testCase)).not.toThrow();
+    const parsed = anyConstructorSchema.parse(testCase);
+    expect(parsed).toEqual(testCase);
+  }
+});

package/node_modules/zod/src/v4/core/tests/index.test.ts

@@ -0,0 +1,46 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v3";
+
+test("test", () => {
+  expect(true).toBe(true);
+});
+
+test("test2", () => {
+  expect(() => z.string().parse(234)).toThrowErrorMatchingInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "string",
+        "received": "number",
+        "path": [],
+        "message": "Expected string, received number"
+      }
+    ]]
+  `);
+});
+
+test("async validation", async () => {
+  const testTuple = z
+    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
+    .refine(async () => true);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = await testTuple.parseAsync(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "number",
+        "received": "string",
+        "path": [
+          1
+        ],
+        "message": "Expected number, received string"
+      }
+    ]]
+  `);
+});

package/node_modules/zod/src/v4/core/tests/locales/be.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import be from "../../../locales/be.js";
+
+describe("Belarusian localization", () => {
+  const localeError = be().localeError;
+
+  describe("pluralization rules", () => {
+    for (const { type, cases } of TEST_CASES) {
+      describe(`${type} pluralization`, () => {
+        for (const { count, expected } of cases) {
+          it(`correctly pluralizes ${count} ${type}`, () => {
+            const error = localeError({
+              code: "too_small",
+              minimum: count,
+              type: "number",
+              inclusive: true,
+              path: [],
+              origin: type,
+              input: count - 1,
+            });
+            expect(error).toContain(expected);
+          });
+        }
+      });
+    }
+
+    it("handles negative numbers correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: -2,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -3,
+      });
+      expect(error).toContain("-2 элементы");
+    });
+
+    it("handles zero correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: 0,
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: -1,
+      });
+      expect(error).toContain("0 элементаў");
+    });
+
+    it("handles bigint values correctly", () => {
+      const error = localeError({
+        code: "too_small",
+        minimum: BigInt(21),
+        type: "number",
+        inclusive: true,
+        path: [],
+        origin: "array",
+        input: BigInt(20),
+      });
+      expect(error).toContain("21 элемент");
+    });
+  });
+});
+
+const TEST_CASES = [
+  {
+    type: "array",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элементы" },
+      { count: 5, expected: "5 элементаў" },
+      { count: 11, expected: "11 элементаў" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элементы" },
+      { count: 25, expected: "25 элементаў" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементаў" },
+    ],
+  },
+  {
+    type: "set",
+    cases: [
+      { count: 1, expected: "1 элемент" },
+      { count: 2, expected: "2 элементы" },
+      { count: 5, expected: "5 элементаў" },
+      { count: 11, expected: "11 элементаў" },
+      { count: 21, expected: "21 элемент" },
+      { count: 22, expected: "22 элементы" },
+      { count: 25, expected: "25 элементаў" },
+      { count: 101, expected: "101 элемент" },
+      { count: 111, expected: "111 элементаў" },
+    ],
+  },
+  {
+    type: "string",
+    cases: [
+      { count: 1, expected: "1 сімвал" },
+      { count: 2, expected: "2 сімвалы" },
+      { count: 5, expected: "5 сімвалаў" },
+      { count: 11, expected: "11 сімвалаў" },
+      { count: 21, expected: "21 сімвал" },
+      { count: 22, expected: "22 сімвалы" },
+      { count: 25, expected: "25 сімвалаў" },
+    ],
+  },
+  {
+    type: "file",
+    cases: [
+      { count: 0, expected: "0 байтаў" },
+      { count: 1, expected: "1 байт" },
+      { count: 2, expected: "2 байты" },
+      { count: 5, expected: "5 байтаў" },
+      { count: 11, expected: "11 байтаў" },
+      { count: 21, expected: "21 байт" },
+      { count: 22, expected: "22 байты" },
+      { count: 25, expected: "25 байтаў" },
+      { count: 101, expected: "101 байт" },
+      { count: 110, expected: "110 байтаў" },
+    ],
+  },
+] as const;

package/node_modules/zod/src/v4/core/tests/locales/en.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { parsedType } from "../../../locales/en.js";
+
+test("parsedType", () => {
+  expect(parsedType("string")).toBe("string");
+  expect(parsedType(1)).toBe("number");
+  expect(parsedType(true)).toBe("boolean");
+  expect(parsedType(null)).toBe("null");
+  expect(parsedType(undefined)).toBe("undefined");
+  expect(parsedType([])).toBe("array");
+  expect(parsedType({})).toBe("object");
+  expect(parsedType(new Date())).toBe("Date");
+  expect(parsedType(new Map())).toBe("Map");
+  expect(parsedType(new Set())).toBe("Set");
+  expect(parsedType(new Error())).toBe("Error");
+
+  const nullPrototype = Object.create(null);
+  expect(parsedType(nullPrototype)).toBe("object");
+
+  const doubleNullPrototype = Object.create(Object.create(null));
+  expect(parsedType(doubleNullPrototype)).toBe("object");
+});

package/node_modules/zod/src/v4/core/tests/locales/es.test.ts

@@ -0,0 +1,181 @@
+import { expect, test } from "vitest";
+import { z } from "../../../../index.js";
+import es from "../../../locales/es.js";
+
+test("Spanish locale - type name translations in too_small errors", () => {
+  z.config(es());
+
+  // Test string type translation
+  const stringSchema = z.string().min(5);
+  const stringResult = stringSchema.safeParse("abc");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe(
+      "Demasiado pequeño: se esperaba que texto tuviera >=5 caracteres"
+    );
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().min(10);
+  const numberResult = numberSchema.safeParse(5);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Demasiado pequeño: se esperaba que número fuera >=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).min(3);
+  const arrayResult = arraySchema.safeParse(["a", "b"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe(
+      "Demasiado pequeño: se esperaba que arreglo tuviera >=3 elementos"
+    );
+  }
+
+  // Test set type translation
+  const setSchema = z.set(z.string()).min(2);
+  const setResult = setSchema.safeParse(new Set(["a"]));
+  expect(setResult.success).toBe(false);
+  if (!setResult.success) {
+    expect(setResult.error.issues[0].message).toBe("Demasiado pequeño: se esperaba que conjunto tuviera >=2 elementos");
+  }
+});
+
+test("Spanish locale - type name translations in too_big errors", () => {
+  z.config(es());
+
+  // Test string type translation
+  const stringSchema = z.string().max(3);
+  const stringResult = stringSchema.safeParse("abcde");
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que texto tuviera <=3 caracteres");
+  }
+
+  // Test number type translation
+  const numberSchema = z.number().max(10);
+  const numberResult = numberSchema.safeParse(15);
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que número fuera <=10");
+  }
+
+  // Test array type translation
+  const arraySchema = z.array(z.string()).max(2);
+  const arrayResult = arraySchema.safeParse(["a", "b", "c"]);
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Demasiado grande: se esperaba que arreglo tuviera <=2 elementos");
+  }
+});
+
+test("Spanish locale - type name translations in invalid_type errors", () => {
+  z.config(es());
+
+  // Test string expected, number received
+  const stringSchema = z.string();
+  const stringResult = stringSchema.safeParse(123);
+  expect(stringResult.success).toBe(false);
+  if (!stringResult.success) {
+    expect(stringResult.error.issues[0].message).toBe("Entrada inválida: se esperaba texto, recibido número");
+  }
+
+  // Test number expected, string received
+  const numberSchema = z.number();
+  const numberResult = numberSchema.safeParse("abc");
+  expect(numberResult.success).toBe(false);
+  if (!numberResult.success) {
+    expect(numberResult.error.issues[0].message).toBe("Entrada inválida: se esperaba número, recibido texto");
+  }
+
+  // Test boolean expected, null received
+  const booleanSchema = z.boolean();
+  const booleanResult = booleanSchema.safeParse(null);
+  expect(booleanResult.success).toBe(false);
+  if (!booleanResult.success) {
+    expect(booleanResult.error.issues[0].message).toBe("Entrada inválida: se esperaba booleano, recibido nulo");
+  }
+
+  // Test array expected, object received
+  const arraySchema = z.array(z.string());
+  const arrayResult = arraySchema.safeParse({});
+  expect(arrayResult.success).toBe(false);
+  if (!arrayResult.success) {
+    expect(arrayResult.error.issues[0].message).toBe("Entrada inválida: se esperaba arreglo, recibido objeto");
+  }
+});
+
+test("Spanish locale - fallback for unknown type names", () => {
+  z.config(es());
+
+  // Test with a type that's not in the TypeNames dictionary
+  // This will test the fallback behavior
+  const dateSchema = z.date().min(new Date("2025-01-01"));
+  const dateResult = dateSchema.safeParse(new Date("2024-01-01"));
+  expect(dateResult.success).toBe(false);
+  if (!dateResult.success) {
+    // Should use "fecha" since we included it in TypeNames
+    expect(dateResult.error.issues[0].message).toContain("fecha");
+  }
+});
+
+test("Spanish locale - other error cases", () => {
+  z.config(es());
+
+  // Test invalid_element with tuple
+  const tupleSchema = z.tuple([z.string(), z.number()]);
+  const tupleResult = tupleSchema.safeParse(["abc", "not a number"]);
+  expect(tupleResult.success).toBe(false);
+  if (!tupleResult.success) {
+    expect(tupleResult.error.issues[0].message).toContain("Entrada inválida");
+  }
+
+  // Test invalid_value with enum
+  const enumSchema = z.enum(["a", "b"]);
+  const enumResult = enumSchema.safeParse("c");
+  expect(enumResult.success).toBe(false);
+  if (!enumResult.success) {
+    expect(enumResult.error.issues[0].message).toBe('Opción inválida: se esperaba una de "a"|"b"');
+  }
+
+  // Test not_multiple_of
+  const multipleSchema = z.number().multipleOf(3);
+  const multipleResult = multipleSchema.safeParse(10);
+  expect(multipleResult.success).toBe(false);
+  if (!multipleResult.success) {
+    expect(multipleResult.error.issues[0].message).toBe("Número inválido: debe ser múltiplo de 3");
+  }
+
+  // Test unrecognized_keys
+  const strictSchema = z.object({ a: z.string() }).strict();
+  const strictResult = strictSchema.safeParse({ a: "test", b: "extra" });
+  expect(strictResult.success).toBe(false);
+  if (!strictResult.success) {
+    expect(strictResult.error.issues[0].message).toBe('Llave desconocida: "b"');
+  }
+
+  // Test invalid_union
+  const unionSchema = z.union([z.string(), z.number()]);
+  const unionResult = unionSchema.safeParse(true);
+  expect(unionResult.success).toBe(false);
+  if (!unionResult.success) {
+    expect(unionResult.error.issues[0].message).toBe("Entrada inválida");
+  }
+
+  // Test invalid_format with regex
+  const regexSchema = z.string().regex(/^[a-z]+$/);
+  const regexResult = regexSchema.safeParse("ABC123");
+  expect(regexResult.success).toBe(false);
+  if (!regexResult.success) {
+    expect(regexResult.error.issues[0].message).toBe("Cadena inválida: debe coincidir con el patrón /^[a-z]+$/");
+  }
+
+  // Test invalid_format with startsWith
+  const startsWithSchema = z.string().startsWith("hello");
+  const startsWithResult = startsWithSchema.safeParse("world");
+  expect(startsWithResult.success).toBe(false);
+  if (!startsWithResult.success) {
+    expect(startsWithResult.error.issues[0].message).toBe('Cadena inválida: debe comenzar con "hello"');
+  }
+});