ostacky 0.5.5 → 0.5.7

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/firstparty.test.ts

@@ -1,87 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("first party switch", () => {
-  const myType = z.string() as z.ZodFirstPartySchemaTypes;
-  const def = myType._def;
-
-  switch (def.typeName) {
-    case z.ZodFirstPartyTypeKind.ZodString:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodNumber:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodNaN:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodBigInt:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodBoolean:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodDate:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodUndefined:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodNull:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodAny:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodUnknown:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodNever:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodVoid:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodArray:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodObject:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodUnion:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodIntersection:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodTuple:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodRecord:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodMap:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodSet:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodFunction:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodLazy:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodLiteral:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodEnum:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodEffects:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodNativeEnum:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodOptional:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodNullable:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodDefault:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodCatch:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodPromise:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodBranded:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodPipeline:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodSymbol:
-      break;
-    case z.ZodFirstPartyTypeKind.ZodReadonly:
-      break;
-    default:
-      util.assertNever(def);
-  }
-});

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/firstpartyschematypes.test.ts

@@ -1,21 +0,0 @@
-// @ts-ignore TS6133
-import { test } from "vitest";
-
-import type { ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("Identify missing [ZodFirstPartySchemaTypes]", () => {
-  type ZodFirstPartySchemaForType<T extends ZodFirstPartyTypeKind> = ZodFirstPartySchemaTypes extends infer Schema
-    ? Schema extends { _def: { typeName: T } }
-      ? Schema
-      : never
-    : never;
-  type ZodMappedTypes = {
-    [key in ZodFirstPartyTypeKind]: ZodFirstPartySchemaForType<key>;
-  };
-  type ZodFirstPartySchemaTypesMissingFromUnion = keyof {
-    [key in keyof ZodMappedTypes as ZodMappedTypes[key] extends { _def: never } ? key : never]: unknown;
-  };
-
-  util.assertEqual<ZodFirstPartySchemaTypesMissingFromUnion, never>(true);
-});

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/function.test.ts

@@ -1,261 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const args1 = z.tuple([z.string()]);
-const returns1 = z.number();
-const func1 = z.function(args1, returns1);
-
-test("function parsing", () => {
-  const parsed = func1.parse((arg: any) => arg.length);
-  const result = parsed("asdf");
-  expect(result).toBe(4);
-});
-
-test("parsed function fail 1", () => {
-  const parsed = func1.parse((x: string) => x);
-  expect(() => parsed("asdf")).toThrow();
-});
-
-test("parsed function fail 2", () => {
-  const parsed = func1.parse((x: string) => x);
-  expect(() => parsed(13 as any)).toThrow();
-});
-
-test("function inference 1", () => {
-  type func1 = z.TypeOf<typeof func1>;
-  util.assertEqual<func1, (k: string) => number>(true);
-});
-
-test("method parsing", () => {
-  const methodObject = z.object({
-    property: z.number(),
-    method: z.function().args(z.string()).returns(z.number()),
-  });
-  const methodInstance = {
-    property: 3,
-    method: function (s: string) {
-      return s.length + this.property;
-    },
-  };
-  const parsed = methodObject.parse(methodInstance);
-  expect(parsed.method("length=8")).toBe(11); // 8 length + 3 property
-});
-
-test("async method parsing", async () => {
-  const methodObject = z.object({
-    property: z.number(),
-    method: z.function().args(z.string()).returns(z.promise(z.number())),
-  });
-  const methodInstance = {
-    property: 3,
-    method: async function (s: string) {
-      return s.length + this.property;
-    },
-  };
-  const parsed = methodObject.parse(methodInstance);
-  expect(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
-});
-
-test("args method", () => {
-  const t1 = z.function();
-  type t1 = z.infer<typeof t1>;
-  util.assertEqual<t1, (...args_1: unknown[]) => unknown>(true);
-
-  const t2 = t1.args(z.string());
-  type t2 = z.infer<typeof t2>;
-  util.assertEqual<t2, (arg: string, ...args_1: unknown[]) => unknown>(true);
-
-  const t3 = t2.returns(z.boolean());
-  type t3 = z.infer<typeof t3>;
-  util.assertEqual<t3, (arg: string, ...args_1: unknown[]) => boolean>(true);
-});
-
-const args2 = z.tuple([
-  z.object({
-    f1: z.number(),
-    f2: z.string().nullable(),
-    f3: z.array(z.boolean().optional()).optional(),
-  }),
-]);
-const returns2 = z.union([z.string(), z.number()]);
-
-const func2 = z.function(args2, returns2);
-
-test("function inference 2", () => {
-  type func2 = z.TypeOf<typeof func2>;
-  util.assertEqual<
-    func2,
-    (arg: {
-      f1: number;
-      f2: string | null;
-      f3?: (boolean | undefined)[] | undefined;
-    }) => string | number
-  >(true);
-});
-
-test("valid function run", () => {
-  const validFunc2Instance = func2.validate((_x) => {
-    return "adf" as any;
-  });
-
-  const checker = () => {
-    validFunc2Instance({
-      f1: 21,
-      f2: "asdf",
-      f3: [true, false],
-    });
-  };
-
-  checker();
-});
-
-test("input validation error", () => {
-  const invalidFuncInstance = func2.validate((_x) => {
-    return "adf" as any;
-  });
-
-  const checker = () => {
-    invalidFuncInstance("Invalid_input" as any);
-  };
-
-  expect(checker).toThrow();
-});
-
-test("output validation error", () => {
-  const invalidFuncInstance = func2.validate((_x) => {
-    return ["this", "is", "not", "valid", "output"] as any;
-  });
-
-  const checker = () => {
-    invalidFuncInstance({
-      f1: 21,
-      f2: "asdf",
-      f3: [true, false],
-    });
-  };
-
-  expect(checker).toThrow();
-});
-
-z.function(z.tuple([z.string()])).args()._def.args;
-
-test("special function error codes", () => {
-  const checker = z.function(z.tuple([z.string()]), z.boolean()).implement((arg) => {
-    return arg.length as any;
-  });
-  try {
-    checker("12" as any);
-  } catch (err) {
-    const zerr = err as z.ZodError;
-    const first = zerr.issues[0];
-    if (first.code !== z.ZodIssueCode.invalid_return_type) throw new Error();
-
-    expect(first.returnTypeError).toBeInstanceOf(z.ZodError);
-  }
-
-  try {
-    checker(12 as any);
-  } catch (err) {
-    const zerr = err as z.ZodError;
-    const first = zerr.issues[0];
-    if (first.code !== z.ZodIssueCode.invalid_arguments) throw new Error();
-    expect(first.argumentsError).toBeInstanceOf(z.ZodError);
-  }
-});
-
-test("function with async refinements", async () => {
-  const func = z
-    .function()
-    .args(z.string().refine(async (val) => val.length > 10))
-    .returns(z.promise(z.number().refine(async (val) => val > 10)))
-    .implement(async (val) => {
-      return val.length;
-    });
-  const results = [];
-  try {
-    await func("asdfasdf");
-    results.push("success");
-  } catch (_err) {
-    results.push("fail");
-  }
-  try {
-    await func("asdflkjasdflkjsf");
-    results.push("success");
-  } catch (_err) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["fail", "success"]);
-});
-
-test("non async function with async refinements should fail", async () => {
-  const func = z
-    .function()
-    .args(z.string().refine(async (val) => val.length > 10))
-    .returns(z.number().refine(async (val) => val > 10))
-    .implement((val) => {
-      return val.length;
-    });
-
-  const results = [];
-  try {
-    await func("asdasdfasdffasdf");
-    results.push("success");
-  } catch (_err) {
-    results.push("fail");
-  }
-
-  expect(results).toEqual(["fail"]);
-});
-
-test("allow extra parameters", () => {
-  const maxLength5 = z
-    .function()
-    .args(z.string())
-    .returns(z.boolean())
-    .implement((str, _arg, _qewr) => {
-      return str.length <= 5;
-    });
-
-  const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
-  expect(filteredList.length).toEqual(2);
-});
-
-test("params and returnType getters", () => {
-  const func = z.function().args(z.string()).returns(z.string());
-
-  const paramResult = func.parameters().items[0].parse("asdf");
-  expect(paramResult).toBe("asdf");
-
-  const returnResult = func.returnType().parse("asdf");
-  expect(returnResult).toBe("asdf");
-});
-
-test("inference with transforms", () => {
-  const funcSchema = z
-    .function()
-    .args(z.string().transform((val) => val.length))
-    .returns(z.object({ val: z.number() }));
-  const myFunc = funcSchema.implement((val) => {
-    return { val, extra: "stuff" };
-  });
-  myFunc("asdf");
-
-  util.assertEqual<typeof myFunc, (arg: string, ...args_1: unknown[]) => { val: number; extra: string }>(true);
-});
-
-test("fallback to OuterTypeOfFunction", () => {
-  const funcSchema = z
-    .function()
-    .args(z.string().transform((val) => val.length))
-    .returns(z.object({ arg: z.number() }).transform((val) => val.arg));
-
-  const myFunc = funcSchema.implement((val) => {
-    return { arg: val, arg2: false };
-  });
-
-  util.assertEqual<typeof myFunc, (arg: string, ...args_1: unknown[]) => number>(true);
-});

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/generics.test.ts

@@ -1,48 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("generics", () => {
-  async function stripOuter<TData extends z.ZodTypeAny>(schema: TData, data: unknown) {
-    return z
-      .object({
-        nested: schema, // as z.ZodTypeAny,
-      })
-      .transform((data) => {
-        return data.nested!;
-      })
-      .parse({ nested: data });
-  }
-
-  const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
-  util.assertEqual<typeof result, Promise<{ a: string }>>(true);
-});
-
-// test("assignability", () => {
-//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(
-//     key: K,
-//     valueSchema: VS,
-//     data: unknown
-//   ) => {
-//     const schema = z.object({
-//       [key]: valueSchema,
-//     } as { [k in K]: VS });
-//     return { [key]: valueSchema };
-//     const parsed = schema.parse(data);
-//     return parsed;
-//     // const inferred: z.infer<z.ZodObject<{ [k in K]: VS }>> = parsed;
-//     // return inferred;
-//   };
-//   const parsed = createSchemaAndParse("foo", z.string(), { foo: "" });
-//   util.assertEqual<typeof parsed, { foo: string }>(true);
-// });
-
-test("nested no undefined", () => {
-  const inner = z.string().or(z.array(z.string()));
-  const outer = z.object({ inner });
-  type outerSchema = z.infer<typeof outer>;
-  z.util.assertEqual<outerSchema, { inner: string | string[] }>(true);
-  expect(outer.safeParse({ inner: undefined }).success).toEqual(false);
-});

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/instanceof.test.ts

@@ -1,37 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("instanceof", async () => {
-  class Test {}
-  class Subtest extends Test {}
-  abstract class AbstractBar {
-    constructor(public val: string) {}
-  }
-  class Bar extends AbstractBar {}
-
-  const TestSchema = z.instanceof(Test);
-  const SubtestSchema = z.instanceof(Subtest);
-  const AbstractSchema = z.instanceof(AbstractBar);
-  const BarSchema = z.instanceof(Bar);
-
-  TestSchema.parse(new Test());
-  TestSchema.parse(new Subtest());
-  SubtestSchema.parse(new Subtest());
-  AbstractSchema.parse(new Bar("asdf"));
-  const bar = BarSchema.parse(new Bar("asdf"));
-  expect(bar.val).toEqual("asdf");
-
-  await expect(() => SubtestSchema.parse(new Test())).toThrow(/Input not instance of Subtest/);
-  await expect(() => TestSchema.parse(12)).toThrow(/Input not instance of Test/);
-
-  util.assertEqual<Test, z.infer<typeof TestSchema>>(true);
-});
-
-test("instanceof fatal", () => {
-  const schema = z.instanceof(Date).refine((d) => d.toString());
-  const res = schema.safeParse(null);
-  expect(res.success).toBe(false);
-});

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/intersection.test.ts

@@ -1,110 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("object intersection", () => {
-  const BaseTeacher = z.object({
-    subjects: z.array(z.string()),
-  });
-  const HasID = z.object({ id: z.string() });
-
-  const Teacher = z.intersection(BaseTeacher.passthrough(), HasID); // BaseTeacher.merge(HasID);
-  const data = {
-    subjects: ["math"],
-    id: "asdfasdf",
-  };
-  expect(Teacher.parse(data)).toEqual(data);
-  expect(() => Teacher.parse({ subject: data.subjects })).toThrow();
-  expect(Teacher.parse({ ...data, extra: 12 })).toEqual({ ...data, extra: 12 });
-
-  expect(() => z.intersection(BaseTeacher.strict(), HasID).parse({ ...data, extra: 12 })).toThrow();
-});
-
-test("deep intersection", () => {
-  const Animal = z.object({
-    properties: z.object({
-      is_animal: z.boolean(),
-    }),
-  });
-  const Cat = z
-    .object({
-      properties: z.object({
-        jumped: z.boolean(),
-      }),
-    })
-    .and(Animal);
-
-  type _Cat = z.infer<typeof Cat>;
-  // const cat:Cat = 'asdf' as any;
-  const cat = Cat.parse({ properties: { is_animal: true, jumped: true } });
-  expect(cat.properties).toEqual({ is_animal: true, jumped: true });
-});
-
-test("deep intersection of arrays", async () => {
-  const Author = z.object({
-    posts: z.array(
-      z.object({
-        post_id: z.number(),
-      })
-    ),
-  });
-  const Registry = z
-    .object({
-      posts: z.array(
-        z.object({
-          title: z.string(),
-        })
-      ),
-    })
-    .and(Author);
-
-  const posts = [
-    { post_id: 1, title: "Novels" },
-    { post_id: 2, title: "Fairy tales" },
-  ];
-  const cat = Registry.parse({ posts });
-  expect(cat.posts).toEqual(posts);
-  const asyncCat = await Registry.parseAsync({ posts });
-  expect(asyncCat.posts).toEqual(posts);
-});
-
-test("invalid intersection types", async () => {
-  const numberIntersection = z.intersection(
-    z.number(),
-    z.number().transform((x) => x + 1)
-  );
-
-  const syncResult = numberIntersection.safeParse(1234);
-  expect(syncResult.success).toEqual(false);
-  if (!syncResult.success) {
-    expect(syncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
-  }
-
-  const asyncResult = await numberIntersection.spa(1234);
-  expect(asyncResult.success).toEqual(false);
-  if (!asyncResult.success) {
-    expect(asyncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
-  }
-});
-
-test("invalid array merge", async () => {
-  const stringArrInt = z.intersection(
-    z.string().array(),
-    z
-      .string()
-      .array()
-      .transform((val) => [...val, "asdf"])
-  );
-  const syncResult = stringArrInt.safeParse(["asdf", "qwer"]);
-  expect(syncResult.success).toEqual(false);
-  if (!syncResult.success) {
-    expect(syncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
-  }
-
-  const asyncResult = await stringArrInt.spa(["asdf", "qwer"]);
-  expect(asyncResult.success).toEqual(false);
-  if (!asyncResult.success) {
-    expect(asyncResult.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_intersection_types);
-  }
-});

package/assets/mcp/ask-user-server/node_modules/zod/src/v3/tests/language-server.source.ts

@@ -1,76 +0,0 @@
-import * as z from "zod/v3";
-
-export const filePath = __filename;
-
-// z.object()
-
-export const Test = z.object({
-  f1: z.number(),
-});
-
-export type Test = z.infer<typeof Test>;
-
-export const instanceOfTest: Test = {
-  f1: 1,
-};
-
-// z.object().merge()
-
-export const TestMerge = z
-  .object({
-    f2: z.string().optional(),
-  })
-  .merge(Test);
-
-export type TestMerge = z.infer<typeof TestMerge>;
-
-export const instanceOfTestMerge: TestMerge = {
-  f1: 1,
-  f2: "string",
-};
-
-// z.union()
-
-export const TestUnion = z.union([
-  z.object({
-    f2: z.string().optional(),
-  }),
-  Test,
-]);
-
-export type TestUnion = z.infer<typeof TestUnion>;
-
-export const instanceOfTestUnion: TestUnion = {
-  f1: 1,
-  f2: "string",
-};
-
-// z.object().partial()
-
-export const TestPartial = Test.partial();
-
-export type TestPartial = z.infer<typeof TestPartial>;
-
-export const instanceOfTestPartial: TestPartial = {
-  f1: 1,
-};
-
-// z.object().pick()
-
-export const TestPick = TestMerge.pick({ f1: true });
-
-export type TestPick = z.infer<typeof TestPick>;
-
-export const instanceOfTestPick: TestPick = {
-  f1: 1,
-};
-
-// z.object().omit()
-
-export const TestOmit = TestMerge.omit({ f2: true });
-
-export type TestOmit = z.infer<typeof TestOmit>;
-
-export const instanceOfTestOmit: TestOmit = {
-  f1: 1,
-};