@undefineds.co/xpod 0.4.18 → 0.4.19

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/helpers/util.ts

@@ -0,0 +1,224 @@
+export namespace util {
+  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+
+  export type isAny<T> = 0 extends 1 & T ? true : false;
+  export const assertEqual = <A, B>(_: AssertEqual<A, B>): void => {};
+  export function assertIs<T>(_arg: T): void {}
+  export function assertNever(_x: never): never {
+    throw new Error();
+  }
+
+  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };
+  export const arrayToEnum = <T extends string, U extends [T, ...T[]]>(items: U): { [k in U[number]]: k } => {
+    const obj: any = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+
+  export const getValidEnumValues = (obj: any): any[] => {
+    const validKeys = objectKeys(obj).filter((k: any) => typeof obj[obj[k]] !== "number");
+    const filtered: any = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return objectValues(filtered);
+  };
+
+  export const objectValues = (obj: any): any[] => {
+    return objectKeys(obj).map(function (e) {
+      return obj[e];
+    });
+  };
+
+  export const objectKeys: ObjectConstructor["keys"] =
+    typeof Object.keys === "function" // eslint-disable-line ban/ban
+      ? (obj: any) => Object.keys(obj) // eslint-disable-line ban/ban
+      : (object: any) => {
+          const keys = [];
+          for (const key in object) {
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+              keys.push(key);
+            }
+          }
+          return keys;
+        };
+
+  export const find = <T>(arr: T[], checker: (arg: T) => any): T | undefined => {
+    for (const item of arr) {
+      if (checker(item)) return item;
+    }
+    return undefined;
+  };
+
+  export type identity<T> = objectUtil.identity<T>;
+  export type flatten<T> = objectUtil.flatten<T>;
+
+  export type noUndefined<T> = T extends undefined ? never : T;
+
+  export const isInteger: NumberConstructor["isInteger"] =
+    typeof Number.isInteger === "function"
+      ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
+      : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+
+  export function joinValues<T extends any[]>(array: T, separator = " | "): string {
+    return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
+  }
+
+  export const jsonStringifyReplacer = (_: string, value: any): any => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+}
+
+export namespace objectUtil {
+  export type MergeShapes<U, V> =
+    // fast path when there is no keys overlap
+    keyof U & keyof V extends never
+      ? U & V
+      : {
+          [k in Exclude<keyof U, keyof V>]: U[k];
+        } & V;
+
+  type optionalKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? k : never;
+  }[keyof T];
+  type requiredKeys<T extends object> = {
+    [k in keyof T]: undefined extends T[k] ? never : k;
+  }[keyof T];
+  export type addQuestionMarks<T extends object, _O = any> = {
+    [K in requiredKeys<T>]: T[K];
+  } & {
+    [K in optionalKeys<T>]?: T[K];
+  } & { [k in keyof T]?: unknown };
+
+  export type identity<T> = T;
+  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
+
+  export type noNeverKeys<T> = {
+    [k in keyof T]: [T[k]] extends [never] ? never : k;
+  }[keyof T];
+
+  export type noNever<T> = identity<{
+    [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
+  }>;
+
+  export const mergeShapes = <U, T>(first: U, second: T): T & U => {
+    return {
+      ...first,
+      ...second, // second overwrites first
+    };
+  };
+
+  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never // fast path when there is no keys overlap
+    ? A & B
+    : {
+        [K in keyof A as K extends keyof B ? never : K]: A[K];
+      } & {
+        [K in keyof B]: B[K];
+      };
+}
+
+export const ZodParsedType: {
+  string: "string";
+  nan: "nan";
+  number: "number";
+  integer: "integer";
+  float: "float";
+  boolean: "boolean";
+  date: "date";
+  bigint: "bigint";
+  symbol: "symbol";
+  function: "function";
+  undefined: "undefined";
+  null: "null";
+  array: "array";
+  object: "object";
+  unknown: "unknown";
+  promise: "promise";
+  void: "void";
+  never: "never";
+  map: "map";
+  set: "set";
+} = util.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set",
+]);
+
+export type ZodParsedType = keyof typeof ZodParsedType;
+
+export const getParsedType = (data: any): ZodParsedType => {
+  const t = typeof data;
+
+  switch (t) {
+    case "undefined":
+      return ZodParsedType.undefined;
+
+    case "string":
+      return ZodParsedType.string;
+
+    case "number":
+      return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
+
+    case "boolean":
+      return ZodParsedType.boolean;
+
+    case "function":
+      return ZodParsedType.function;
+
+    case "bigint":
+      return ZodParsedType.bigint;
+
+    case "symbol":
+      return ZodParsedType.symbol;
+
+    case "object":
+      if (Array.isArray(data)) {
+        return ZodParsedType.array;
+      }
+      if (data === null) {
+        return ZodParsedType.null;
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return ZodParsedType.promise;
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return ZodParsedType.map;
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return ZodParsedType.set;
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return ZodParsedType.date;
+      }
+      return ZodParsedType.object;
+
+    default:
+      return ZodParsedType.unknown;
+  }
+};

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/index.ts

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

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/locales/en.ts

@@ -0,0 +1,124 @@
+import { type ZodErrorMap, ZodIssueCode } from "../ZodError.js";
+import { util, ZodParsedType } from "../helpers/util.js";
+
+const errorMap: ZodErrorMap = (issue, _ctx) => {
+  let message: string;
+  switch (issue.code) {
+    case ZodIssueCode.invalid_type:
+      if (issue.received === ZodParsedType.undefined) {
+        message = "Required";
+      } else {
+        message = `Expected ${issue.expected}, received ${issue.received}`;
+      }
+      break;
+    case ZodIssueCode.invalid_literal:
+      message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+      break;
+    case ZodIssueCode.unrecognized_keys:
+      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+      break;
+    case ZodIssueCode.invalid_union:
+      message = `Invalid input`;
+      break;
+    case ZodIssueCode.invalid_union_discriminator:
+      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+      break;
+    case ZodIssueCode.invalid_enum_value:
+      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+      break;
+    case ZodIssueCode.invalid_arguments:
+      message = `Invalid function arguments`;
+      break;
+    case ZodIssueCode.invalid_return_type:
+      message = `Invalid function return type`;
+      break;
+    case ZodIssueCode.invalid_date:
+      message = `Invalid date`;
+      break;
+    case ZodIssueCode.invalid_string:
+      if (typeof issue.validation === "object") {
+        if ("includes" in issue.validation) {
+          message = `Invalid input: must include "${issue.validation.includes}"`;
+
+          if (typeof issue.validation.position === "number") {
+            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
+          }
+        } else if ("startsWith" in issue.validation) {
+          message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+        } else if ("endsWith" in issue.validation) {
+          message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+        } else {
+          util.assertNever(issue.validation);
+        }
+      } else if (issue.validation !== "regex") {
+        message = `Invalid ${issue.validation}`;
+      } else {
+        message = "Invalid";
+      }
+      break;
+    case ZodIssueCode.too_small:
+      if (issue.type === "array")
+        message = `Array must contain ${
+          issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`
+        } ${issue.minimum} element(s)`;
+      else if (issue.type === "string")
+        message = `String must contain ${
+          issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`
+        } ${issue.minimum} character(s)`;
+      else if (issue.type === "number")
+        message = `Number must be ${
+          issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `
+        }${issue.minimum}`;
+      else if (issue.type === "bigint")
+        message = `Number must be ${
+          issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `
+        }${issue.minimum}`;
+      else if (issue.type === "date")
+        message = `Date must be ${
+          issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `
+        }${new Date(Number(issue.minimum))}`;
+      else message = "Invalid input";
+      break;
+    case ZodIssueCode.too_big:
+      if (issue.type === "array")
+        message = `Array must contain ${
+          issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`
+        } ${issue.maximum} element(s)`;
+      else if (issue.type === "string")
+        message = `String must contain ${
+          issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`
+        } ${issue.maximum} character(s)`;
+      else if (issue.type === "number")
+        message = `Number must be ${
+          issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`
+        } ${issue.maximum}`;
+      else if (issue.type === "bigint")
+        message = `BigInt must be ${
+          issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`
+        } ${issue.maximum}`;
+      else if (issue.type === "date")
+        message = `Date must be ${
+          issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`
+        } ${new Date(Number(issue.maximum))}`;
+      else message = "Invalid input";
+      break;
+    case ZodIssueCode.custom:
+      message = `Invalid input`;
+      break;
+    case ZodIssueCode.invalid_intersection_types:
+      message = `Intersection results could not be merged`;
+      break;
+    case ZodIssueCode.not_multiple_of:
+      message = `Number must be a multiple of ${issue.multipleOf}`;
+      break;
+    case ZodIssueCode.not_finite:
+      message = "Number must be finite";
+      break;
+    default:
+      message = _ctx.defaultError;
+      util.assertNever(issue);
+  }
+  return { message };
+};
+
+export default errorMap;

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/standard-schema.ts

@@ -0,0 +1,113 @@
+/**
+ * The Standard Schema interface.
+ */
+export type 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"];
+
+  // biome-ignore lint/complexity/noUselessEmptyExport: needed for granular visibility control of TS namespace
+  export {};
+}

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/tests/Mocker.ts

@@ -0,0 +1,54 @@
+function getRandomInt(max: number) {
+  return Math.floor(Math.random() * Math.floor(max));
+}
+
+const testSymbol = Symbol("test");
+
+export class Mocker {
+  pick = (...args: any[]): any => {
+    return args[getRandomInt(args.length)];
+  };
+
+  get string(): string {
+    return Math.random().toString(36).substring(7);
+  }
+  get number(): number {
+    return Math.random() * 100;
+  }
+  get bigint(): bigint {
+    return BigInt(Math.floor(Math.random() * 10000));
+  }
+  get boolean(): boolean {
+    return Math.random() < 0.5;
+  }
+  get date(): Date {
+    return new Date(Math.floor(Date.now() * Math.random()));
+  }
+  get symbol(): symbol {
+    return testSymbol;
+  }
+  get null(): null {
+    return null;
+  }
+  get undefined(): undefined {
+    return undefined;
+  }
+  get stringOptional(): string | undefined {
+    return this.pick(this.string, this.undefined);
+  }
+  get stringNullable(): string | null {
+    return this.pick(this.string, this.null);
+  }
+  get numberOptional(): number | undefined {
+    return this.pick(this.number, this.undefined);
+  }
+  get numberNullable(): number | null {
+    return this.pick(this.number, this.null);
+  }
+  get booleanOptional(): boolean | undefined {
+    return this.pick(this.boolean, this.undefined);
+  }
+  get booleanNullable(): boolean | null {
+    return this.pick(this.boolean, this.null);
+  }
+}

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/tests/all-errors.test.ts

@@ -0,0 +1,157 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const Test = z.object({
+  f1: z.number(),
+  f2: z.string().optional(),
+  f3: z.string().nullable(),
+  f4: z.array(z.object({ t: z.union([z.string(), z.boolean()]) })),
+});
+type TestFlattenedErrors = z.inferFlattenedErrors<typeof Test, { message: string; code: number }>;
+type TestFormErrors = z.inferFlattenedErrors<typeof Test>;
+
+test("default flattened errors type inference", () => {
+  type TestTypeErrors = {
+    formErrors: string[];
+    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] };
+  };
+
+  util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);
+  util.assertEqual<z.inferFlattenedErrors<typeof Test, { message: string }>, TestTypeErrors>(false);
+});
+
+test("custom flattened errors type inference", () => {
+  type ErrorType = { message: string; code: number };
+  type TestTypeErrors = {
+    formErrors: ErrorType[];
+    fieldErrors: {
+      [P in keyof z.TypeOf<typeof Test>]?: ErrorType[];
+    };
+  };
+
+  util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(false);
+  util.assertEqual<z.inferFlattenedErrors<typeof Test, { message: string; code: number }>, TestTypeErrors>(true);
+  util.assertEqual<z.inferFlattenedErrors<typeof Test, { message: string }>, TestTypeErrors>(false);
+});
+
+test("form errors type inference", () => {
+  type TestTypeErrors = {
+    formErrors: string[];
+    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] };
+  };
+
+  util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);
+});
+
+test(".flatten() type assertion", () => {
+  const parsed = Test.safeParse({}) as z.SafeParseError<void>;
+  const validFlattenedErrors: TestFlattenedErrors = parsed.error.flatten(() => ({ message: "", code: 0 }));
+  // @ts-expect-error should fail assertion between `TestFlattenedErrors` and unmapped `flatten()`.
+  const invalidFlattenedErrors: TestFlattenedErrors = parsed.error.flatten();
+  const validFormErrors: TestFormErrors = parsed.error.flatten();
+  // @ts-expect-error should fail assertion between `TestFormErrors` and mapped `flatten()`.
+  const invalidFormErrors: TestFormErrors = parsed.error.flatten(() => ({
+    message: "string",
+    code: 0,
+  }));
+
+  [validFlattenedErrors, invalidFlattenedErrors, validFormErrors, invalidFormErrors];
+});
+
+test(".formErrors type assertion", () => {
+  const parsed = Test.safeParse({}) as z.SafeParseError<void>;
+  const validFormErrors: TestFormErrors = parsed.error.formErrors;
+  // @ts-expect-error should fail assertion between `TestFlattenedErrors` and `.formErrors`.
+  const invalidFlattenedErrors: TestFlattenedErrors = parsed.error.formErrors;
+
+  [validFormErrors, invalidFlattenedErrors];
+});
+
+test("all errors", () => {
+  const propertySchema = z.string();
+  const schema = z
+    .object({
+      a: propertySchema,
+      b: propertySchema,
+    })
+    .refine(
+      (val) => {
+        return val.a === val.b;
+      },
+      { message: "Must be equal" }
+    );
+
+  try {
+    schema.parse({
+      a: "asdf",
+      b: "qwer",
+    });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      expect(error.flatten()).toEqual({
+        formErrors: ["Must be equal"],
+        fieldErrors: {},
+      });
+    }
+  }
+
+  try {
+    schema.parse({
+      a: null,
+      b: null,
+    });
+  } catch (_error) {
+    const error = _error as z.ZodError;
+    expect(error.flatten()).toEqual({
+      formErrors: [],
+      fieldErrors: {
+        a: ["Expected string, received null"],
+        b: ["Expected string, received null"],
+      },
+    });
+
+    expect(error.flatten((iss) => iss.message.toUpperCase())).toEqual({
+      formErrors: [],
+      fieldErrors: {
+        a: ["EXPECTED STRING, RECEIVED NULL"],
+        b: ["EXPECTED STRING, RECEIVED NULL"],
+      },
+    });
+    // Test identity
+
+    expect(error.flatten((i: z.ZodIssue) => i)).toEqual({
+      formErrors: [],
+      fieldErrors: {
+        a: [
+          {
+            code: "invalid_type",
+            expected: "string",
+            message: "Expected string, received null",
+            path: ["a"],
+            received: "null",
+          },
+        ],
+        b: [
+          {
+            code: "invalid_type",
+            expected: "string",
+            message: "Expected string, received null",
+            path: ["b"],
+            received: "null",
+          },
+        ],
+      },
+    });
+    // Test mapping
+    expect(error.flatten((i: z.ZodIssue) => i.message.length)).toEqual({
+      formErrors: [],
+      fieldErrors: {
+        a: ["Expected string, received null".length],
+        b: ["Expected string, received null".length],
+      },
+    });
+  }
+});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v3/tests/anyunknown.test.ts

@@ -0,0 +1,28 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("check any inference", () => {
+  const t1 = z.any();
+  t1.optional();
+  t1.nullable();
+  type t1 = z.infer<typeof t1>;
+  util.assertEqual<t1, any>(true);
+});
+
+test("check unknown inference", () => {
+  const t1 = z.unknown();
+  t1.optional();
+  t1.nullable();
+  type t1 = z.infer<typeof t1>;
+  util.assertEqual<t1, unknown>(true);
+});
+
+test("check never inference", () => {
+  const t1 = z.never();
+  expect(() => t1.parse(undefined)).toThrow();
+  expect(() => t1.parse("asdf")).toThrow();
+  expect(() => t1.parse(null)).toThrow();
+});