@ubundi/openclaw-cortex 1.5.0 → 1.5.1

package/node_modules/zod/src/v3/tests/language-server.test.ts

@@ -1,207 +0,0 @@
-import { test } from "vitest";
-// import path from "path";
-// import { Node, Project, SyntaxKind } from "ts-morph";
-
-// import { filePath } from "./language-server.source";
-
-// The following tool is helpful for understanding the TypeScript AST associated with these tests:
-// https://ts-ast-viewer.com/ (just copy the contents of language-server.source into the viewer)
-
-test("", () => {});
-// describe("Executing Go To Definition (and therefore Find Usages and Rename Refactoring) using an IDE works on inferred object properties", () => {
-//   // Compile file developmentEnvironment.source
-//   const project = new Project({
-//     tsConfigFilePath: path.join(__dirname, "..", "..", "tsconfig.json"),
-//     skipAddingFilesFromTsConfig: true,
-//   });
-//   const sourceFile = project.addSourceFileAtPath(filePath);
-
-//   test("works for object properties inferred from z.object()", () => {
-//     // Find usage of Test.f1 property
-//     const instanceVariable =
-//       sourceFile.getVariableDeclarationOrThrow("instanceOfTest");
-//     const propertyBeingAssigned = getPropertyBeingAssigned(
-//       instanceVariable,
-//       "f1"
-//     );
-
-//     // Find definition of Test.f1 property
-//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//       SyntaxKind.VariableDeclaration
-//     );
-
-//     // Assert that find definition returned the Zod definition of Test
-//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
-//     expect(parentOfProperty?.getName()).toEqual("Test");
-//   });
-
-//   // test("works for first object properties inferred from z.object().merge()", () => {
-//   //   // Find usage of TestMerge.f1 property
-//   //   const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
-//   //     "instanceOfTestMerge"
-//   //   );
-//   //   const propertyBeingAssigned = getPropertyBeingAssigned(
-//   //     instanceVariable,
-//   //     "f1"
-//   //   );
-
-//   //   // Find definition of TestMerge.f1 property
-//   //   const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//   //   const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//   //     SyntaxKind.VariableDeclaration
-//   //   );
-
-//   //   // Assert that find definition returned the Zod definition of Test
-//   //   expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
-//   //   expect(parentOfProperty?.getName()).toEqual("Test");
-//   // });
-
-//   // test("works for second object properties inferred from z.object().merge()", () => {
-//   //   // Find usage of TestMerge.f2 property
-//   //   const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
-//   //     "instanceOfTestMerge"
-//   //   );
-//   //   const propertyBeingAssigned = getPropertyBeingAssigned(
-//   //     instanceVariable,
-//   //     "f2"
-//   //   );
-
-//   //   // Find definition of TestMerge.f2 property
-//   //   const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//   //   const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//   //     SyntaxKind.VariableDeclaration
-//   //   );
-
-//   //   // Assert that find definition returned the Zod definition of TestMerge
-//   //   expect(definitionOfProperty?.getText()).toEqual(
-//   //     "f2: z.string().optional()"
-//   //   );
-//   //   expect(parentOfProperty?.getName()).toEqual("TestMerge");
-//   // });
-
-//   test("works for first object properties inferred from z.union()", () => {
-//     // Find usage of TestUnion.f1 property
-//     const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
-//       "instanceOfTestUnion"
-//     );
-//     const propertyBeingAssigned = getPropertyBeingAssigned(
-//       instanceVariable,
-//       "f1"
-//     );
-
-//     // Find definition of TestUnion.f1 property
-//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//       SyntaxKind.VariableDeclaration
-//     );
-
-//     // Assert that find definition returned the Zod definition of Test
-//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
-//     expect(parentOfProperty?.getName()).toEqual("Test");
-//   });
-
-//   test("works for second object properties inferred from z.union()", () => {
-//     // Find usage of TestUnion.f2 property
-//     const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
-//       "instanceOfTestUnion"
-//     );
-//     const propertyBeingAssigned = getPropertyBeingAssigned(
-//       instanceVariable,
-//       "f2"
-//     );
-
-//     // Find definition of TestUnion.f2 property
-//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//       SyntaxKind.VariableDeclaration
-//     );
-
-//     // Assert that find definition returned the Zod definition of TestUnion
-//     expect(definitionOfProperty?.getText()).toEqual(
-//       "f2: z.string().optional()"
-//     );
-//     expect(parentOfProperty?.getName()).toEqual("TestUnion");
-//   });
-
-//   test("works for object properties inferred from z.object().partial()", () => {
-//     // Find usage of TestPartial.f1 property
-//     const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
-//       "instanceOfTestPartial"
-//     );
-//     const propertyBeingAssigned = getPropertyBeingAssigned(
-//       instanceVariable,
-//       "f1"
-//     );
-
-//     // Find definition of TestPartial.f1 property
-//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//       SyntaxKind.VariableDeclaration
-//     );
-
-//     // Assert that find definition returned the Zod definition of Test
-//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
-//     expect(parentOfProperty?.getName()).toEqual("Test");
-//   });
-
-//   test("works for object properties inferred from z.object().pick()", () => {
-//     // Find usage of TestPick.f1 property
-//     const instanceVariable =
-//       sourceFile.getVariableDeclarationOrThrow("instanceOfTestPick");
-//     const propertyBeingAssigned = getPropertyBeingAssigned(
-//       instanceVariable,
-//       "f1"
-//     );
-
-//     // Find definition of TestPick.f1 property
-//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//       SyntaxKind.VariableDeclaration
-//     );
-
-//     // Assert that find definition returned the Zod definition of Test
-//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
-//     expect(parentOfProperty?.getName()).toEqual("Test");
-//   });
-
-//   test("works for object properties inferred from z.object().omit()", () => {
-//     // Find usage of TestOmit.f1 property
-//     const instanceVariable =
-//       sourceFile.getVariableDeclarationOrThrow("instanceOfTestOmit");
-//     const propertyBeingAssigned = getPropertyBeingAssigned(
-//       instanceVariable,
-//       "f1"
-//     );
-
-//     // Find definition of TestOmit.f1 property
-//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
-//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
-//       SyntaxKind.VariableDeclaration
-//     );
-
-//     // Assert that find definition returned the Zod definition of Test
-//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
-//     expect(parentOfProperty?.getName()).toEqual("Test");
-//   });
-// });
-
-// const getPropertyBeingAssigned = (node: Node, name: string) => {
-//   const propertyAssignment = node.forEachDescendant((descendent) =>
-//     Node.isPropertyAssignment(descendent) && descendent.getName() == name
-//       ? descendent
-//       : undefined
-//   );
-
-//   if (propertyAssignment == null)
-//     fail(`Could not find property assignment with name ${name}`);
-
-//   const propertyLiteral = propertyAssignment.getFirstDescendantByKind(
-//     SyntaxKind.Identifier
-//   );
-
-//   if (propertyLiteral == null)
-//     fail(`Could not find property literal with name ${name}`);
-
-//   return propertyLiteral;
-// };

package/node_modules/zod/src/v3/tests/literal.test.ts

@@ -1,36 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const literalTuna = z.literal("tuna");
-const literalFortyTwo = z.literal(42);
-const literalTrue = z.literal(true);
-
-const terrificSymbol = Symbol("terrific");
-const literalTerrificSymbol = z.literal(terrificSymbol);
-
-test("passing validations", () => {
-  literalTuna.parse("tuna");
-  literalFortyTwo.parse(42);
-  literalTrue.parse(true);
-  literalTerrificSymbol.parse(terrificSymbol);
-});
-
-test("failing validations", () => {
-  expect(() => literalTuna.parse("shark")).toThrow();
-  expect(() => literalFortyTwo.parse(43)).toThrow();
-  expect(() => literalTrue.parse(false)).toThrow();
-  expect(() => literalTerrificSymbol.parse(Symbol("terrific"))).toThrow();
-});
-
-test("invalid_literal should have `received` field with data", () => {
-  const data = "shark";
-  const result = literalTuna.safeParse(data);
-  if (!result.success) {
-    const issue = result.error.issues[0];
-    if (issue.code === "invalid_literal") {
-      expect(issue.received).toBe(data);
-    }
-  }
-});

package/node_modules/zod/src/v3/tests/map.test.ts

@@ -1,110 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { ZodIssueCode } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const stringMap = z.map(z.string(), z.string());
-type stringMap = z.infer<typeof stringMap>;
-
-test("type inference", () => {
-  util.assertEqual<stringMap, Map<string, string>>(true);
-});
-
-test("valid parse", () => {
-  const result = stringMap.safeParse(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(true);
-  if (result.success) {
-    expect(result.data.has("first")).toEqual(true);
-    expect(result.data.has("second")).toEqual(true);
-    expect(result.data.get("first")).toEqual("foo");
-    expect(result.data.get("second")).toEqual("bar");
-  }
-});
-
-test("valid parse async", async () => {
-  const result = await stringMap.spa(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(true);
-  if (result.success) {
-    expect(result.data.has("first")).toEqual(true);
-    expect(result.data.has("second")).toEqual(true);
-    expect(result.data.get("first")).toEqual("foo");
-    expect(result.data.get("second")).toEqual("bar");
-  }
-});
-
-test("throws when a Set is given", () => {
-  const result = stringMap.safeParse(new Set([]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(1);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
-  }
-});
-
-test("throws when the given map has invalid key and invalid input", () => {
-  const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[0].path).toEqual([0, "key"]);
-    expect(result.error.issues[1].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[1].path).toEqual([0, "value"]);
-  }
-});
-
-test("throws when the given map has multiple invalid entries", () => {
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-
-  const result = stringMap.safeParse(
-    new Map([
-      [1, "foo"],
-      ["bar", 2],
-    ] as [any, any][]) as Map<any, any>
-  );
-
-  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
-  expect(result.success).toEqual(false);
-  if (result.success === false) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[0].path).toEqual([0, "key"]);
-    expect(result.error.issues[1].code).toEqual(ZodIssueCode.invalid_type);
-    expect(result.error.issues[1].path).toEqual([1, "value"]);
-  }
-});
-
-test("dirty", async () => {
-  const map = z.map(
-    z.string().refine((val) => val === val.toUpperCase(), {
-      message: "Keys must be uppercase",
-    }),
-    z.string()
-  );
-  const result = await map.spa(
-    new Map([
-      ["first", "foo"],
-      ["second", "bar"],
-    ])
-  );
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.custom);
-    expect(result.error.issues[0].message).toEqual("Keys must be uppercase");
-    expect(result.error.issues[1].code).toEqual(z.ZodIssueCode.custom);
-    expect(result.error.issues[1].message).toEqual("Keys must be uppercase");
-  }
-});

package/node_modules/zod/src/v3/tests/masking.test.ts

@@ -1,4 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-test("masking test", () => {});

package/node_modules/zod/src/v3/tests/mocker.test.ts

@@ -1,19 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import { Mocker } from "./Mocker.js";
-
-test("mocker", () => {
-  const mocker = new Mocker();
-  mocker.string;
-  mocker.number;
-  mocker.boolean;
-  mocker.null;
-  mocker.undefined;
-  mocker.stringOptional;
-  mocker.stringNullable;
-  mocker.numberOptional;
-  mocker.numberNullable;
-  mocker.booleanOptional;
-  mocker.booleanNullable;
-});

package/node_modules/zod/src/v3/tests/nan.test.ts

@@ -1,21 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const schema = z.nan();
-
-test("passing validations", () => {
-  schema.parse(Number.NaN);
-  schema.parse(Number("Not a number"));
-});
-
-test("failing validations", () => {
-  expect(() => schema.parse(5)).toThrow();
-  expect(() => schema.parse("John")).toThrow();
-  expect(() => schema.parse(true)).toThrow();
-  expect(() => schema.parse(null)).toThrow();
-  expect(() => schema.parse(undefined)).toThrow();
-  expect(() => schema.parse({})).toThrow();
-  expect(() => schema.parse([])).toThrow();
-});

package/node_modules/zod/src/v3/tests/nativeEnum.test.ts

@@ -1,87 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("nativeEnum test with consts", () => {
-  const Fruits: { Apple: "apple"; Banana: "banana" } = {
-    Apple: "apple",
-    Banana: "banana",
-  };
-  const fruitEnum = z.nativeEnum(Fruits);
-  type fruitEnum = z.infer<typeof fruitEnum>;
-  fruitEnum.parse("apple");
-  fruitEnum.parse("banana");
-  fruitEnum.parse(Fruits.Apple);
-  fruitEnum.parse(Fruits.Banana);
-  util.assertEqual<fruitEnum, "apple" | "banana">(true);
-});
-
-test("nativeEnum test with real enum", () => {
-  enum Fruits {
-    Apple = "apple",
-    Banana = "banana",
-  }
-  // @ts-ignore
-  const fruitEnum = z.nativeEnum(Fruits);
-  type fruitEnum = z.infer<typeof fruitEnum>;
-  fruitEnum.parse("apple");
-  fruitEnum.parse("banana");
-  fruitEnum.parse(Fruits.Apple);
-  fruitEnum.parse(Fruits.Banana);
-  util.assertIs<fruitEnum extends Fruits ? true : false>(true);
-});
-
-test("nativeEnum test with const with numeric keys", () => {
-  const FruitValues = {
-    Apple: 10,
-    Banana: 20,
-    // @ts-ignore
-  } as const;
-  const fruitEnum = z.nativeEnum(FruitValues);
-  type fruitEnum = z.infer<typeof fruitEnum>;
-  fruitEnum.parse(10);
-  fruitEnum.parse(20);
-  fruitEnum.parse(FruitValues.Apple);
-  fruitEnum.parse(FruitValues.Banana);
-  util.assertEqual<fruitEnum, 10 | 20>(true);
-});
-
-test("from enum", () => {
-  enum Fruits {
-    Cantaloupe = 0,
-    Apple = "apple",
-    Banana = "banana",
-  }
-
-  const FruitEnum = z.nativeEnum(Fruits as any);
-  type _FruitEnum = z.infer<typeof FruitEnum>;
-  FruitEnum.parse(Fruits.Cantaloupe);
-  FruitEnum.parse(Fruits.Apple);
-  FruitEnum.parse("apple");
-  FruitEnum.parse(0);
-  expect(() => FruitEnum.parse(1)).toThrow();
-  expect(() => FruitEnum.parse("Apple")).toThrow();
-  expect(() => FruitEnum.parse("Cantaloupe")).toThrow();
-});
-
-test("from const", () => {
-  const Greek = {
-    Alpha: "a",
-    Beta: "b",
-    Gamma: 3,
-    // @ts-ignore
-  } as const;
-
-  const GreekEnum = z.nativeEnum(Greek);
-  type _GreekEnum = z.infer<typeof GreekEnum>;
-  GreekEnum.parse("a");
-  GreekEnum.parse("b");
-  GreekEnum.parse(3);
-  expect(() => GreekEnum.parse("v")).toThrow();
-  expect(() => GreekEnum.parse("Alpha")).toThrow();
-  expect(() => GreekEnum.parse(2)).toThrow();
-
-  expect(GreekEnum.enum.Alpha).toEqual("a");
-});

package/node_modules/zod/src/v3/tests/nullable.test.ts

@@ -1,42 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-function checkErrors(a: z.ZodTypeAny, bad: any) {
-  let expected: any;
-  try {
-    a.parse(bad);
-  } catch (error) {
-    expected = (error as z.ZodError).formErrors;
-  }
-  try {
-    a.nullable().parse(bad);
-  } catch (error) {
-    expect((error as z.ZodError).formErrors).toEqual(expected);
-  }
-}
-
-test("Should have error messages appropriate for the underlying type", () => {
-  checkErrors(z.string().min(2), 1);
-  z.string().min(2).nullable().parse(null);
-  checkErrors(z.number().gte(2), 1);
-  z.number().gte(2).nullable().parse(null);
-  checkErrors(z.boolean(), "");
-  z.boolean().nullable().parse(null);
-  checkErrors(z.null(), null);
-  z.null().nullable().parse(null);
-  checkErrors(z.null(), {});
-  z.null().nullable().parse(null);
-  checkErrors(z.object({}), 1);
-  z.object({}).nullable().parse(null);
-  checkErrors(z.tuple([]), 1);
-  z.tuple([]).nullable().parse(null);
-  checkErrors(z.unknown(), 1);
-  z.unknown().nullable().parse(null);
-});
-
-test("unwrap", () => {
-  const unwrapped = z.string().nullable().unwrap();
-  expect(unwrapped).toBeInstanceOf(z.ZodString);
-});