react-iten 0.0.2 → 0.4.2

package/src/zod.ts

@@ -0,0 +1,150 @@
+import type { RouteMap, RouteUnion } from 'iten-core'
+import { z } from 'zod'
+
+type ObjectParams = Record<string, unknown> & { name?: never }
+
+declare const noParamsBrand: unique symbol
+
+type ZodNoParamsSchema = z.ZodDefault<z.ZodObject<Record<string, never>>> & {
+  readonly [noParamsBrand]: true
+}
+
+export type ZodRouteSchemas = Record<string, z.ZodType<ObjectParams, unknown>>
+
+export type ZodRouteMap<Schemas extends ZodRouteSchemas> = RouteMap<{
+  [K in Extract<keyof Schemas, string>]: z.output<Schemas[K]>
+}>
+
+export 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]
+
+export 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 }>
+}
+
+export type ZodRouteParseResult<Schemas extends ZodRouteSchemas> =
+  | { success: true; route: ZodRouteUnion<Schemas> }
+  | { success: false; error: unknown }
+
+function hasOwnName({ value }: { value: unknown }): boolean {
+  return typeof value === 'object' && value !== null && Object.hasOwn(value, 'name')
+}
+
+function splitInput({ value }: { value: unknown }): { name: unknown; params: unknown } | null {
+  if (typeof value !== 'object' || value === null || !Object.hasOwn(value, 'name')) {
+    return null
+  }
+
+  const { name, ...params } = value as { name: unknown } & Record<string, unknown>
+  return { name, params }
+}
+
+function getSchema<const Schemas extends ZodRouteSchemas>({
+  schemas,
+  name,
+}: {
+  schemas: Schemas
+  name: unknown
+}): {
+  name: Extract<keyof Schemas, string>
+  schema: Schemas[Extract<keyof Schemas, string>]
+} | null {
+  if (typeof name !== 'string' || !Object.hasOwn(schemas, name)) {
+    return null
+  }
+  const routeName = name as Extract<keyof Schemas, string>
+  return { name: routeName, schema: schemas[routeName] }
+}
+
+export function defineZodRoutes<const Schemas extends ZodRouteSchemas>(schemas: Schemas): Schemas {
+  return schemas
+}
+
+export function zodNoParams(): ZodNoParamsSchema {
+  return z.object({}).strict().default({}) as ZodNoParamsSchema
+}
+
+export function createZodRoute<const Schemas extends ZodRouteSchemas>(
+  schemas: Schemas,
+): ZodRouteFactory<Schemas> {
+  return (({
+    name,
+    input,
+  }: {
+    name: Extract<keyof Schemas, string>
+    input?: z.input<Schemas[typeof name]>
+  }) => {
+    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 }
+  }) as unknown as ZodRouteFactory<Schemas>
+}
+
+export function parseZodRoute<const Schemas extends ZodRouteSchemas>({
+  schemas,
+  value,
+}: {
+  schemas: Schemas
+  value: unknown
+}): ZodRouteParseResult<Schemas> {
+  const input = splitInput({ value })
+
+  if (!input) {
+    return {
+      success: false,
+      error: new TypeError('[iten] Expected a route object with a name field'),
+    }
+  }
+
+  const resolved = getSchema({ schemas, name: input.name })
+
+  if (!resolved) {
+    return {
+      success: false,
+      error: 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: new TypeError('[iten] Zod route params must not include a name field'),
+    }
+  }
+
+  return {
+    success: true,
+    route: { name: resolved.name, ...result.data } as ZodRouteUnion<Schemas>,
+  }
+}

package/index.js

@@ -1 +0,0 @@
-throw new Error('react-iten is reserved for the upcoming React adapter. Use jotai-iten today.')