@wecode-ai/weibo-openclaw-plugin 1.0.0 → 1.0.2

package/node_modules/zod/src/v4/classic/tests/pickomit.test.ts

@@ -0,0 +1,211 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+const fish = z.object({
+  name: z.string(),
+  age: z.number(),
+  nested: z.object({}),
+});
+
+test("pick type inference", () => {
+  const nameonlyFish = fish.pick({ name: true });
+  type nameonlyFish = z.infer<typeof nameonlyFish>;
+  expectTypeOf<nameonlyFish>().toEqualTypeOf<{ name: string }>();
+});
+
+test("pick parse - success", () => {
+  const nameonlyFish = fish.pick({ name: true });
+  nameonlyFish.parse({ name: "bob" });
+
+  // @ts-expect-error checking runtime picks `name` only.
+  const anotherNameonlyFish = fish.pick({ name: true, age: false });
+  anotherNameonlyFish.parse({ name: "bob" });
+});
+
+test("pick parse - fail", () => {
+  fish.pick({ name: true }).parse({ name: "12" } as any);
+  fish.pick({ name: true }).parse({ name: "bob", age: 12 } as any);
+  fish.pick({ age: true }).parse({ age: 12 } as any);
+
+  const nameonlyFish = fish.pick({ name: true }).strict();
+  const bad1 = () => nameonlyFish.parse({ name: 12 } as any);
+  const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 } as any);
+  const bad3 = () => nameonlyFish.parse({ age: 12 } as any);
+
+  // @ts-expect-error checking runtime picks `name` only.
+  const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
+  const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 } as any);
+
+  expect(bad1).toThrow();
+  expect(bad2).toThrow();
+  expect(bad3).toThrow();
+  expect(bad4).toThrow();
+});
+
+test("pick - remove optional", () => {
+  const schema = z.object({ a: z.string(), b: z.string().optional() });
+  expect("a" in schema._zod.def.shape).toEqual(true);
+  expect("b" in schema._zod.def.shape!).toEqual(true);
+  const picked = schema.pick({ a: true });
+  expect("a" in picked._zod.def.shape).toEqual(true);
+  expect("b" in picked._zod.def.shape!).toEqual(false);
+});
+
+test("omit type inference", () => {
+  const nonameFish = fish.omit({ name: true });
+  type nonameFish = z.infer<typeof nonameFish>;
+
+  expectTypeOf<nonameFish>().toEqualTypeOf<{ age: number; nested: Record<string, never> }>();
+});
+
+test("omit parse - success", () => {
+  const nonameFish = fish.omit({ name: true });
+  nonameFish.parse({ age: 12, nested: {} });
+
+  // @ts-expect-error checking runtime omits `name` only.
+  const anotherNonameFish = fish.omit({ name: true, age: false });
+  anotherNonameFish.parse({ age: 12, nested: {} });
+});
+
+test("omit parse - fail", () => {
+  const nonameFish = fish.omit({ name: true });
+  const bad1 = () => nonameFish.parse({ name: 12 } as any);
+  const bad2 = () => nonameFish.parse({ age: 12 } as any);
+  const bad3 = () => nonameFish.parse({} as any);
+
+  // @ts-expect-error checking runtime omits `name` only.
+  const anotherNonameFish = fish.omit({ name: true, age: false });
+  const bad4 = () => anotherNonameFish.parse({ nested: {} } as any);
+
+  expect(bad1).toThrow();
+  expect(bad2).toThrow();
+  expect(bad3).toThrow();
+  expect(bad4).toThrow();
+});
+
+test("omit - remove optional", () => {
+  const schema = z.object({ a: z.string(), b: z.string().optional() });
+  expect("a" in schema._zod.def.shape).toEqual(true);
+  const omitted = schema.omit({ a: true });
+  expect("a" in omitted._zod.def.shape).toEqual(false);
+});
+
+test("nonstrict inference", () => {
+  const laxfish = fish.pick({ name: true }).catchall(z.any());
+  type laxfish = z.infer<typeof laxfish>;
+  expectTypeOf<laxfish>().toEqualTypeOf<{ name: string; [k: string]: any }>();
+});
+
+test("nonstrict parsing - pass", () => {
+  const laxfish = fish.passthrough().pick({ name: true });
+  laxfish.parse({ name: "asdf", whatever: "asdf" });
+  laxfish.parse({ name: "asdf", age: 12, nested: {} });
+});
+
+test("nonstrict parsing - fail", () => {
+  const laxfish = fish.passthrough().pick({ name: true });
+  const bad = () => laxfish.parse({ whatever: "asdf" } as any);
+  expect(bad).toThrow();
+});
+
+test("pick/omit/required/partial - do not allow unknown keys", () => {
+  const schema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  // Mixed valid + invalid keys
+  // @ts-expect-error
+  expect(() => schema.pick({ name: true, asdf: true }).safeParse({})).toThrow();
+  // @ts-expect-error
+  expect(() => schema.omit({ name: true, asdf: true }).safeParse({})).toThrow();
+  // @ts-expect-error
+  expect(() => schema.partial({ name: true, asdf: true }).safeParse({})).toThrow();
+  // @ts-expect-error
+  expect(() => schema.required({ name: true, asdf: true }).safeParse({})).toThrow();
+
+  // Only invalid keys
+  // @ts-expect-error
+  expect(() => schema.pick({ $unknown: true }).safeParse({})).toThrow();
+  // @ts-expect-error
+  expect(() => schema.omit({ $unknown: true }).safeParse({})).toThrow();
+  // @ts-expect-error
+  expect(() => schema.required({ $unknown: true }).safeParse({})).toThrow();
+  // @ts-expect-error
+  expect(() => schema.partial({ $unknown: true }).safeParse({})).toThrow();
+});
+
+test("pick - throws error on schema with refinements", () => {
+  const baseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    items: z.string().array(),
+  });
+
+  const refinedSchema = baseSchema.superRefine((val, ctx) => {
+    if (val.items.length === 0) {
+      ctx.addIssue({
+        message: "Must have at least one item",
+        code: "custom",
+        path: ["items"],
+      });
+    }
+  });
+
+  expect(() => refinedSchema.pick({ name: true })).toThrow(
+    ".pick() cannot be used on object schemas containing refinements"
+  );
+});
+
+test("omit - throws error on schema with refinements", () => {
+  const baseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    items: z.string().array(),
+  });
+
+  const refinedSchema = baseSchema.superRefine((val, ctx) => {
+    if (val.items.length === 0) {
+      ctx.addIssue({
+        message: "Must have at least one item",
+        code: "custom",
+        path: ["items"],
+      });
+    }
+  });
+
+  expect(() => refinedSchema.omit({ id: true })).toThrow(
+    ".omit() cannot be used on object schemas containing refinements"
+  );
+});
+
+test("pick - throws error on schema with refine", () => {
+  const baseSchema = z.object({
+    password: z.string(),
+    confirmPassword: z.string(),
+  });
+
+  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords must match",
+  });
+
+  expect(() => refinedSchema.pick({ password: true })).toThrow(
+    ".pick() cannot be used on object schemas containing refinements"
+  );
+});
+
+test("omit - throws error on schema with refine", () => {
+  const baseSchema = z.object({
+    password: z.string(),
+    confirmPassword: z.string(),
+    email: z.string(),
+  });
+
+  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords must match",
+  });
+
+  expect(() => refinedSchema.omit({ email: true })).toThrow(
+    ".omit() cannot be used on object schemas containing refinements"
+  );
+});

package/node_modules/zod/src/v4/classic/tests/pipe.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("string to number pipe", () => {
+  const schema = z.string().transform(Number).pipe(z.number());
+  expect(schema.parse("1234")).toEqual(1234);
+});
+
+test("string to number pipe async", async () => {
+  const schema = z
+    .string()
+    .transform(async (val) => Number(val))
+    .pipe(z.number());
+  expect(await schema.parseAsync("1234")).toEqual(1234);
+});
+
+test("string with default fallback", () => {
+  const stringWithDefault = z
+    .pipe(
+      z.transform((v) => (v === "none" ? undefined : v)),
+      z.string()
+    )
+    .catch("default");
+
+  expect(stringWithDefault.parse("ok")).toBe("ok");
+  expect(stringWithDefault.parse(undefined)).toBe("default");
+  expect(stringWithDefault.parse("none")).toBe("default");
+  expect(stringWithDefault.parse(15)).toBe("default");
+});
+
+test("continue on non-fatal errors", () => {
+  const schema = z
+    .string()
+    .refine((c) => c === "1234", "A")
+    .transform((val) => Number(val))
+    .refine((c) => c === 1234, "B");
+
+  schema.parse("1234");
+
+  expect(schema.safeParse("4321")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "A"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("break on fatal errors", () => {
+  const schema = z
+    .string()
+    .refine((c) => c === "1234", { message: "A", abort: true })
+    .transform((val) => Number(val))
+    .refine((c) => c === 1234, "B");
+
+  schema.parse("1234");
+
+  expect(schema.safeParse("4321")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "A"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("reverse parsing with pipe", () => {
+  const schema = z.string().pipe(z.string());
+
+  // Reverse direction: default should NOT be applied
+  expect(z.safeDecode(schema, "asdf")).toMatchInlineSnapshot(`
+    {
+      "data": "asdf",
+      "success": true,
+    }
+  `);
+  expect(z.safeEncode(schema, "asdf")).toMatchInlineSnapshot(`
+    {
+      "data": "asdf",
+      "success": true,
+    }
+  `);
+});
+
+test("reverse parsing with pipe", () => {
+  const schema = z.string().transform((val) => val.length);
+
+  // should throw
+  expect(() => z.encode(schema, 1234)).toThrow();
+});

package/node_modules/zod/src/v4/classic/tests/prefault.test.ts

@@ -0,0 +1,74 @@
+import { expect, expectTypeOf, test } from "vitest";
+import { z } from "zod/v4";
+
+test("basic prefault", () => {
+  const a = z.prefault(z.string().trim(), "  default  ");
+  expect(a).toBeInstanceOf(z.ZodPrefault);
+  expect(a.parse("  asdf  ")).toEqual("asdf");
+  expect(a.parse(undefined)).toEqual("default");
+
+  type inp = z.input<typeof a>;
+  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
+  type out = z.output<typeof a>;
+  expectTypeOf<out>().toEqualTypeOf<string>();
+});
+
+test("prefault inside object", () => {
+  // test optinality
+  const a = z.object({
+    name: z.string().optional(),
+    age: z.number().default(1234),
+    email: z.string().prefault("1234"),
+  });
+
+  type inp = z.input<typeof a>;
+  expectTypeOf<inp>().toEqualTypeOf<{
+    name?: string | undefined;
+    age?: number | undefined;
+    email?: string | undefined;
+  }>();
+
+  type out = z.output<typeof a>;
+  expectTypeOf<out>().toEqualTypeOf<{
+    name?: string | undefined;
+    age: number;
+    email: string;
+  }>();
+});
+
+test("object schema with prefault should return shallow clone", () => {
+  const schema = z
+    .object({
+      a: z.string(),
+    })
+    .default({ a: "x" });
+  const result1 = schema.parse(undefined);
+  const result2 = schema.parse(undefined);
+  expect(result1).not.toBe(result2);
+  expect(result1).toEqual(result2);
+});
+
+test("direction-aware prefault", () => {
+  const schema = z.string().prefault("hello");
+
+  // Forward direction (regular parse): prefault should be applied
+  expect(schema.parse(undefined)).toBe("hello");
+
+  // Reverse direction (encode): prefault should NOT be applied, undefined should fail validation
+  expect(z.safeEncode(schema, undefined as any)).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+
+  // But valid values should still work in reverse
+  expect(z.encode(schema, "world")).toBe("world");
+});

package/node_modules/zod/src/v4/classic/tests/preprocess.test.ts

@@ -0,0 +1,282 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("preprocess", () => {
+  const schema = z.preprocess((data) => [data], z.string().array());
+  const value = schema.parse("asdf");
+  expect(value).toEqual(["asdf"]);
+  expectTypeOf<(typeof schema)["_input"]>().toEqualTypeOf<unknown>();
+});
+
+test("async preprocess", async () => {
+  const schema = z.preprocess(async (data) => {
+    return [data];
+  }, z.string().array());
+  const value = await schema.safeParseAsync("asdf");
+  expect(value.data).toEqual(["asdf"]);
+  expect(value).toMatchInlineSnapshot(`
+    {
+      "data": [
+        "asdf",
+      ],
+      "success": true,
+    }
+  `);
+});
+
+test("ctx.addIssue accepts string", () => {
+  const schema = z.preprocess((_, ctx) => {
+    ctx.addIssue("bad stuff");
+  }, z.string());
+  const result = schema.safeParse("asdf");
+  expect(result.error!.issues).toHaveLength(1);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "message": "bad stuff",
+        "code": "custom",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("preprocess ctx.addIssue with parse", () => {
+  const a = z.preprocess((data, ctx) => {
+    ctx.addIssue({
+      input: data,
+      code: "custom",
+      message: `${data} is not one of our allowed strings`,
+    });
+    return data;
+  }, z.string());
+
+  const result = a.safeParse("asdf");
+
+  // expect(result.error!.toJSON()).toContain("not one of our allowed strings");
+
+  expect(result.error!.issues).toHaveLength(1);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("preprocess ctx.addIssue fatal by default", () => {
+  const schema = z.preprocess((data, ctx) => {
+    ctx.addIssue({
+      code: "custom",
+      message: `custom error`,
+    });
+
+    return data;
+  }, z.string());
+  const result = schema.safeParse(1234);
+
+  expect(result.error!.issues).toHaveLength(1);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("preprocess ctx.addIssue fatal true", () => {
+  const schema = z.preprocess((data, ctx) => {
+    ctx.addIssue({
+      input: data,
+      code: "custom",
+      origin: "custom",
+      message: `custom error`,
+      fatal: true,
+    });
+    return data;
+  }, z.string());
+
+  const result = schema.safeParse(1234);
+
+  expect(result.error!.issues).toHaveLength(1);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "origin": "custom",
+        "message": "custom error",
+        "fatal": true,
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("async preprocess ctx.addIssue with parseAsync", async () => {
+  const schema = z.preprocess(async (data, ctx) => {
+    ctx.addIssue({
+      input: data,
+      code: "custom",
+      message: `${data} is not one of our allowed strings`,
+    });
+    return data;
+  }, z.string());
+
+  const result = await schema.safeParseAsync("asdf");
+
+  expect(result.error!.issues).toHaveLength(1);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("z.NEVER in preprocess", () => {
+  const foo = z.preprocess((val, ctx) => {
+    if (!val) {
+      ctx.addIssue({ input: val, code: "custom", message: "bad" });
+      return z.NEVER;
+    }
+    return val;
+  }, z.number());
+
+  type foo = z.infer<typeof foo>;
+  expectTypeOf<foo>().toEqualTypeOf<number>();
+  const result = foo.safeParse(undefined);
+
+  expect(result.error!.issues).toHaveLength(1);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "bad",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("preprocess as the second property of object", () => {
+  const schema = z.object({
+    nonEmptyStr: z.string().min(1),
+    positiveNum: z.preprocess((v) => Number(v), z.number().positive()),
+  });
+  const result = schema.safeParse({
+    nonEmptyStr: "",
+    positiveNum: "",
+  });
+
+  expect(result.error!.issues).toHaveLength(2);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 1,
+        "inclusive": true,
+        "path": [
+          "nonEmptyStr"
+        ],
+        "message": "Too small: expected string to have >=1 characters"
+      },
+      {
+        "origin": "number",
+        "code": "too_small",
+        "minimum": 0,
+        "inclusive": false,
+        "path": [
+          "positiveNum"
+        ],
+        "message": "Too small: expected number to be >0"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("preprocess validates with sibling errors", () => {
+  const schema = z.object({
+    missing: z.string().refine(() => false),
+    preprocess: z.preprocess((data: any) => data?.trim(), z.string().regex(/ asdf/)),
+  });
+
+  const result = schema.safeParse({ preprocess: " asdf" });
+
+  expect(result.error!.issues).toHaveLength(2);
+  expect(result).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "missing"
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      },
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "regex",
+        "pattern": "/ asdf/",
+        "path": [
+          "preprocess"
+        ],
+        "message": "Invalid string: must match pattern / asdf/"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("perform transform with non-fatal issues", () => {
+  const A = z
+    .string()
+    .refine((_) => false)
+    .min(4)
+    .transform((val) => val.length)
+    .pipe(z.number())
+    .refine((_) => false);
+  expect(A.safeParse("asdfasdf").error!.issues).toHaveLength(1);
+  expect(A.safeParse("asdfasdf").error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
+  `);
+});