@trpc-panel/core 1.0.2 → 1.0.3

package/lib/scripts/build-react.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/src/meta.d.ts

@@ -1,9 +1,5 @@
 import { z } from "zod";
 export declare const TRPCPanelMetaSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    description?: string | undefined;
-}, {
-    description?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type TRPCPanelMeta = z.infer<typeof TRPCPanelMetaSchema>;

package/lib/src/parse/__tests__/utils/router.d.ts

@@ -17,64 +17,24 @@ export declare const parseTestRouterInputSchema: z.ZodObject<{
     expectedAgeOfDeath: z.ZodOptional<z.ZodNumber>;
     object: z.ZodObject<{
         nestedId: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        nestedId: string;
-    }, {
-        nestedId: string;
-    }>;
-    du: z.ZodDiscriminatedUnion<"d", [z.ZodObject<{
+    }, z.core.$strip>;
+    du: z.ZodDiscriminatedUnion<[z.ZodObject<{
         d: z.ZodLiteral<"one">;
         oneProps: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        d: "one";
-        oneProps: string;
-    }, {
-        d: "one";
-        oneProps: string;
-    }>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         d: z.ZodLiteral<"two">;
-    }, "strip", z.ZodTypeAny, {
-        d: "two";
-    }, {
-        d: "two";
-    }>]>;
-}, "strip", z.ZodTypeAny, {
-    object: {
-        nestedId: string;
-    };
-    id: string;
-    age: number;
-    du: {
-        d: "one";
-        oneProps: string;
-    } | {
-        d: "two";
-    };
-    expectedAgeOfDeath?: number | undefined;
-}, {
-    object: {
-        nestedId: string;
-    };
-    id: string;
-    age: number;
-    du: {
-        d: "one";
-        oneProps: string;
-    } | {
-        d: "two";
-    };
-    expectedAgeOfDeath?: number | undefined;
-}>;
+    }, z.core.$strip>], "d">;
+}, z.core.$strip>;
 export declare const expectedTestRouterInputParsedNode: ObjectNode;
 export declare const testQueryExpectedParseResult: ParsedProcedure;
 export declare const testMutationExpectedParseResult: ParsedProcedure;
 export declare const testQuery: import("@trpc/server").TRPCQueryProcedure<{
     input: {
+        id: string;
+        age: number;
         object: {
             nestedId: string;
         };
-        id: string;
-        age: number;
         du: {
             d: "one";
             oneProps: string;
@@ -90,11 +50,11 @@ export declare const testQuery: import("@trpc/server").TRPCQueryProcedure<{
 }>;
 export declare const testMutation: import("@trpc/server").TRPCMutationProcedure<{
     input: {
+        id: string;
+        age: number;
         object: {
             nestedId: string;
         };
-        id: string;
-        age: number;
         du: {
             d: "one";
             oneProps: string;
@@ -118,11 +78,11 @@ export declare const parseTestRouter: import("@trpc/server").TRPCBuiltRouter<{
 }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
     testQuery: import("@trpc/server").TRPCQueryProcedure<{
         input: {
+            id: string;
+            age: number;
             object: {
                 nestedId: string;
             };
-            id: string;
-            age: number;
             du: {
                 d: "one";
                 oneProps: string;
@@ -138,11 +98,11 @@ export declare const parseTestRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     testMutation: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            id: string;
+            age: number;
             object: {
                 nestedId: string;
             };
-            id: string;
-            age: number;
             du: {
                 d: "one";
                 oneProps: string;

package/lib/src/parse/input-mappers/zod/parsers/parseZodArrayDef.d.ts

@@ -1,3 +1,14 @@
-import { ZodArrayDef } from "zod";
 import { ArrayNode, ParseFunction } from "../../../parseNodeTypes";
-export declare const parseZodArrayDef: ParseFunction<ZodArrayDef, ArrayNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4ArrayDef extends ZodDefWithType {
+    type: "array";
+    element: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+}
+export declare const parseZodArrayDef: ParseFunction<ZodV4ArrayDef, ArrayNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodBigIntDef.d.ts

@@ -1,3 +1,7 @@
-import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodBigIntDef } from "zod";
-export declare function parseZodBigIntDef(def: ZodBigIntDef, refs: ParseReferences): ParsedInputNode;
+import { NumberNode, ParseFunction } from "../../../parseNodeTypes";
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4BigIntDef extends ZodDefWithType {
+    type: "bigint";
+}
+export declare const parseZodBigIntDef: ParseFunction<ZodV4BigIntDef, NumberNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodBooleanFieldDef.d.ts

@@ -1,3 +1,7 @@
-import { ZodBooleanDef } from "zod";
 import { BooleanNode, ParseFunction } from "../../../parseNodeTypes";
-export declare const parseZodBooleanFieldDef: ParseFunction<ZodBooleanDef, BooleanNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4BooleanDef extends ZodDefWithType {
+    type: "boolean";
+}
+export declare const parseZodBooleanFieldDef: ParseFunction<ZodV4BooleanDef, BooleanNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodBrandedDef.d.ts

@@ -1,3 +1,14 @@
 import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { AnyZodObject, ZodBrandedDef } from "zod";
-export declare function parseZodBrandedDef(def: ZodBrandedDef<AnyZodObject>, refs: ParseReferences): ParsedInputNode;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4BrandedDef extends ZodDefWithType {
+    type: "branded";
+    innerType?: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+}
+export declare function parseZodBrandedDef(def: ZodV4BrandedDef, refs: ParseReferences): ParsedInputNode;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodDefaultDef.d.ts

@@ -1,3 +1,15 @@
 import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodDefaultDef } from "zod";
-export declare function parseZodDefaultDef(def: ZodDefaultDef, refs: ParseReferences): ParsedInputNode;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4DefaultDef extends ZodDefWithType {
+    type: "default";
+    innerType: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+    defaultValue: unknown;
+}
+export declare function parseZodDefaultDef(def: ZodV4DefaultDef, refs: ParseReferences): ParsedInputNode;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodDiscriminatedUnionDef.d.ts

@@ -1,16 +1,9 @@
-import { AnyZodObject } from "zod";
 import { DiscriminatedUnionNode, ParseFunction } from "../../../parseNodeTypes";
-type OptionsMap = Map<string, AnyZodObject>;
-type ZodDiscriminatedUnionThreePointTwenty = {
-    optionsMap: OptionsMap;
-    discriminator: string;
-    description?: string;
-};
-type ZodDiscriminatedUnionPreThreePointTwenty = {
-    options: OptionsMap;
-    discriminator: string;
-    description?: string;
-};
-export type ZodDiscriminatedUnionDefUnversioned = ZodDiscriminatedUnionPreThreePointTwenty | ZodDiscriminatedUnionThreePointTwenty;
+import { ZodDefWithType } from "../zod-types";
+export interface ZodDiscriminatedUnionDefUnversioned extends ZodDefWithType {
+    type: "union";
+    discriminator?: string;
+    options?: unknown[];
+    optionsMap?: Map<string, unknown>;
+}
 export declare const parseZodDiscriminatedUnionDef: ParseFunction<ZodDiscriminatedUnionDefUnversioned, DiscriminatedUnionNode>;
-export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodEffectsDef.d.ts

@@ -1,3 +1,28 @@
 import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodEffectsDef } from "zod";
-export declare function parseZodEffectsDef(def: ZodEffectsDef, refs: ParseReferences): ParsedInputNode;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4EffectsDef extends ZodDefWithType {
+    type: "effects" | "pipe";
+    schema?: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+    in?: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+    out?: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+}
+export declare function parseZodEffectsDef(def: ZodV4EffectsDef, refs: ParseReferences): ParsedInputNode;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodEnumDef.d.ts

@@ -1,3 +1,9 @@
-import { ZodEnumDef } from "zod";
 import { EnumNode, ParseFunction } from "../../../parseNodeTypes";
-export declare const parseZodEnumDef: ParseFunction<ZodEnumDef, EnumNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4EnumDef extends ZodDefWithType {
+    type: "enum";
+    values?: readonly string[];
+    entries?: Record<string, string>;
+}
+export declare const parseZodEnumDef: ParseFunction<ZodV4EnumDef, EnumNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodLiteralDef.d.ts

@@ -1,3 +1,9 @@
-import { ZodLiteralDef } from "zod";
 import { LiteralNode, ParseFunction } from "../../../parseNodeTypes";
-export declare const parseZodLiteralDef: ParseFunction<ZodLiteralDef, LiteralNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4LiteralDef extends ZodDefWithType {
+    type: "literal";
+    value?: string | number | boolean | bigint | null | undefined;
+    values?: readonly (string | number | boolean | bigint | null | undefined)[];
+}
+export declare const parseZodLiteralDef: ParseFunction<ZodV4LiteralDef, LiteralNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodNullDef.d.ts

@@ -1,3 +1,7 @@
-import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodNullDef } from "zod";
-export declare function parseZodNullDef(def: ZodNullDef, refs: ParseReferences): ParsedInputNode;
+import { LiteralNode, ParseFunction } from "../../../parseNodeTypes";
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4NullDef extends ZodDefWithType {
+    type: "null";
+}
+export declare const parseZodNullDef: ParseFunction<ZodV4NullDef, LiteralNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodNullableDef.d.ts

@@ -1,3 +1,14 @@
 import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodNullableDef } from "zod";
-export declare function parseZodNullableDef(def: ZodNullableDef, refs: ParseReferences): ParsedInputNode;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4NullableDef extends ZodDefWithType {
+    type: "nullable";
+    innerType: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+}
+export declare function parseZodNullableDef(def: ZodV4NullableDef, refs: ParseReferences): ParsedInputNode;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodNumberDef.d.ts

@@ -1,3 +1,7 @@
 import { NumberNode, ParseFunction } from "../../../parseNodeTypes";
-import { ZodNumberDef } from "zod";
-export declare const parseZodNumberDef: ParseFunction<ZodNumberDef, NumberNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4NumberDef extends ZodDefWithType {
+    type: "number";
+}
+export declare const parseZodNumberDef: ParseFunction<ZodV4NumberDef, NumberNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodObjectDef.d.ts

@@ -1,3 +1,15 @@
-import { ZodObjectDef } from "zod";
 import { ObjectNode, ParseFunction, UnsupportedNode } from "../../../parseNodeTypes";
-export declare const parseZodObjectDef: ParseFunction<ZodObjectDef, ObjectNode | UnsupportedNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4ObjectDef extends ZodDefWithType {
+    type: "object";
+    shape: Record<string, {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+        description?: string;
+    }>;
+}
+export declare const parseZodObjectDef: ParseFunction<ZodV4ObjectDef, ObjectNode | UnsupportedNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodOptionalDef.d.ts

@@ -1,3 +1,14 @@
-import { ZodOptionalDef } from "zod";
-import { ParsedInputNode, ParseFunction } from "../../../parseNodeTypes";
-export declare const parseZodOptionalDef: ParseFunction<ZodOptionalDef, ParsedInputNode>;
+import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4OptionalDef extends ZodDefWithType {
+    type: "optional";
+    innerType: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+}
+export declare function parseZodOptionalDef(def: ZodV4OptionalDef, refs: ParseReferences): ParsedInputNode;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodPromiseDef.d.ts

@@ -1,3 +1,14 @@
 import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodPromiseDef } from "zod";
-export declare function parseZodPromiseDef(def: ZodPromiseDef, refs: ParseReferences): ParsedInputNode;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4PromiseDef extends ZodDefWithType {
+    type: "promise";
+    innerType?: {
+        _def?: unknown;
+        def?: unknown;
+        _zod?: {
+            def?: unknown;
+        };
+    };
+}
+export declare function parseZodPromiseDef(def: ZodV4PromiseDef, refs: ParseReferences): ParsedInputNode;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodStringDef.d.ts

@@ -1,3 +1,7 @@
 import { ParseFunction, StringNode } from "../../../parseNodeTypes";
-import { ZodStringDef } from "zod";
-export declare const parseZodStringDef: ParseFunction<ZodStringDef, StringNode>;
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4StringDef extends ZodDefWithType {
+    type: "string";
+}
+export declare const parseZodStringDef: ParseFunction<ZodV4StringDef, StringNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodUndefinedDef.d.ts

@@ -1,3 +1,7 @@
-import { ParsedInputNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodUndefinedDef } from "zod";
-export declare function parseZodUndefinedDef(def: ZodUndefinedDef, refs: ParseReferences): ParsedInputNode;
+import { LiteralNode, ParseFunction } from "../../../parseNodeTypes";
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4UndefinedDef extends ZodDefWithType {
+    type: "undefined";
+}
+export declare const parseZodUndefinedDef: ParseFunction<ZodV4UndefinedDef, LiteralNode>;
+export {};

package/lib/src/parse/input-mappers/zod/parsers/parseZodVoidDef.d.ts

@@ -1,3 +1,7 @@
-import { LiteralNode, ParseReferences } from "@src/parse/parseNodeTypes";
-import { ZodVoidDef } from "zod";
-export declare function parseZodVoidDef(_: ZodVoidDef, refs: ParseReferences): LiteralNode;
+import { LiteralNode, ParseFunction } from "../../../parseNodeTypes";
+import { ZodDefWithType } from "../zod-types";
+interface ZodV4VoidDef extends ZodDefWithType {
+    type: "void";
+}
+export declare const parseZodVoidDef: ParseFunction<ZodV4VoidDef, LiteralNode>;
+export {};

package/lib/src/parse/input-mappers/zod/selector.d.ts

@@ -1,3 +1,4 @@
+import { getZodDef, ZodDefWithType } from "./zod-types";
 import { ParserSelectorFunction } from "../../parseNodeTypes";
-import { ZodDefWithType } from "./zod-types";
 export declare const zodSelectorFunction: ParserSelectorFunction<ZodDefWithType>;
+export { getZodDef };

package/lib/src/parse/input-mappers/zod/zod-types.d.ts

@@ -1,4 +1,6 @@
-import { ZodFirstPartyTypeKind, ZodTypeDef } from "zod";
-export type ZodDefWithType = ZodTypeDef & {
-    typeName: ZodFirstPartyTypeKind;
+export type ZodV4Type = "string" | "number" | "boolean" | "bigint" | "date" | "symbol" | "undefined" | "null" | "void" | "never" | "any" | "unknown" | "array" | "object" | "union" | "intersection" | "tuple" | "record" | "map" | "set" | "function" | "lazy" | "literal" | "enum" | "nativeEnum" | "optional" | "nullable" | "default" | "catch" | "nan" | "readonly" | "pipe" | "promise" | "effects" | "branded";
+export type ZodDefWithType = {
+    type: ZodV4Type;
+    [key: string]: unknown;
 };
+export declare function getZodDef(schema: unknown): ZodDefWithType | null;

package/lib/src/parse/parseNodeTypes.d.ts

@@ -1,11 +1,11 @@
-import { ZodTypeDef } from "zod";
 import { ZodDiscriminatedUnionDefUnversioned } from "./input-mappers/zod/parsers/parseZodDiscriminatedUnionDef";
 import { TrpcPanelExtraOptions } from "./parseRouter";
+import { ZodDefWithType } from "./input-mappers/zod/zod-types";
 export type SharedInputNodeProperties = {
     path: (string | number)[];
     optional?: true;
 };
-type InputNodeTypes = ZodTypeDef | ZodDiscriminatedUnionDefUnversioned;
+type InputNodeTypes = ZodDefWithType | ZodDiscriminatedUnionDefUnversioned;
 export type ArrayNode = {
     type: "array";
     childType: ParsedInputNode;