@vitos-pizza/vitos-pizza 0.2.0 → 0.3.1

package/packages/permission-system/node_modules/zod/src/v3/benchmarks/primitives.ts

@@ -1,162 +0,0 @@
-import Benchmark from "benchmark";
-
-import { z } from "zod/v3";
-import { Mocker } from "../tests/Mocker.js";
-
-const val = new Mocker();
-
-const enumSuite = new Benchmark.Suite("z.enum");
-const enumSchema = z.enum(["a", "b", "c"]);
-
-enumSuite
-  .add("valid", () => {
-    enumSchema.parse("a");
-  })
-  .add("invalid", () => {
-    try {
-      enumSchema.parse("x");
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`z.enum: ${e.target}`);
-  });
-
-const longEnumSuite = new Benchmark.Suite("long z.enum");
-const longEnumSchema = z.enum([
-  "one",
-  "two",
-  "three",
-  "four",
-  "five",
-  "six",
-  "seven",
-  "eight",
-  "nine",
-  "ten",
-  "eleven",
-  "twelve",
-  "thirteen",
-  "fourteen",
-  "fifteen",
-  "sixteen",
-  "seventeen",
-]);
-
-longEnumSuite
-  .add("valid", () => {
-    longEnumSchema.parse("five");
-  })
-  .add("invalid", () => {
-    try {
-      longEnumSchema.parse("invalid");
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`long z.enum: ${e.target}`);
-  });
-
-const undefinedSuite = new Benchmark.Suite("z.undefined");
-const undefinedSchema = z.undefined();
-
-undefinedSuite
-  .add("valid", () => {
-    undefinedSchema.parse(undefined);
-  })
-  .add("invalid", () => {
-    try {
-      undefinedSchema.parse(1);
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`z.undefined: ${e.target}`);
-  });
-
-const literalSuite = new Benchmark.Suite("z.literal");
-const short = "short";
-const bad = "bad";
-const literalSchema = z.literal("short");
-
-literalSuite
-  .add("valid", () => {
-    literalSchema.parse(short);
-  })
-  .add("invalid", () => {
-    try {
-      literalSchema.parse(bad);
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`z.literal: ${e.target}`);
-  });
-
-const numberSuite = new Benchmark.Suite("z.number");
-const numberSchema = z.number().int();
-
-numberSuite
-  .add("valid", () => {
-    numberSchema.parse(1);
-  })
-  .add("invalid type", () => {
-    try {
-      numberSchema.parse("bad");
-    } catch (_e: any) {}
-  })
-  .add("invalid number", () => {
-    try {
-      numberSchema.parse(0.5);
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`z.number: ${e.target}`);
-  });
-
-const dateSuite = new Benchmark.Suite("z.date");
-
-const plainDate = z.date();
-const minMaxDate = z.date().min(new Date("2021-01-01")).max(new Date("2030-01-01"));
-
-dateSuite
-  .add("valid", () => {
-    plainDate.parse(new Date());
-  })
-  .add("invalid", () => {
-    try {
-      plainDate.parse(1);
-    } catch (_e: any) {}
-  })
-  .add("valid min and max", () => {
-    minMaxDate.parse(new Date("2023-01-01"));
-  })
-  .add("invalid min", () => {
-    try {
-      minMaxDate.parse(new Date("2019-01-01"));
-    } catch (_e: any) {}
-  })
-  .add("invalid max", () => {
-    try {
-      minMaxDate.parse(new Date("2031-01-01"));
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`z.date: ${e.target}`);
-  });
-
-const symbolSuite = new Benchmark.Suite("z.symbol");
-const symbolSchema = z.symbol();
-
-symbolSuite
-  .add("valid", () => {
-    symbolSchema.parse(val.symbol);
-  })
-  .add("invalid", () => {
-    try {
-      symbolSchema.parse(1);
-    } catch (_e: any) {}
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`z.symbol: ${e.target}`);
-  });
-
-export default {
-  suites: [enumSuite, longEnumSuite, undefinedSuite, literalSuite, numberSuite, dateSuite, symbolSuite],
-};

package/packages/permission-system/node_modules/zod/src/v3/benchmarks/realworld.ts

@@ -1,63 +0,0 @@
-import Benchmark from "benchmark";
-
-import { z } from "zod/v3";
-
-const shortSuite = new Benchmark.Suite("realworld");
-
-const People = z.array(
-  z.object({
-    type: z.literal("person"),
-    hair: z.enum(["blue", "brown"]),
-    active: z.boolean(),
-    name: z.string(),
-    age: z.number().int(),
-    hobbies: z.array(z.string()),
-    address: z.object({
-      street: z.string(),
-      zip: z.string(),
-      country: z.string(),
-    }),
-  })
-);
-
-let i = 0;
-
-function num() {
-  return ++i;
-}
-
-function str() {
-  return (++i % 100).toString(16);
-}
-
-function array<T>(fn: () => T): T[] {
-  return Array.from({ length: ++i % 10 }, () => fn());
-}
-
-const people = Array.from({ length: 100 }, () => {
-  return {
-    type: "person",
-    hair: i % 2 ? "blue" : "brown",
-    active: !!(i % 2),
-    name: str(),
-    age: num(),
-    hobbies: array(str),
-    address: {
-      street: str(),
-      zip: str(),
-      country: str(),
-    },
-  };
-});
-
-shortSuite
-  .add("valid", () => {
-    People.parse(people);
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`${(shortSuite as any).name}: ${e.target}`);
-  });
-
-export default {
-  suites: [shortSuite],
-};

package/packages/permission-system/node_modules/zod/src/v3/benchmarks/string.ts

@@ -1,55 +0,0 @@
-import Benchmark from "benchmark";
-
-import { z } from "zod/v3";
-
-const SUITE_NAME = "z.string";
-const suite = new Benchmark.Suite(SUITE_NAME);
-
-const empty = "";
-const short = "short";
-const long = "long".repeat(256);
-const manual = (str: unknown) => {
-  if (typeof str !== "string") {
-    throw new Error("Not a string");
-  }
-
-  return str;
-};
-const stringSchema = z.string();
-const optionalStringSchema = z.string().optional();
-const optionalNullableStringSchema = z.string().optional().nullable();
-
-suite
-  .add("empty string", () => {
-    stringSchema.parse(empty);
-  })
-  .add("short string", () => {
-    stringSchema.parse(short);
-  })
-  .add("long string", () => {
-    stringSchema.parse(long);
-  })
-  .add("optional string", () => {
-    optionalStringSchema.parse(long);
-  })
-  .add("nullable string", () => {
-    optionalNullableStringSchema.parse(long);
-  })
-  .add("nullable (null) string", () => {
-    optionalNullableStringSchema.parse(null);
-  })
-  .add("invalid: null", () => {
-    try {
-      stringSchema.parse(null);
-    } catch (_err) {}
-  })
-  .add("manual parser: long", () => {
-    manual(long);
-  })
-  .on("cycle", (e: Benchmark.Event) => {
-    console.log(`${SUITE_NAME}: ${e.target}`);
-  });
-
-export default {
-  suites: [suite],
-};

package/packages/permission-system/node_modules/zod/src/v3/benchmarks/union.ts

@@ -1,80 +0,0 @@
-import Benchmark from "benchmark";
-
-import { z } from "zod/v3";
-
-const doubleSuite = new Benchmark.Suite("z.union: double");
-const manySuite = new Benchmark.Suite("z.union: 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.union([aSchema, bSchema]);
-const many = z.union([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],
-};

package/packages/permission-system/node_modules/zod/src/v3/errors.ts

@@ -1,13 +0,0 @@
-import type { ZodErrorMap } from "./ZodError.js";
-import defaultErrorMap from "./locales/en.js";
-
-let overrideErrorMap = defaultErrorMap;
-export { defaultErrorMap };
-
-export function setErrorMap(map: ZodErrorMap) {
-  overrideErrorMap = map;
-}
-
-export function getErrorMap() {
-  return overrideErrorMap;
-}

package/packages/permission-system/node_modules/zod/src/v3/external.ts

@@ -1,6 +0,0 @@
-export * from "./errors.js";
-export * from "./helpers/parseUtil.js";
-export * from "./helpers/typeAliases.js";
-export * from "./helpers/util.js";
-export * from "./types.js";
-export * from "./ZodError.js";

package/packages/permission-system/node_modules/zod/src/v3/helpers/enumUtil.ts

@@ -1,17 +0,0 @@
-export namespace enumUtil {
-  type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (
-    k: infer Intersection
-  ) => void
-    ? Intersection
-    : never;
-
-  type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
-
-  type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never]
-    ? Tuple
-    : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
-
-  type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
-
-  export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
-}

package/packages/permission-system/node_modules/zod/src/v3/helpers/errorUtil.ts

@@ -1,8 +0,0 @@
-export namespace errorUtil {
-  export type ErrMessage = string | { message?: string | undefined };
-  export const errToObj = (message?: ErrMessage): { message?: string | undefined } =>
-    typeof message === "string" ? { message } : message || {};
-  // biome-ignore lint:
-  export const toString = (message?: ErrMessage): string | undefined =>
-    typeof message === "string" ? message : message?.message;
-}

package/packages/permission-system/node_modules/zod/src/v3/helpers/parseUtil.ts

@@ -1,176 +0,0 @@
-import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError.js";
-import { getErrorMap } from "../errors.js";
-import defaultErrorMap from "../locales/en.js";
-import type { ZodParsedType } from "./util.js";
-
-export const makeIssue = (params: {
-  data: any;
-  path: (string | number)[];
-  errorMaps: ZodErrorMap[];
-  issueData: IssueData;
-}): ZodIssue => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...(issueData.path || [])];
-  const fullIssue = {
-    ...issueData,
-    path: fullPath,
-  };
-
-  if (issueData.message !== undefined) {
-    return {
-      ...issueData,
-      path: fullPath,
-      message: issueData.message,
-    };
-  }
-
-  let errorMessage = "";
-  const maps = errorMaps
-    .filter((m) => !!m)
-    .slice()
-    .reverse();
-  for (const map of maps) {
-    errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
-  }
-
-  return {
-    ...issueData,
-    path: fullPath,
-    message: errorMessage,
-  };
-};
-
-export type ParseParams = {
-  path: (string | number)[];
-  errorMap: ZodErrorMap;
-  async: boolean;
-};
-
-export type ParsePathComponent = string | number;
-export type ParsePath = ParsePathComponent[];
-export const EMPTY_PATH: ParsePath = [];
-
-export interface ParseContext {
-  readonly common: {
-    readonly issues: ZodIssue[];
-    readonly contextualErrorMap?: ZodErrorMap | undefined;
-    readonly async: boolean;
-  };
-  readonly path: ParsePath;
-  readonly schemaErrorMap?: ZodErrorMap | undefined;
-  readonly parent: ParseContext | null;
-  readonly data: any;
-  readonly parsedType: ZodParsedType;
-}
-
-export type ParseInput = {
-  data: any;
-  path: (string | number)[];
-  parent: ParseContext;
-};
-
-export function addIssueToContext(ctx: ParseContext, issueData: IssueData): void {
-  const overrideMap = getErrorMap();
-  const issue = makeIssue({
-    issueData: issueData,
-    data: ctx.data,
-    path: ctx.path,
-    errorMaps: [
-      ctx.common.contextualErrorMap, // contextual error map is first priority
-      ctx.schemaErrorMap, // then schema-bound map if available
-      overrideMap, // then global override map
-      overrideMap === defaultErrorMap ? undefined : defaultErrorMap, // then global default map
-    ].filter((x) => !!x),
-  });
-  ctx.common.issues.push(issue);
-}
-
-export type ObjectPair = {
-  key: SyncParseReturnType<any>;
-  value: SyncParseReturnType<any>;
-};
-export class ParseStatus {
-  value: "aborted" | "dirty" | "valid" = "valid";
-  dirty(): void {
-    if (this.value === "valid") this.value = "dirty";
-  }
-  abort(): void {
-    if (this.value !== "aborted") this.value = "aborted";
-  }
-
-  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType {
-    const arrayValue: any[] = [];
-    for (const s of results) {
-      if (s.status === "aborted") return INVALID;
-      if (s.status === "dirty") status.dirty();
-      arrayValue.push(s.value);
-    }
-
-    return { status: status.value, value: arrayValue };
-  }
-
-  static async mergeObjectAsync(
-    status: ParseStatus,
-    pairs: { key: ParseReturnType<any>; value: ParseReturnType<any> }[]
-  ): Promise<SyncParseReturnType<any>> {
-    const syncPairs: ObjectPair[] = [];
-    for (const pair of pairs) {
-      const key = await pair.key;
-      const value = await pair.value;
-      syncPairs.push({
-        key,
-        value,
-      });
-    }
-    return ParseStatus.mergeObjectSync(status, syncPairs);
-  }
-
-  static mergeObjectSync(
-    status: ParseStatus,
-    pairs: {
-      key: SyncParseReturnType<any>;
-      value: SyncParseReturnType<any>;
-      alwaysSet?: boolean;
-    }[]
-  ): SyncParseReturnType {
-    const finalObject: any = {};
-    for (const pair of pairs) {
-      const { key, value } = pair;
-      if (key.status === "aborted") return INVALID;
-      if (value.status === "aborted") return INVALID;
-      if (key.status === "dirty") status.dirty();
-      if (value.status === "dirty") status.dirty();
-
-      if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
-        finalObject[key.value] = value.value;
-      }
-    }
-
-    return { status: status.value, value: finalObject };
-  }
-}
-export interface ParseResult {
-  status: "aborted" | "dirty" | "valid";
-  data: any;
-}
-
-export type INVALID = { status: "aborted" };
-export const INVALID: INVALID = Object.freeze({
-  status: "aborted",
-});
-
-export type DIRTY<T> = { status: "dirty"; value: T };
-export const DIRTY = <T>(value: T): DIRTY<T> => ({ status: "dirty", value });
-
-export type OK<T> = { status: "valid"; value: T };
-export const OK = <T>(value: T): OK<T> => ({ status: "valid", value });
-
-export type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-export type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-export type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
-
-export const isAborted = (x: ParseReturnType<any>): x is INVALID => (x as any).status === "aborted";
-export const isDirty = <T>(x: ParseReturnType<T>): x is OK<T> | DIRTY<T> => (x as any).status === "dirty";
-export const isValid = <T>(x: ParseReturnType<T>): x is OK<T> => (x as any).status === "valid";
-export const isAsync = <T>(x: ParseReturnType<T>): x is AsyncParseReturnType<T> =>
-  typeof Promise !== "undefined" && x instanceof Promise;

package/packages/permission-system/node_modules/zod/src/v3/helpers/partialUtil.ts

@@ -1,34 +0,0 @@
-import type {
-  ZodArray,
-  ZodNullable,
-  ZodObject,
-  ZodOptional,
-  ZodRawShape,
-  ZodTuple,
-  ZodTupleItems,
-  ZodTypeAny,
-} from "../types.js";
-
-export namespace partialUtil {
-  export type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape>
-    ? ZodObject<
-        { [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> },
-        T["_def"]["unknownKeys"],
-        T["_def"]["catchall"]
-      >
-    : T extends ZodArray<infer Type, infer Card>
-      ? ZodArray<DeepPartial<Type>, Card>
-      : T extends ZodOptional<infer Type>
-        ? ZodOptional<DeepPartial<Type>>
-        : T extends ZodNullable<infer Type>
-          ? ZodNullable<DeepPartial<Type>>
-          : T extends ZodTuple<infer Items>
-            ? {
-                [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
-              } extends infer PI
-              ? PI extends ZodTupleItems
-                ? ZodTuple<PI>
-                : never
-              : never
-            : T;
-}

package/packages/permission-system/node_modules/zod/src/v3/helpers/typeAliases.ts

@@ -1,2 +0,0 @@
-export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-export type Scalars = Primitive | Primitive[];