pi-codex-auto-review 0.1.2 → 0.1.3

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

@@ -1,64 +0,0 @@
-/** 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> {
-    /** The version number of the standard. */
-    readonly version: 1;
-    /** The vendor name of the schema library. */
-    readonly vendor: string;
-    /** Validates unknown input values. */
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-    /** Inferred types associated with the schema. */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-
-  /** 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 non-existent issues. */
-    readonly issues?: 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 Schema 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 Schema. */
-  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-
-  /** Infers the output type of a Standard Schema. */
-  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-}

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

@@ -1,46 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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/ru.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from "vitest";
-import ru from "../../../locales/ru.js";
-
-describe("Russian localization", () => {
-  const localeError = ru().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/tr.test.ts

@@ -1,69 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-import { parsedType } from "../../../locales/tr.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");
-
-  expect(parsedType(Number.NaN)).toBe("NaN");
-});
-
-test("locales - tr", () => {
-  z.config(z.locales.tr());
-
-  const invalidType = z.number().safeParse("a");
-  expect(invalidType.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidType.error!.issues[0].message).toBe("Geçersiz değer: beklenen number, alınan string");
-
-  const invalidType2 = z.string().safeParse(1);
-  expect(invalidType2.error!.issues[0].code).toBe("invalid_type");
-  expect(invalidType2.error!.issues[0].message).toBe("Geçersiz değer: beklenen string, alınan number");
-
-  const invalidValue = z.enum(["a", "b"]).safeParse(1);
-  expect(invalidValue.error!.issues[0].code).toBe("invalid_value");
-  expect(invalidValue.error!.issues[0].message).toBe('Geçersiz seçenek: aşağıdakilerden biri olmalı: "a"|"b"');
-
-  const tooBig = z.number().max(10).safeParse(15);
-  expect(tooBig.error!.issues[0].code).toBe("too_big");
-  expect(tooBig.error!.issues[0].message).toBe("Çok büyük: beklenen number <=10");
-
-  const tooSmall = z.number().min(10).safeParse(5);
-  expect(tooSmall.error!.issues[0].code).toBe("too_small");
-  expect(tooSmall.error!.issues[0].message).toBe("Çok küçük: beklenen number >=10");
-
-  const invalidFormatRegex = z.string().regex(/abcd/).safeParse("invalid-string");
-  expect(invalidFormatRegex.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatRegex.error!.issues[0].message).toBe("Geçersiz metin: /abcd/ desenine uymalı");
-
-  const invalidFormatStartsWith = z.string().startsWith("abcd").safeParse("invalid-string");
-  expect(invalidFormatStartsWith.error!.issues[0].code).toBe("invalid_format");
-  expect(invalidFormatStartsWith.error!.issues[0].message).toBe('Geçersiz metin: "abcd" ile başlamalı');
-
-  const notMultipleOf = z.number().multipleOf(3).safeParse(10);
-  expect(notMultipleOf.error!.issues[0].code).toBe("not_multiple_of");
-  expect(notMultipleOf.error!.issues[0].message).toBe("Geçersiz sayı: 3 ile tam bölünebilmeli");
-
-  const unrecognizedKeys = z.object({ a: z.string(), b: z.number() }).strict().safeParse({ a: "a", b: 1, c: 2 });
-  expect(unrecognizedKeys.error!.issues[0].code).toBe("unrecognized_keys");
-  expect(unrecognizedKeys.error!.issues[0].message).toBe('Tanınmayan anahtar: "c"');
-
-  const invalidUnion = z.union([z.string(), z.number()]).safeParse(true);
-  expect(invalidUnion.error!.issues[0].code).toBe("invalid_union");
-  expect(invalidUnion.error!.issues[0].message).toBe("Geçersiz değer");
-});