@bb-labs/next-router 0.0.2 → 0.0.4

package/README.md

@@ -35,9 +35,9 @@ import { z } from "zod";
 
 export default zPage({
   params: {
-    searchParams: z.object({
+    searchParams: {
       email: z.string().email(),
-    }),
+    },
   },
   handler: ({ searchParams }) => {
     // Already awaited — use directly
@@ -56,17 +56,18 @@ export default zPage({
 When `resolve: false`, params are passed as **promises** — you control when to await.
 
 ```tsx
-import { zPage, resolveParams } from "@bb-labs/next-router";
+import { zPage } from "@bb-labs/next-router";
+import { resolveZPageParams } from "@bb-labs/next-router/common";
 import { z } from "zod";
 
 export default zPage({
   params: {
-    routeParams: z.object({ id: z.string() }),
-    searchParams: z.object({ page: z.coerce.number().optional() }),
+    routeParams: { id: z.string() },
+    searchParams: { page: z.coerce.number().optional() },
   },
   resolve: false,
   handler: async (paramsPromise) => {
-    const { routeParams, searchParams } = await resolveParams(paramsPromise);
+    const { routeParams, searchParams } = await resolveZPageParams(paramsPromise);
     return (
       <div>
         Product {routeParams.id}, Page {searchParams.page}
@@ -78,24 +79,25 @@ export default zPage({
 
 **Note:** `onError` and `loadingHandler` are not available when `resolve: false`.
 
-### `resolveParams`
+### `resolveZPageParams`
 
 Helper function to await and validate params from promise-based handlers. Optionally accepts an `onError` callback.
 
 ```tsx
-import { zPage, resolveParams } from "@bb-labs/next-router";
+import { zPage } from "@bb-labs/next-router";
+import { resolveZPageParams } from "@bb-labs/next-router/common";
 import { redirect } from "next/navigation";
 import { z } from "zod";
 
 export default zPage({
   params: {
-    searchParams: z.object({
+    searchParams: {
       email: z.string().email(),
-    }),
+    },
   },
   resolve: false,
   handler: async (paramsPromise) => {
-    const { searchParams } = await resolveParams(paramsPromise, {
+    const { searchParams } = await resolveZPageParams(paramsPromise, {
       onError: (error) => {
         console.error("Validation failed:", error);
         redirect("/custom-error");
@@ -112,13 +114,13 @@ You can provide both, only `routeParams`, or only `searchParams` — but never n
 
 ```tsx
 // ✅ Both
-{ params: { routeParams: z.object({...}), searchParams: z.object({...}) } }
+{ params: { routeParams: {...}, searchParams: {...} } }
 
 // ✅ Only routeParams
-{ params: { routeParams: z.object({...}) } }
+{ params: { routeParams: {...} } }
 
 // ✅ Only searchParams
-{ params: { searchParams: z.object({...}) } }
+{ params: { searchParams: {...} } }
 
 // ❌ Neither — TypeScript error
 { params: {} }
@@ -138,12 +140,12 @@ Hooks for accessing validated params in client components with `onSuccess` and `
 import { useSearchParams } from "@bb-labs/next-router/client";
 import { z } from "zod";
 
-const searchParamsSchema = z.object({
+const searchParamsSchema = {
   email: z.string().email(),
-});
+};
 
 export function MyComponent() {
-  const { data } = useSearchParams(searchParamsSchema, {
+  const { data, error } = useSearchParams(searchParamsSchema, {
     onSuccess: (data) => {
       console.log("Valid params:", data.email);
     },
@@ -153,7 +155,7 @@ export function MyComponent() {
     },
   });
 
-  if (!data) return <div>Error</div>;
+  if (error) return <div>Error: {error}</div>;
 
   return <div>Email: {data.email}</div>;
 }
@@ -162,18 +164,19 @@ export function MyComponent() {
 ### Hook API
 
 ```tsx
-const { data } = useRouteParams(schema, options?);
-const { data } = useSearchParams(schema, options?);
+const { data, error } = useRouteParams(schema, options?);
+const { data, error } = useSearchParams(schema, options?);
 ```
 
 **Options:**
 
 - `onSuccess?: (data: T) => void` — Called when params are successfully validated
-- `onError?: (error: Error) => void` — Called when validation fails (defaults to redirecting to "/404")
+- `onError?: (error: z.ZodError) => void` — Called when validation fails (defaults to redirecting to "/404")
 
 **Returns:**
 
 - `data` — The validated params, or `null` if validation failed
+- `error` — The error message string, or `null` if validation succeeded
 
 ---
 
@@ -183,28 +186,28 @@ const { data } = useSearchParams(schema, options?);
 
 ```tsx
 // ✅ Correct — use coercion for non-string types
-z.object({
-  id: z.string(), // strings work directly
-  page: z.coerce.number(), // coerce string → number
-  active: z.coerce.boolean(), // coerce string → boolean
-  count: z.coerce.number().optional(), // optional coerced number
-  tags: z.array(z.string()), // array of strings (for ?tags=a&tags=b)
-});
+{
+  id: z.string(),              // strings work directly
+  page: z.coerce.number(),     // coerce string → number
+  active: z.coerce.boolean(),  // coerce string → boolean
+  count: z.coerce.number().optional(),  // optional coerced number
+  tags: z.array(z.string()),   // array of strings (for ?tags=a&tags=b)
+}
 
 // ❌ Wrong — will fail because raw input is always a string
-z.object({
-  page: z.number(), // Error: expected number, received string
+{
+  page: z.number(),    // Error: expected number, received string
   active: z.boolean(), // Error: expected boolean, received string
-});
+}
 ```
 
 You can also use transforms for custom parsing:
 
 ```tsx
-z.object({
+{
   date: z.string().transform((s) => new Date(s)),
   ids: z.string().transform((s) => s.split(",")),
-});
+}
 ```
 
 ### JSON-Encoded Objects
@@ -215,7 +218,7 @@ For complex objects, encode them as JSON in the URL (URL-escaped). Use `.transfo
 // URL: ?filter={"category":"books","price":{"min":10,"max":50},"inStock":true}
 // (URL-encoded: ?filter=%7B%22category%22%3A%22books%22...%7D)
 
-z.object({
+{
   filter: z
     .string()
     .transform((s) => JSON.parse(s))
@@ -227,7 +230,7 @@ z.object({
         inStock: z.boolean(),
       })
     ),
-});
+}
 ```
 
 **How it works:**
@@ -241,7 +244,7 @@ z.object({
 ```tsx
 export default zPage({
   params: {
-    searchParams: z.object({
+    searchParams: {
       filter: z
         .string()
         .transform((s) => JSON.parse(s))
@@ -251,7 +254,7 @@ export default zPage({
             price: z.object({ min: z.number(), max: z.number() }),
           })
         ),
-    }),
+    },
   },
   handler: ({ searchParams }) => {
     // searchParams.filter is fully typed!
@@ -278,7 +281,7 @@ const url = `/products?filter=${encodeURIComponent(JSON.stringify(filter))}`;
 
 By default, validation errors redirect to "/404":
 
-- **Server components**: `zPage` and `resolveParams` with `resolve: true` redirects on validation failure
+- **Server components**: `zPage` and `resolveZPageParams` with `resolve: true` redirects on validation failure
 - **Client components**: `useRouteParams` and `useSearchParams` redirect on validation failure
 
 You can customize error handling:
@@ -286,6 +289,65 @@ You can customize error handling:
 - **Server**: Provide an `onError` callback to `zPage` (only available when `resolve: true`)
 - **Client**: Provide an `onError` callback to the hooks
 
+---
+
+## Type Utilities
+
+The package exports type utilities from `@bb-labs/next-router/common` to help with type inference in advanced scenarios.
+
+### `InferZPageParams` / `InferZPageParamsPromises`
+
+Infer the resolved param types from a `zPage` configuration. Useful when you need to pass params to child components.
+
+```tsx
+import { zPage } from "@bb-labs/next-router";
+import type { InferZPageParams, InferZPageParamsPromises } from "@bb-labs/next-router/common";
+import { z } from "zod";
+
+const pageParams = {
+  routeParams: { id: z.string() },
+  searchParams: { page: z.coerce.number() },
+};
+
+// Infer the resolved param types
+type PageParams = InferZPageParams<typeof pageParams>;
+// { routeParams: { id: string }, searchParams: { page: number } }
+
+// For promise-wrapped params (when resolve: false)
+type PageParamsPromises = InferZPageParamsPromises<typeof pageParams>;
+// { routeParams: Promise<{ id: string }>, searchParams: Promise<{ page: number }> }
+
+// Use in child components
+function ProductDetails({ routeParams, searchParams }: PageParams) {
+  return (
+    <div>
+      Product {routeParams.id}, Page {searchParams.page}
+    </div>
+  );
+}
+
+export default zPage({
+  params: pageParams,
+  handler: (params) => <ProductDetails {...params} />,
+});
+```
+
+### Flexible Schema Input
+
+Both server and client APIs accept schemas in two formats:
+
+```tsx
+// Format 1: z.object() directly
+z.object({ id: z.string() });
+
+// Format 2: Plain object shape (automatically wrapped) — recommended
+{
+  id: z.string();
+}
+```
+
+Both formats are fully type-safe and produce the same runtime behavior.
+
 ## License
 
 MIT

package/dist/client/z-page/index.d.ts

@@ -1,13 +1,9 @@
-import { z, type ZodRawShape } from "zod";
-type ZodObject = z.ZodObject<ZodRawShape>;
+import type { InferZodObjectShapeOutput, T_DataError, ZodObjectShape } from "../../utils/types";
+import type { OnZodError } from "../../server/z-page/utils/types";
 type HookOptions<T> = {
     onSuccess?: (data: T) => void;
-    onError?: (error: Error) => void;
-};
-export declare function useRouteParams<T extends ZodObject>(schema: T, options?: HookOptions<z.output<T>>): {
-    data: z.core.output<T> | null;
-};
-export declare function useSearchParams<T extends ZodObject>(schema: T, options?: HookOptions<z.output<T>>): {
-    data: z.core.output<T> | null;
+    onError?: OnZodError;
 };
+export declare function useRouteParams<T extends ZodObjectShape>(schema: T, options?: HookOptions<InferZodObjectShapeOutput<T>>): T_DataError<InferZodObjectShapeOutput<T>>;
+export declare function useSearchParams<T extends ZodObjectShape>(schema: T, options?: HookOptions<InferZodObjectShapeOutput<T>>): T_DataError<InferZodObjectShapeOutput<T>>;
 export {};

package/dist/client/z-page/index.js

@@ -1,52 +1,57 @@
 "use client";
 import { useEffect, useRef, useMemo } from "react";
 import { useParams, useSearchParams as useNextSearchParams, useRouter } from "next/navigation";
+import { toZodObject } from "../../utils/to-zod-object";
+const defaultOnError = (error, router) => {
+    console.log(error);
+    router.push("/404");
+};
 export function useRouteParams(schema, options) {
     const rawParams = useParams();
     const router = useRouter();
     const calledRef = useRef(false);
+    const zodSchema = useMemo(() => toZodObject(schema), [schema]);
     const result = useMemo(() => {
-        const parsed = schema.safeParse(rawParams);
+        const parsed = zodSchema.safeParse(rawParams);
         return parsed.success ? { data: parsed.data, error: null } : { data: null, error: parsed.error };
-    }, [rawParams, schema]);
+    }, [rawParams, zodSchema]);
     useEffect(() => {
         if (calledRef.current)
             return;
         calledRef.current = true;
         if (result.error) {
-            console.log(result.error);
-            options?.onError ? options.onError(result.error) : router.push("/404");
+            options?.onError ? options.onError(result.error) : defaultOnError(result.error, router);
         }
         else if (result.data) {
             options?.onSuccess?.(result.data);
         }
     }, [result, options, router]);
-    return { data: result.data };
+    return result.error ? { data: null, error: result.error.message } : { data: result.data, error: null };
 }
 export function useSearchParams(schema, options) {
     const nextSearchParams = useNextSearchParams();
     const router = useRouter();
     const calledRef = useRef(false);
+    const zodSchema = useMemo(() => toZodObject(schema), [schema]);
     const result = useMemo(() => {
         const raw = {};
         nextSearchParams.forEach((v, k) => {
             const existing = raw[k];
             raw[k] = existing ? (Array.isArray(existing) ? [...existing, v] : [existing, v]) : v;
         });
-        const parsed = schema.safeParse(raw);
+        const parsed = zodSchema.safeParse(raw);
         return parsed.success ? { data: parsed.data, error: null } : { data: null, error: parsed.error };
-    }, [nextSearchParams, schema]);
+    }, [nextSearchParams, zodSchema]);
     useEffect(() => {
         if (calledRef.current)
             return;
         calledRef.current = true;
         if (result.error) {
-            console.log(result.error);
-            options?.onError ? options.onError(result.error) : router.push("/404");
+            options?.onError ? options.onError(result.error) : defaultOnError(result.error, router);
         }
         else if (result.data) {
             options?.onSuccess?.(result.data);
         }
     }, [result, options, router]);
-    return { data: result.data };
+    return result.error ? { data: null, error: result.error.message } : { data: result.data, error: null };
 }

package/dist/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./z-page/infer-params";
+export * from "./z-page/resolve-params";

package/dist/common/index.js

@@ -0,0 +1,2 @@
+export * from "./z-page/infer-params";
+export * from "./z-page/resolve-params";

package/dist/common/z-page/infer-params.d.ts

@@ -0,0 +1,24 @@
+import type { ZodObjectShape, InferZodObjectShapeOutput } from "../../utils/types";
+/** Helper to infer a single param type */
+type InferParam<T, K extends string> = K extends keyof T ? (T[K] extends ZodObjectShape ? InferZodObjectShapeOutput<T[K]> : never) : never;
+/** Inferred params with Promise wrappers (for async page props) */
+type InferZPageParamsPromises<T> = (T extends {
+    routeParams: ZodObjectShape;
+} ? {
+    routeParams: Promise<InferParam<T, "routeParams">>;
+} : {}) & (T extends {
+    searchParams: ZodObjectShape;
+} ? {
+    searchParams: Promise<InferParam<T, "searchParams">>;
+} : {});
+/** Inferred params (unwrapped) */
+type InferZPageParams<T> = (T extends {
+    routeParams: ZodObjectShape;
+} ? {
+    routeParams: InferParam<T, "routeParams">;
+} : {}) & (T extends {
+    searchParams: ZodObjectShape;
+} ? {
+    searchParams: InferParam<T, "searchParams">;
+} : {});
+export type { InferZPageParamsPromises, InferZPageParams };

package/dist/common/z-page/resolve-params.d.ts

@@ -0,0 +1,14 @@
+import type { OnZodError } from "../../server/z-page/utils/types";
+type ResolveZPageParamsInput<RP, SP> = {
+    routeParams?: Promise<RP>;
+    searchParams?: Promise<SP>;
+};
+type ResolveZPageParamsResult<RP, SP> = {
+    routeParams: RP;
+    searchParams: SP;
+};
+type ResolveZPageParamsOptions = {
+    onError?: OnZodError;
+};
+export declare function resolveZPageParams<RP, SP>(paramsPromise: ResolveZPageParamsInput<RP, SP>, options?: ResolveZPageParamsOptions): Promise<ResolveZPageParamsResult<RP, SP>>;
+export {};

package/dist/{server/z-page/helpers → common/z-page}/resolve-params.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { defaultOnError } from "../utils/helper";
-export async function resolveParams(paramsPromise, options = {}) {
+import { defaultOnError } from "../../server/z-page/utils/setup";
+export async function resolveZPageParams(paramsPromise, options = {}) {
     const result = {};
     const onError = options.onError ?? defaultOnError;
     if (paramsPromise.routeParams) {

package/dist/server/z-page/fns/z-page.d.ts

@@ -1,47 +1,47 @@
 import React from "react";
-import { z } from "zod";
-import { type ZodObject, type OnError } from "../utils/helper";
-import type { NextPageProps } from "../types";
+import type { NextPageProps, OnZodError } from "../utils/types";
+import type { InferZodObjectShapeOutput, ZodObjectShape } from "../../../utils/types";
 /** Return type for zPage */
 type ZPageReturn = (props: NextPageProps) => React.ReactNode | Promise<React.ReactNode>;
-export declare function zPage<RP extends ZodObject, SP extends ZodObject>(cfg: {
+type InferOutput<T extends ZodObjectShape> = InferZodObjectShapeOutput<T>;
+export declare function zPage<RP extends ZodObjectShape, SP extends ZodObjectShape>(cfg: {
     params: {
         routeParams: RP;
         searchParams: SP;
     };
     resolve?: true;
-    onError?: OnError;
+    onError?: OnZodError;
     loadingHandler?: React.ReactNode;
     handler: (input: {
-        routeParams: z.output<RP>;
-        searchParams: z.output<SP>;
+        routeParams: InferOutput<RP>;
+        searchParams: InferOutput<SP>;
     }) => React.ReactNode | Promise<React.ReactNode>;
 }): ZPageReturn;
-export declare function zPage<RP extends ZodObject>(cfg: {
+export declare function zPage<RP extends ZodObjectShape>(cfg: {
     params: {
         routeParams: RP;
         searchParams?: undefined;
     };
     resolve?: true;
-    onError?: OnError;
+    onError?: OnZodError;
     loadingHandler?: React.ReactNode;
     handler: (input: {
-        routeParams: z.output<RP>;
+        routeParams: InferOutput<RP>;
     }) => React.ReactNode | Promise<React.ReactNode>;
 }): ZPageReturn;
-export declare function zPage<SP extends ZodObject>(cfg: {
+export declare function zPage<SP extends ZodObjectShape>(cfg: {
     params: {
         routeParams?: undefined;
         searchParams: SP;
     };
     resolve?: true;
-    onError?: OnError;
+    onError?: OnZodError;
     loadingHandler?: React.ReactNode;
     handler: (input: {
-        searchParams: z.output<SP>;
+        searchParams: InferOutput<SP>;
     }) => React.ReactNode | Promise<React.ReactNode>;
 }): ZPageReturn;
-export declare function zPage<RP extends ZodObject, SP extends ZodObject>(cfg: {
+export declare function zPage<RP extends ZodObjectShape, SP extends ZodObjectShape>(cfg: {
     params: {
         routeParams: RP;
         searchParams: SP;
@@ -50,11 +50,11 @@ export declare function zPage<RP extends ZodObject, SP extends ZodObject>(cfg: {
     onError?: never;
     loadingHandler?: never;
     handler: (input: {
-        routeParams: Promise<z.output<RP>>;
-        searchParams: Promise<z.output<SP>>;
+        routeParams: Promise<InferOutput<RP>>;
+        searchParams: Promise<InferOutput<SP>>;
     }) => React.ReactNode | Promise<React.ReactNode>;
 }): ZPageReturn;
-export declare function zPage<RP extends ZodObject>(cfg: {
+export declare function zPage<RP extends ZodObjectShape>(cfg: {
     params: {
         routeParams: RP;
         searchParams?: undefined;
@@ -63,10 +63,10 @@ export declare function zPage<RP extends ZodObject>(cfg: {
     onError?: never;
     loadingHandler?: never;
     handler: (input: {
-        routeParams: Promise<z.output<RP>>;
+        routeParams: Promise<InferOutput<RP>>;
     }) => React.ReactNode | Promise<React.ReactNode>;
 }): ZPageReturn;
-export declare function zPage<SP extends ZodObject>(cfg: {
+export declare function zPage<SP extends ZodObjectShape>(cfg: {
     params: {
         routeParams?: undefined;
         searchParams: SP;
@@ -75,7 +75,7 @@ export declare function zPage<SP extends ZodObject>(cfg: {
     onError?: never;
     loadingHandler?: never;
     handler: (input: {
-        searchParams: Promise<z.output<SP>>;
+        searchParams: Promise<InferOutput<SP>>;
     }) => React.ReactNode | Promise<React.ReactNode>;
 }): ZPageReturn;
 export {};

package/dist/server/z-page/fns/z-page.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Suspense } from "react";
-import { setup } from "../utils/helper";
+import { setup } from "../utils/setup";
 // ------------- IMPLEMENTATION -------------
 export function zPage(cfg) {
     const shouldResolve = cfg.resolve !== false;

package/dist/server/z-page/index.d.ts

@@ -1,3 +1 @@
 export { zPage } from "./fns/z-page";
-export { resolveParams } from "./helpers/resolve-params";
-export type { InferParamsPromises, InferParams } from "./helpers/infer-props";

package/dist/server/z-page/index.js

@@ -1,2 +1 @@
 export { zPage } from "./fns/z-page";
-export { resolveParams } from "./helpers/resolve-params";

package/dist/server/z-page/utils/setup.d.ts

@@ -0,0 +1,16 @@
+import type { NextPageProps, OnZodError } from "./types";
+import type { ZodObjectShape } from "../../../utils/types";
+export declare const defaultOnError: OnZodError;
+export declare function setup<RP extends ZodObjectShape, SP extends ZodObjectShape>(params: {
+    routeParams?: RP;
+    searchParams?: SP;
+}, onError?: OnZodError): {
+    createValidatedPromises: (props: NextPageProps) => {
+        routeParams: Promise<Record<string, unknown>> | undefined;
+        searchParams: Promise<Record<string, unknown>> | undefined;
+    };
+    resolveParams: (promises: {
+        routeParams: Promise<Record<string, unknown>> | undefined;
+        searchParams: Promise<Record<string, unknown>> | undefined;
+    }) => Promise<Record<string, unknown>>;
+};

package/dist/server/z-page/utils/{helper.js → setup.js}

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { redirect } from "next/navigation";
+import { toZodObject } from "../../../utils/to-zod-object";
 export const defaultOnError = (e) => {
     console.log(e);
     redirect("/404");
 };
 export function setup(params, onError = defaultOnError) {
-    const rpSchema = params.routeParams;
-    const spSchema = params.searchParams;
+    const rpSchema = params.routeParams ? toZodObject(params.routeParams) : undefined;
+    const spSchema = params.searchParams ? toZodObject(params.searchParams) : undefined;
     /** Creates validated promises from Next.js page props */
     function createValidatedPromises(props) {
         return {

package/dist/server/z-page/{types.d.ts → utils/types.d.ts}

@@ -1,10 +1,8 @@
-import { z, type ZodRawShape } from "zod";
+import { z } from "zod";
 /** Next.js page props type */
 export type NextPageProps = {
     params: Promise<Record<string, string | string[]>>;
     searchParams: Promise<Record<string, string | string[] | undefined>>;
 };
-/** Enforces that routeParams/searchParams must be z.object(...) */
-export type ZodObject = z.ZodObject<ZodRawShape>;
 /** Error handler type */
-export type OnError = (error: z.ZodError) => never | void;
+export type OnZodError = (error: z.ZodError) => never | void;

package/dist/utils/to-zod-object.d.ts

@@ -0,0 +1,4 @@
+import { z, type ZodRawShape } from "zod";
+import type { ZodObjectShape } from "./types";
+/** Wrap a raw shape in z.object() if it's not already a ZodObject */
+export declare function toZodObject(schema: ZodObjectShape): z.ZodObject<ZodRawShape>;

package/dist/utils/to-zod-object.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/** Wrap a raw shape in z.object() if it's not already a ZodObject */
+export function toZodObject(schema) {
+    if (schema instanceof z.ZodObject)
+        return schema;
+    return z.object(schema);
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,14 @@
+import { z, type ZodRawShape } from "zod";
+/** A z.object(...) schema */
+export type ZodObject<T extends ZodRawShape = ZodRawShape> = z.ZodObject<T>;
+/** Plain object shape or z.object() - accepts either format */
+export type ZodObjectShape = ZodRawShape | ZodObject;
+/** Infer output type from either raw shape or ZodObject */
+export type InferZodObjectShapeOutput<T extends ZodObjectShape> = T extends ZodObject<infer S> ? z.output<z.ZodObject<S>> : T extends ZodRawShape ? z.output<z.ZodObject<T>> : never;
+export type T_DataError<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: string;
+};

package/dist/utils/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bb-labs/next-router",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "Beepbop",
   "homepage": "https://github.com/beepbop-labs/next-router",
   "keywords": [
@@ -21,7 +21,8 @@
   ],
   "exports": {
     ".": "./dist/server/index.js",
-    "./client": "./dist/client/index.js"
+    "./client": "./dist/client/index.js",
+    "./common": "./dist/common/index.js"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/dist/server/z-page/helpers/infer-props.d.ts

@@ -1,12 +0,0 @@
-import { z, type ZodObject, type ZodRawShape } from "zod";
-type InferParamsPromises<T> = ("routeParams" extends keyof T ? (T["routeParams"] extends ZodObject<ZodRawShape> ? {
-    routeParams: Promise<z.output<T["routeParams"]>>;
-} : {}) : {}) & ("searchParams" extends keyof T ? (T["searchParams"] extends ZodObject<ZodRawShape> ? {
-    searchParams: Promise<z.output<T["searchParams"]>>;
-} : {}) : {});
-type InferParams<T> = ("routeParams" extends keyof T ? (T["routeParams"] extends ZodObject<ZodRawShape> ? {
-    routeParams: z.output<T["routeParams"]>;
-} : {}) : {}) & ("searchParams" extends keyof T ? (T["searchParams"] extends ZodObject<ZodRawShape> ? {
-    searchParams: z.output<T["searchParams"]>;
-} : {}) : {});
-export type { InferParamsPromises, InferParams };

package/dist/server/z-page/helpers/resolve-params.d.ts

@@ -1,14 +0,0 @@
-import { type OnError } from "../utils/helper";
-type ResolveParamsInput<RP, SP> = {
-    routeParams?: Promise<RP>;
-    searchParams?: Promise<SP>;
-};
-type ResolveParamsResult<RP, SP> = {
-    routeParams: RP;
-    searchParams: SP;
-};
-type ResolveParamsOptions = {
-    onError?: OnError;
-};
-export declare function resolveParams<RP, SP>(paramsPromise: ResolveParamsInput<RP, SP>, options?: ResolveParamsOptions): Promise<ResolveParamsResult<RP, SP>>;
-export {};

package/dist/server/z-page/utils/helper.d.ts

@@ -1,17 +0,0 @@
-import { z } from "zod";
-import type { NextPageProps, ZodObject, OnError } from "../types";
-export type { ZodObject, OnError };
-export declare const defaultOnError: OnError;
-export declare function setup<RP extends ZodObject, SP extends ZodObject>(params: {
-    routeParams?: RP;
-    searchParams?: SP;
-}, onError?: OnError): {
-    createValidatedPromises: (props: NextPageProps) => {
-        routeParams: Promise<z.core.output<RP>> | undefined;
-        searchParams: Promise<z.core.output<SP>> | undefined;
-    };
-    resolveParams: (promises: {
-        routeParams: Promise<z.core.output<RP>> | undefined;
-        searchParams: Promise<z.core.output<SP>> | undefined;
-    }) => Promise<Record<string, unknown>>;
-};