switchboard-cli 0.1.0-alpha.3 → 0.1.0-alpha.4

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/node_modules/zod/src/v4/classic/tests/validations.test.ts

@@ -1,283 +0,0 @@
-import { expect, test } from "vitest";
-
-import * as z from "zod/v4";
-
-test("string length", async () => {
-  try {
-    await z.string().length(4).parseAsync("asd");
-  } catch (err) {
-    // ("String must contain exactly 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "exact": true,
-          "inclusive": true,
-          "message": "Too small: expected string to have >=4 characters",
-          "minimum": 4,
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-
-  try {
-    await z.string().length(4).parseAsync("asdaa");
-  } catch (err) {
-    // ("String must contain exactly 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "exact": true,
-          "inclusive": true,
-          "maximum": 4,
-          "message": "Too big: expected string to have <=4 characters",
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("string min/max", async () => {
-  try {
-    await z.string().min(4).parseAsync("asd");
-  } catch (err) {
-    // ("String must contain at least 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected string to have >=4 characters",
-          "minimum": 4,
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("string max", async () => {
-  try {
-    await z.string().max(4).parseAsync("aasdfsdfsd");
-  } catch (err) {
-    // ("String must contain at most 4 character(s)");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 4,
-          "message": "Too big: expected string to have <=4 characters",
-          "origin": "string",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number min", async () => {
-  try {
-    await z.number().min(3).parseAsync(2);
-  } catch (err) {
-    // ("Number must be greater than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected number to be >=3",
-          "minimum": 3,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number gte", async () => {
-  try {
-    await z.number().gte(3).parseAsync(2);
-  } catch (err) {
-    // ("Number must be greater than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected number to be >=3",
-          "minimum": 3,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number gt", async () => {
-  try {
-    await z.number().gt(3).parseAsync(3);
-  } catch (err) {
-    // ("Number must be greater than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": false,
-          "message": "Too small: expected number to be >3",
-          "minimum": 3,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number max", async () => {
-  try {
-    await z.number().max(3).parseAsync(4);
-  } catch (err) {
-    // ("Number must be less than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 3,
-          "message": "Too big: expected number to be <=3",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number lte", async () => {
-  try {
-    await z.number().lte(3).parseAsync(4);
-  } catch (err) {
-    // ("Number must be less than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 3,
-          "message": "Too big: expected number to be <=3",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number lt", async () => {
-  try {
-    await z.number().lt(3).parseAsync(3);
-  } catch (err) {
-    // ("Number must be less than or equal to 3");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": false,
-          "maximum": 3,
-          "message": "Too big: expected number to be <3",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number nonnegative", async () => {
-  try {
-    await z.number().nonnegative().parseAsync(-1);
-  } catch (err) {
-    // ("Number must be greater than or equal to 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": true,
-          "message": "Too small: expected number to be >=0",
-          "minimum": 0,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number nonpositive", async () => {
-  try {
-    await z.number().nonpositive().parseAsync(1);
-  } catch (err) {
-    // ("Number must be less than or equal to 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": true,
-          "maximum": 0,
-          "message": "Too big: expected number to be <=0",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number negative", async () => {
-  try {
-    await z.number().negative().parseAsync(1);
-  } catch (err) {
-    // ("Number must be less than 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_big",
-          "inclusive": false,
-          "maximum": 0,
-          "message": "Too big: expected number to be <0",
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});
-
-test("number positive", async () => {
-  try {
-    await z.number().positive().parseAsync(-1);
-  } catch (err) {
-    // ("Number must be greater than 0");
-    expect((err as z.ZodError).issues).toMatchInlineSnapshot(`
-      [
-        {
-          "code": "too_small",
-          "inclusive": false,
-          "message": "Too small: expected number to be >0",
-          "minimum": 0,
-          "origin": "number",
-          "path": [],
-        },
-      ]
-    `);
-  }
-});

package/node_modules/@switchboard/projections/node_modules/@switchboard/core/node_modules/zod/src/v4/classic/tests/void.test.ts

@@ -1,12 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-test("void", () => {
-  const v = z.void();
-  v.parse(undefined);
-
-  expect(() => v.parse(null)).toThrow();
-  expect(() => v.parse("")).toThrow();
-
-  type v = z.infer<typeof v>;
-  expectTypeOf<v>().toEqualTypeOf<void>();
-});