react-iten 0.0.2 → 0.4.2

package/dist/hooks.cjs

@@ -0,0 +1,52 @@
+let react = require("react");
+//#region src/hooks.ts
+function makeHooks(store) {
+	function useRouterState() {
+		return (0, react.useSyncExternalStore)((listener) => store.subscribe({ listener }), store.getState, store.getState);
+	}
+	function useCurrentRoute() {
+		return useRouterState().route;
+	}
+	function useRoute({ name }) {
+		const route = useRouterState().route;
+		if (route?.name === name) return {
+			isActive: true,
+			params: route
+		};
+		return {
+			isActive: false,
+			params: null
+		};
+	}
+	function useNavigate() {
+		return store.navigate;
+	}
+	function useGoBack() {
+		return store.goBack;
+	}
+	function useIsNavigating() {
+		return useRouterState().isNavigating;
+	}
+	function useCanGoBack() {
+		return useRouterState().canGoBack;
+	}
+	function useRouteLoading({ name }) {
+		return useRouterState().pendingRoute?.name === name;
+	}
+	function useRouterError() {
+		return useRouterState().error;
+	}
+	return {
+		useRouterState,
+		useCurrentRoute,
+		useRoute,
+		useNavigate,
+		useGoBack,
+		useIsNavigating,
+		useCanGoBack,
+		useRouteLoading,
+		useRouterError
+	};
+}
+//#endregion
+exports.makeHooks = makeHooks;

package/dist/hooks.d.cts

@@ -0,0 +1,21 @@
+import { UseRouteResult } from "./types.cjs";
+import { NavigateInput, RouteMapDef, RouteUnion, RouterError, RouterState } from "iten-core";
+
+//#region src/hooks.d.ts
+type HookBundle<M extends RouteMapDef> = {
+  useRouterState: () => RouterState<M>;
+  useCurrentRoute: () => RouteUnion<M> | null;
+  useRoute: <K extends keyof M>(input: {
+    name: K;
+  }) => UseRouteResult<M, K>;
+  useNavigate: () => (input: NavigateInput<M>) => Promise<void>;
+  useGoBack: () => () => void;
+  useIsNavigating: () => boolean;
+  useCanGoBack: () => boolean;
+  useRouteLoading: (input: {
+    name: keyof M;
+  }) => boolean;
+  useRouterError: () => RouterError | null;
+};
+//#endregion
+export { HookBundle };

package/dist/hooks.d.ts

@@ -0,0 +1,21 @@
+import { UseRouteResult } from "./types.js";
+import { NavigateInput, RouteMapDef, RouteUnion, RouterError, RouterState } from "iten-core";
+
+//#region src/hooks.d.ts
+type HookBundle<M extends RouteMapDef> = {
+  useRouterState: () => RouterState<M>;
+  useCurrentRoute: () => RouteUnion<M> | null;
+  useRoute: <K extends keyof M>(input: {
+    name: K;
+  }) => UseRouteResult<M, K>;
+  useNavigate: () => (input: NavigateInput<M>) => Promise<void>;
+  useGoBack: () => () => void;
+  useIsNavigating: () => boolean;
+  useCanGoBack: () => boolean;
+  useRouteLoading: (input: {
+    name: keyof M;
+  }) => boolean;
+  useRouterError: () => RouterError | null;
+};
+//#endregion
+export { HookBundle };

package/dist/hooks.mjs

@@ -0,0 +1,52 @@
+import { useSyncExternalStore } from "react";
+//#region src/hooks.ts
+function makeHooks(store) {
+	function useRouterState() {
+		return useSyncExternalStore((listener) => store.subscribe({ listener }), store.getState, store.getState);
+	}
+	function useCurrentRoute() {
+		return useRouterState().route;
+	}
+	function useRoute({ name }) {
+		const route = useRouterState().route;
+		if (route?.name === name) return {
+			isActive: true,
+			params: route
+		};
+		return {
+			isActive: false,
+			params: null
+		};
+	}
+	function useNavigate() {
+		return store.navigate;
+	}
+	function useGoBack() {
+		return store.goBack;
+	}
+	function useIsNavigating() {
+		return useRouterState().isNavigating;
+	}
+	function useCanGoBack() {
+		return useRouterState().canGoBack;
+	}
+	function useRouteLoading({ name }) {
+		return useRouterState().pendingRoute?.name === name;
+	}
+	function useRouterError() {
+		return useRouterState().error;
+	}
+	return {
+		useRouterState,
+		useCurrentRoute,
+		useRoute,
+		useNavigate,
+		useGoBack,
+		useIsNavigating,
+		useCanGoBack,
+		useRouteLoading,
+		useRouterError
+	};
+}
+//#endregion
+export { makeHooks };

package/dist/index.cjs

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_headless = require("./headless.cjs");
+const require_create_router = require("./create-router.cjs");
+let iten_core = require("iten-core");
+exports.createHeadlessRouter = require_headless.createHeadlessRouter;
+Object.defineProperty(exports, "createRoute", {
+	enumerable: true,
+	get: function() {
+		return iten_core.createRoute;
+	}
+});
+exports.createRouter = require_create_router.createRouter;
+Object.defineProperty(exports, "defineRouteConfig", {
+	enumerable: true,
+	get: function() {
+		return iten_core.defineRouteConfig;
+	}
+});
+Object.defineProperty(exports, "defineRoutes", {
+	enumerable: true,
+	get: function() {
+		return iten_core.defineRoutes;
+	}
+});
+Object.defineProperty(exports, "isRoute", {
+	enumerable: true,
+	get: function() {
+		return iten_core.isRoute;
+	}
+});
+Object.defineProperty(exports, "isRouteName", {
+	enumerable: true,
+	get: function() {
+		return iten_core.isRouteName;
+	}
+});
+Object.defineProperty(exports, "matchRoute", {
+	enumerable: true,
+	get: function() {
+		return iten_core.matchRoute;
+	}
+});
+Object.defineProperty(exports, "route", {
+	enumerable: true,
+	get: function() {
+		return iten_core.route;
+	}
+});

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { InferRoutes, NoParams, QueryClientLike, ReactRouterConfig, RouteConfigMap, RouteDefinition, RouteDefinitions, RouteMap, RouteMapDef, RouteMatcher, RouteName, RouteOf, RouteParams, RouteUnion, RouterError, RouterState, UseRouteResult } from "./types.cjs";
+import { HeadlessReactRouter, ReactRouterStore, createHeadlessRouter } from "./headless.cjs";
+import { LinkProps } from "./components/Link.cjs";
+import { NavigateProps } from "./components/Navigate.cjs";
+import { RouteProps } from "./components/Route.cjs";
+import { ReactRouter, createRouter } from "./create-router.cjs";
+import { createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route } from "iten-core";
+export { type HeadlessReactRouter, type InferRoutes, type LinkProps, type NavigateProps, type NoParams, type QueryClientLike, type ReactRouter, type ReactRouterConfig, type ReactRouterStore, type RouteConfigMap, type RouteDefinition, type RouteDefinitions, type RouteMap, type RouteMapDef, type RouteMatcher, type RouteName, type RouteOf, type RouteParams, type RouteProps, type RouteUnion, type RouterError, type RouterState, type UseRouteResult, createHeadlessRouter, createRoute, createRouter, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { InferRoutes, NoParams, QueryClientLike, ReactRouterConfig, RouteConfigMap, RouteDefinition, RouteDefinitions, RouteMap, RouteMapDef, RouteMatcher, RouteName, RouteOf, RouteParams, RouteUnion, RouterError, RouterState, UseRouteResult } from "./types.js";
+import { HeadlessReactRouter, ReactRouterStore, createHeadlessRouter } from "./headless.js";
+import { LinkProps } from "./components/Link.js";
+import { NavigateProps } from "./components/Navigate.js";
+import { RouteProps } from "./components/Route.js";
+import { ReactRouter, createRouter } from "./create-router.js";
+import { createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route } from "iten-core";
+export { type HeadlessReactRouter, type InferRoutes, type LinkProps, type NavigateProps, type NoParams, type QueryClientLike, type ReactRouter, type ReactRouterConfig, type ReactRouterStore, type RouteConfigMap, type RouteDefinition, type RouteDefinitions, type RouteMap, type RouteMapDef, type RouteMatcher, type RouteName, type RouteOf, type RouteParams, type RouteProps, type RouteUnion, type RouterError, type RouterState, type UseRouteResult, createHeadlessRouter, createRoute, createRouter, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { createHeadlessRouter } from "./headless.mjs";
+import { createRouter } from "./create-router.mjs";
+import { createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route } from "iten-core";
+export { createHeadlessRouter, createRoute, createRouter, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route };

package/dist/types.d.cts

@@ -0,0 +1,19 @@
+import { InferRoutes, NoParams, QueryClientLike, RouteConfigMap, RouteDefinition, RouteDefinitions, RouteMap as RouteMap$1, RouteMapDef as RouteMapDef$1, RouteMatcher, RouteName, RouteOf, RouteParams, RouteUnion as RouteUnion$1, RouterError as RouterError$1, RouterState as RouterState$1 } from "iten-core";
+
+//#region src/types.d.ts
+type ReactRouterConfig<M extends RouteMapDef$1, Ctx = unknown> = {
+  initial: RouteUnion$1<M> | null;
+  routeConfig?: RouteConfigMap<M, Ctx> | undefined;
+  maxHistoryLength?: number | undefined;
+  context?: Ctx | (() => Ctx) | undefined;
+  queryClient?: QueryClientLike | null | undefined;
+};
+type UseRouteResult<M extends RouteMapDef$1, K extends keyof M> = {
+  isActive: true;
+  params: M[K];
+} | {
+  isActive: false;
+  params: null;
+};
+//#endregion
+export { type InferRoutes, type NoParams, type QueryClientLike, ReactRouterConfig, type RouteConfigMap, type RouteDefinition, type RouteDefinitions, type RouteMap$1 as RouteMap, type RouteMapDef$1 as RouteMapDef, type RouteMatcher, type RouteName, type RouteOf, type RouteParams, type RouteUnion$1 as RouteUnion, type RouterError$1 as RouterError, type RouterState$1 as RouterState, UseRouteResult };

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+import { InferRoutes, NoParams, QueryClientLike, RouteConfigMap, RouteDefinition, RouteDefinitions, RouteMap as RouteMap$1, RouteMapDef as RouteMapDef$1, RouteMatcher, RouteName, RouteOf, RouteParams, RouteUnion as RouteUnion$1, RouterError as RouterError$1, RouterState as RouterState$1 } from "iten-core";
+
+//#region src/types.d.ts
+type ReactRouterConfig<M extends RouteMapDef$1, Ctx = unknown> = {
+  initial: RouteUnion$1<M> | null;
+  routeConfig?: RouteConfigMap<M, Ctx> | undefined;
+  maxHistoryLength?: number | undefined;
+  context?: Ctx | (() => Ctx) | undefined;
+  queryClient?: QueryClientLike | null | undefined;
+};
+type UseRouteResult<M extends RouteMapDef$1, K extends keyof M> = {
+  isActive: true;
+  params: M[K];
+} | {
+  isActive: false;
+  params: null;
+};
+//#endregion
+export { type InferRoutes, type NoParams, type QueryClientLike, ReactRouterConfig, type RouteConfigMap, type RouteDefinition, type RouteDefinitions, type RouteMap$1 as RouteMap, type RouteMapDef$1 as RouteMapDef, type RouteMatcher, type RouteName, type RouteOf, type RouteParams, type RouteUnion$1 as RouteUnion, type RouterError$1 as RouterError, type RouterState$1 as RouterState, UseRouteResult };

package/dist/url.cjs

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let iten_core_url = require("iten-core/url");
+//#region src/url.ts
+function createUrlSync({ router, ...input }) {
+	const coreLike = {
+		getState: () => router.store.getState(),
+		navigate: (navigateInput) => router.store.navigate(navigateInput),
+		goBack: () => router.store.goBack(),
+		subscribe: ({ listener }) => router.store.subscribe({ listener: () => {
+			listener(router.store.getState());
+		} }),
+		dispose: () => {}
+	};
+	return (0, iten_core_url.createUrlSync)({
+		...input,
+		router: coreLike
+	});
+}
+//#endregion
+exports.createUrlSync = createUrlSync;

package/dist/url.d.cts

@@ -0,0 +1,14 @@
+import { HeadlessReactRouter } from "./headless.cjs";
+import { RouteMapDef } from "iten-core";
+import { CreateUrlSyncInput as CreateUrlSyncInput$1, FormatUrlInput, ParseUrlInput, UrlHydrateInput, UrlParseErrorInput, UrlStartInput, UrlSubscribeInput, UrlSync, UrlSync as UrlSync$1, UrlWriteInput, UrlWriteMode } from "iten-core/url";
+
+//#region src/url.d.ts
+type CreateUrlSyncInput<M extends RouteMapDef> = Omit<CreateUrlSyncInput$1<M>, "router"> & {
+  router: HeadlessReactRouter<M>;
+};
+declare function createUrlSync<M extends RouteMapDef>({
+  router,
+  ...input
+}: CreateUrlSyncInput<M>): UrlSync$1<M>;
+//#endregion
+export { CreateUrlSyncInput, type FormatUrlInput, type ParseUrlInput, type UrlHydrateInput, type UrlParseErrorInput, type UrlStartInput, type UrlSubscribeInput, type UrlSync, type UrlWriteInput, type UrlWriteMode, createUrlSync };

package/dist/url.d.ts

@@ -0,0 +1,14 @@
+import { HeadlessReactRouter } from "./headless.js";
+import { RouteMapDef } from "iten-core";
+import { CreateUrlSyncInput as CreateUrlSyncInput$1, FormatUrlInput, ParseUrlInput, UrlHydrateInput, UrlParseErrorInput, UrlStartInput, UrlSubscribeInput, UrlSync, UrlSync as UrlSync$1, UrlWriteInput, UrlWriteMode } from "iten-core/url";
+
+//#region src/url.d.ts
+type CreateUrlSyncInput<M extends RouteMapDef> = Omit<CreateUrlSyncInput$1<M>, "router"> & {
+  router: HeadlessReactRouter<M>;
+};
+declare function createUrlSync<M extends RouteMapDef>({
+  router,
+  ...input
+}: CreateUrlSyncInput<M>): UrlSync$1<M>;
+//#endregion
+export { CreateUrlSyncInput, type FormatUrlInput, type ParseUrlInput, type UrlHydrateInput, type UrlParseErrorInput, type UrlStartInput, type UrlSubscribeInput, type UrlSync, type UrlWriteInput, type UrlWriteMode, createUrlSync };

package/dist/url.mjs

@@ -0,0 +1,19 @@
+import { createUrlSync as createUrlSync$1 } from "iten-core/url";
+//#region src/url.ts
+function createUrlSync({ router, ...input }) {
+	const coreLike = {
+		getState: () => router.store.getState(),
+		navigate: (navigateInput) => router.store.navigate(navigateInput),
+		goBack: () => router.store.goBack(),
+		subscribe: ({ listener }) => router.store.subscribe({ listener: () => {
+			listener(router.store.getState());
+		} }),
+		dispose: () => {}
+	};
+	return createUrlSync$1({
+		...input,
+		router: coreLike
+	});
+}
+//#endregion
+export { createUrlSync };

package/dist/utils.cjs

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let iten_core_utils = require("iten-core/utils");
+Object.defineProperty(exports, "createRoute", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.createRoute;
+	}
+});
+Object.defineProperty(exports, "defineRouteConfig", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.defineRouteConfig;
+	}
+});
+Object.defineProperty(exports, "defineRoutes", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.defineRoutes;
+	}
+});
+Object.defineProperty(exports, "isRoute", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.isRoute;
+	}
+});
+Object.defineProperty(exports, "isRouteName", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.isRouteName;
+	}
+});
+Object.defineProperty(exports, "matchRoute", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.matchRoute;
+	}
+});
+Object.defineProperty(exports, "route", {
+	enumerable: true,
+	get: function() {
+		return iten_core_utils.route;
+	}
+});

package/dist/utils.d.cts

@@ -0,0 +1,3 @@
+import { InferRoutes, NoParams, RouteConfigMap, RouteMap, RouteMapDef, RouteUnion } from "iten-core";
+import { RouteMatcher, RouteName, RouteOf, RouteParams, createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route } from "iten-core/utils";
+export { type InferRoutes, type NoParams, type RouteConfigMap, type RouteMap, type RouteMapDef, type RouteMatcher, type RouteName, type RouteOf, type RouteParams, type RouteUnion, createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route };

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+import { InferRoutes, NoParams, RouteConfigMap, RouteMap, RouteMapDef, RouteUnion } from "iten-core";
+import { RouteMatcher, RouteName, RouteOf, RouteParams, createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route } from "iten-core/utils";
+export { type InferRoutes, type NoParams, type RouteConfigMap, type RouteMap, type RouteMapDef, type RouteMatcher, type RouteName, type RouteOf, type RouteParams, type RouteUnion, createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route };

package/dist/utils.mjs

@@ -0,0 +1,2 @@
+import { createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route } from "iten-core/utils";
+export { createRoute, defineRouteConfig, defineRoutes, isRoute, isRouteName, matchRoute, route };

package/dist/zod.cjs

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/zod.ts
+function hasOwnName({ value }) {
+	return typeof value === "object" && value !== null && Object.hasOwn(value, "name");
+}
+function splitInput({ value }) {
+	if (typeof value !== "object" || value === null || !Object.hasOwn(value, "name")) return null;
+	const { name, ...params } = value;
+	return {
+		name,
+		params
+	};
+}
+function getSchema({ schemas, name }) {
+	if (typeof name !== "string" || !Object.hasOwn(schemas, name)) return null;
+	const routeName = name;
+	return {
+		name: routeName,
+		schema: schemas[routeName]
+	};
+}
+function defineZodRoutes(schemas) {
+	return schemas;
+}
+function zodNoParams() {
+	return zod.z.object({}).strict().default({});
+}
+function createZodRoute(schemas) {
+	return (({ name, input }) => {
+		const schema = schemas[name];
+		if (!schema) throw new TypeError(`[iten] Unknown route name: ${String(name)}`);
+		if (hasOwnName({ value: input })) throw new TypeError("[iten] Zod route params must not include a name field");
+		const params = schema.parse(input ?? {});
+		if (hasOwnName({ value: params })) throw new TypeError("[iten] Zod route params must not include a name field");
+		return {
+			name,
+			...params
+		};
+	});
+}
+function parseZodRoute({ schemas, value }) {
+	const input = splitInput({ value });
+	if (!input) return {
+		success: false,
+		error: /* @__PURE__ */ new TypeError("[iten] Expected a route object with a name field")
+	};
+	const resolved = getSchema({
+		schemas,
+		name: input.name
+	});
+	if (!resolved) return {
+		success: false,
+		error: /* @__PURE__ */ new TypeError(`[iten] Unknown route name: ${String(input.name)}`)
+	};
+	const result = resolved.schema.safeParse(input.params);
+	if (!result.success) return {
+		success: false,
+		error: result.error
+	};
+	if (hasOwnName({ value: result.data })) return {
+		success: false,
+		error: /* @__PURE__ */ new TypeError("[iten] Zod route params must not include a name field")
+	};
+	return {
+		success: true,
+		route: {
+			name: resolved.name,
+			...result.data
+		}
+	};
+}
+//#endregion
+exports.createZodRoute = createZodRoute;
+exports.defineZodRoutes = defineZodRoutes;
+exports.parseZodRoute = parseZodRoute;
+exports.zodNoParams = zodNoParams;

package/dist/zod.d.cts

@@ -0,0 +1,48 @@
+import { RouteMap, RouteUnion } from "iten-core";
+import { z } from "zod";
+
+//#region src/zod.d.ts
+type ObjectParams = Record<string, unknown> & {
+  name?: never;
+};
+declare const noParamsBrand: unique symbol;
+type ZodNoParamsSchema = z.ZodDefault<z.ZodObject<Record<string, never>>> & {
+  readonly [noParamsBrand]: true;
+};
+type ZodRouteSchemas = Record<string, z.ZodType<ObjectParams, unknown>>;
+type ZodRouteMap<Schemas extends ZodRouteSchemas> = RouteMap<{ [K in Extract<keyof Schemas, string>]: z.output<Schemas[K]> }>;
+type ZodRouteUnion<Schemas extends ZodRouteSchemas> = RouteUnion<ZodRouteMap<Schemas>>;
+type EmptySchemaKeys<Schemas extends ZodRouteSchemas> = { [K in keyof Schemas]: Schemas[K] extends ZodNoParamsSchema ? K : never }[keyof Schemas];
+type ZodRouteFactory<Schemas extends ZodRouteSchemas> = {
+  <K extends Extract<EmptySchemaKeys<Schemas>, string>>(input: {
+    name: K;
+    input?: never;
+  }): Extract<ZodRouteUnion<Schemas>, {
+    name: K;
+  }>;
+  <K extends Exclude<Extract<keyof Schemas, string>, Extract<EmptySchemaKeys<Schemas>, string>>>(input: {
+    name: K;
+    input: z.input<Schemas[K]>;
+  }): Extract<ZodRouteUnion<Schemas>, {
+    name: K;
+  }>;
+};
+type ZodRouteParseResult<Schemas extends ZodRouteSchemas> = {
+  success: true;
+  route: ZodRouteUnion<Schemas>;
+} | {
+  success: false;
+  error: unknown;
+};
+declare function defineZodRoutes<const Schemas extends ZodRouteSchemas>(schemas: Schemas): Schemas;
+declare function zodNoParams(): ZodNoParamsSchema;
+declare function createZodRoute<const Schemas extends ZodRouteSchemas>(schemas: Schemas): ZodRouteFactory<Schemas>;
+declare function parseZodRoute<const Schemas extends ZodRouteSchemas>({
+  schemas,
+  value
+}: {
+  schemas: Schemas;
+  value: unknown;
+}): ZodRouteParseResult<Schemas>;
+//#endregion
+export { ZodRouteFactory, ZodRouteMap, ZodRouteParseResult, ZodRouteSchemas, ZodRouteUnion, createZodRoute, defineZodRoutes, parseZodRoute, zodNoParams };

package/dist/zod.d.ts

@@ -0,0 +1,48 @@
+import { RouteMap, RouteUnion } from "iten-core";
+import { z } from "zod";
+
+//#region src/zod.d.ts
+type ObjectParams = Record<string, unknown> & {
+  name?: never;
+};
+declare const noParamsBrand: unique symbol;
+type ZodNoParamsSchema = z.ZodDefault<z.ZodObject<Record<string, never>>> & {
+  readonly [noParamsBrand]: true;
+};
+type ZodRouteSchemas = Record<string, z.ZodType<ObjectParams, unknown>>;
+type ZodRouteMap<Schemas extends ZodRouteSchemas> = RouteMap<{ [K in Extract<keyof Schemas, string>]: z.output<Schemas[K]> }>;
+type ZodRouteUnion<Schemas extends ZodRouteSchemas> = RouteUnion<ZodRouteMap<Schemas>>;
+type EmptySchemaKeys<Schemas extends ZodRouteSchemas> = { [K in keyof Schemas]: Schemas[K] extends ZodNoParamsSchema ? K : never }[keyof Schemas];
+type ZodRouteFactory<Schemas extends ZodRouteSchemas> = {
+  <K extends Extract<EmptySchemaKeys<Schemas>, string>>(input: {
+    name: K;
+    input?: never;
+  }): Extract<ZodRouteUnion<Schemas>, {
+    name: K;
+  }>;
+  <K extends Exclude<Extract<keyof Schemas, string>, Extract<EmptySchemaKeys<Schemas>, string>>>(input: {
+    name: K;
+    input: z.input<Schemas[K]>;
+  }): Extract<ZodRouteUnion<Schemas>, {
+    name: K;
+  }>;
+};
+type ZodRouteParseResult<Schemas extends ZodRouteSchemas> = {
+  success: true;
+  route: ZodRouteUnion<Schemas>;
+} | {
+  success: false;
+  error: unknown;
+};
+declare function defineZodRoutes<const Schemas extends ZodRouteSchemas>(schemas: Schemas): Schemas;
+declare function zodNoParams(): ZodNoParamsSchema;
+declare function createZodRoute<const Schemas extends ZodRouteSchemas>(schemas: Schemas): ZodRouteFactory<Schemas>;
+declare function parseZodRoute<const Schemas extends ZodRouteSchemas>({
+  schemas,
+  value
+}: {
+  schemas: Schemas;
+  value: unknown;
+}): ZodRouteParseResult<Schemas>;
+//#endregion
+export { ZodRouteFactory, ZodRouteMap, ZodRouteParseResult, ZodRouteSchemas, ZodRouteUnion, createZodRoute, defineZodRoutes, parseZodRoute, zodNoParams };

package/dist/zod.mjs

@@ -0,0 +1,73 @@
+import { z } from "zod";
+//#region src/zod.ts
+function hasOwnName({ value }) {
+	return typeof value === "object" && value !== null && Object.hasOwn(value, "name");
+}
+function splitInput({ value }) {
+	if (typeof value !== "object" || value === null || !Object.hasOwn(value, "name")) return null;
+	const { name, ...params } = value;
+	return {
+		name,
+		params
+	};
+}
+function getSchema({ schemas, name }) {
+	if (typeof name !== "string" || !Object.hasOwn(schemas, name)) return null;
+	const routeName = name;
+	return {
+		name: routeName,
+		schema: schemas[routeName]
+	};
+}
+function defineZodRoutes(schemas) {
+	return schemas;
+}
+function zodNoParams() {
+	return z.object({}).strict().default({});
+}
+function createZodRoute(schemas) {
+	return (({ name, input }) => {
+		const schema = schemas[name];
+		if (!schema) throw new TypeError(`[iten] Unknown route name: ${String(name)}`);
+		if (hasOwnName({ value: input })) throw new TypeError("[iten] Zod route params must not include a name field");
+		const params = schema.parse(input ?? {});
+		if (hasOwnName({ value: params })) throw new TypeError("[iten] Zod route params must not include a name field");
+		return {
+			name,
+			...params
+		};
+	});
+}
+function parseZodRoute({ schemas, value }) {
+	const input = splitInput({ value });
+	if (!input) return {
+		success: false,
+		error: /* @__PURE__ */ new TypeError("[iten] Expected a route object with a name field")
+	};
+	const resolved = getSchema({
+		schemas,
+		name: input.name
+	});
+	if (!resolved) return {
+		success: false,
+		error: /* @__PURE__ */ new TypeError(`[iten] Unknown route name: ${String(input.name)}`)
+	};
+	const result = resolved.schema.safeParse(input.params);
+	if (!result.success) return {
+		success: false,
+		error: result.error
+	};
+	if (hasOwnName({ value: result.data })) return {
+		success: false,
+		error: /* @__PURE__ */ new TypeError("[iten] Zod route params must not include a name field")
+	};
+	return {
+		success: true,
+		route: {
+			name: resolved.name,
+			...result.data
+		}
+	};
+}
+//#endregion
+export { createZodRoute, defineZodRoutes, parseZodRoute, zodNoParams };