rouzer 3.0.1 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rouzer",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "type": "module",
   "exports": {
     ".": {
@@ -47,7 +47,7 @@
     "!*.tsbuildinfo"
   ],
   "scripts": {
-    "build": "tsgo -b tsconfig.json",
+    "build": "rm -rf dist && tsgo -b tsconfig.json",
     "test": "vitest run"
   }
 }

package/dist/internal.d.ts

@@ -1,17 +0,0 @@
-import type { RoutePattern } from '@remix-run/route-pattern';
-import type { RouteRequestFactory, RouteSchema } from './types.js';
-/** @internal */
-export type RouteSchemaMap = {
-    GET?: RouteSchema;
-    POST?: RouteSchema;
-    PUT?: RouteSchema;
-    PATCH?: RouteSchema;
-    DELETE?: RouteSchema;
-};
-/** @internal */
-export type Route<P extends string = string, T extends RouteSchemaMap = RouteSchemaMap> = {
-    path: RoutePattern<P>;
-    methods: T;
-} & {
-    [K in keyof T]: RouteRequestFactory<Extract<T[K], RouteSchema>, P>;
-};

package/dist/internal.js

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

package/dist/server/types.d.ts

@@ -1,42 +0,0 @@
-import type { MatchParams } from '@remix-run/route-pattern/match';
-import type { AnyMiddlewareChain, MiddlewareChain, MiddlewareContext } from 'alien-middleware';
-import type * as z from 'zod';
-import { Promisable } from '../common.js';
-import type { HttpAction, HttpResource, HttpRouteTree } from '../http.js';
-import type { InferRouteResponse, RouteSchema } from '../types.js';
-type RequestContext<TMiddleware extends AnyMiddlewareChain> = MiddlewareContext<TMiddleware>;
-type RouteRequestHandler<TMiddleware extends AnyMiddlewareChain, TArgs extends object, TResult> = (context: RequestContext<TMiddleware> & TArgs) => Promisable<TResult | Response>;
-type InferActionHandler<TMiddleware extends AnyMiddlewareChain, TAction extends HttpAction, TPath extends string> = TAction['method'] extends 'GET' ? RouteRequestHandler<TMiddleware, {
-    path: TAction['schema'] extends {
-        path: any;
-    } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
-    query: TAction['schema'] extends {
-        query: any;
-    } ? z.infer<TAction['schema']['query']> : undefined;
-    headers: TAction['schema'] extends {
-        headers: any;
-    } ? z.infer<TAction['schema']['headers']> : undefined;
-}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>> : RouteRequestHandler<TMiddleware, {
-    path: TAction['schema'] extends {
-        path: any;
-    } ? z.infer<TAction['schema']['path']> : MatchParams<TPath>;
-    body: TAction['schema'] extends {
-        body: any;
-    } ? z.infer<TAction['schema']['body']> : undefined;
-    headers: TAction['schema'] extends {
-        headers: any;
-    } ? z.infer<TAction['schema']['headers']> : undefined;
-}, InferRouteResponse<Extract<TAction['schema'], RouteSchema>>>;
-type Join<A extends string, B extends string> = A extends '' ? B : B extends '' ? A : `${A}/${B}`;
-/**
- * Handler map shape required by `createRouter().use(routes, handlers)`.
- *
- * @remarks The handler object mirrors the HTTP route tree. Resource nodes become
- * nested handler objects, while action nodes become direct handler functions.
- * Handler context is inferred from middleware plus accumulated path params,
- * query/body schemas, and header schemas.
- */
-export type RouteRequestHandlerMap<TRoutes extends HttpRouteTree = HttpRouteTree, TMiddleware extends AnyMiddlewareChain = MiddlewareChain, TPrefix extends string = ''> = {
-    [K in keyof TRoutes]: TRoutes[K] extends HttpResource<infer P, infer C> ? RouteRequestHandlerMap<C, TMiddleware, Join<TPrefix, P>> : TRoutes[K] extends HttpAction<infer P, any, any> ? InferActionHandler<TMiddleware, TRoutes[K], Join<TPrefix, P>> : never;
-};
-export {};

package/dist/server/types.js

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

package/dist/types.d.ts

@@ -1,140 +0,0 @@
-import type { MatchParams } from '@remix-run/route-pattern/match';
-import { RoutePattern } from '@remix-run/route-pattern';
-import * as z from 'zod';
-import { Unchecked } from './common.js';
-/**
- * Compile-time-only marker used by `$type<T>()` for unchecked response types.
- *
- * @remarks Application code should usually call `$type<T>()` instead of naming
- * this marker directly.
- */
-export type { Unchecked };
-/** Schema shape for `GET` route methods. */
-export type QueryRouteSchema = {
-    /** Optional Zod object used to validate path params. */
-    path?: z.ZodObject<any>;
-    /** Optional Zod object used to validate URL query params. */
-    query?: z.ZodObject<any>;
-    /** `GET` routes do not accept request bodies. */
-    body?: never;
-    /** Optional Zod object used to validate request headers. */
-    headers?: z.ZodObject<any>;
-    /** Optional compile-time-only JSON response type marker. */
-    response?: Unchecked<any>;
-};
-/** Schema shape for mutation route methods. */
-export type MutationRouteSchema = {
-    /** Optional Zod object used to validate path params. */
-    path?: z.ZodObject<any>;
-    /** Mutation routes do not accept query schemas. */
-    query?: never;
-    /** Optional Zod schema used to validate the JSON request body. */
-    body?: z.ZodType<any, any>;
-    /** Optional Zod object used to validate request headers. */
-    headers?: z.ZodObject<any>;
-    /** Optional compile-time-only JSON response type marker. */
-    response?: Unchecked<any>;
-};
-/** Any HTTP action schema Rouzer can execute. */
-export type RouteSchema = QueryRouteSchema | MutationRouteSchema;
-declare class Any {
-    private isAny;
-}
-type PathArgs<T, P extends string> = T extends {
-    path: infer TPath;
-} ? {} extends z.infer<TPath> ? {
-    [K in keyof T as 'path']?: z.infer<TPath>;
-} : {
-    [K in keyof T as 'path']: z.infer<TPath>;
-} : MatchParams<P> extends infer TParams ? {} extends TParams ? {
-    [K in keyof T as 'path']?: TParams;
-} : {
-    [K in keyof T as 'path']: TParams;
-} : unknown;
-type QueryArgs<T> = T extends QueryRouteSchema & {
-    query: infer TQuery;
-} ? {} extends z.infer<TQuery> ? {
-    [K in keyof T as 'query']?: z.infer<TQuery>;
-} : {
-    [K in keyof T as 'query']: z.infer<TQuery>;
-} : unknown;
-type MutationArgs<T> = T extends MutationRouteSchema ? T extends {
-    body: infer TBody;
-} ? {} extends z.infer<TBody> ? {
-    [K in keyof T as 'body']?: z.infer<TBody>;
-} : {
-    [K in keyof T as 'body']: z.infer<TBody>;
-} : {
-    body?: unknown;
-} : unknown;
-/**
- * Arguments accepted by a client action function or low-level request factory.
- *
- * @remarks The type is derived from an action schema and route pattern. `path`,
- * `query`, `body`, and `headers` are validated by the client before `fetch` when
- * a matching schema exists. Other `RequestInit` fields are forwarded to `fetch`,
- * except `method`, `body`, and `headers`, which Rouzer derives from the action
- * schema and call arguments.
- */
-export type RouteArgs<T extends RouteSchema = any, P extends string = string> = ([T] extends [Any] ? {
-    query?: any;
-    body?: any;
-    path?: any;
-} : QueryArgs<T> & MutationArgs<T> & PathArgs<T, P>) & Omit<RequestInit, 'method' | 'body' | 'headers'> & {
-    /** Headers for this request. Undefined values are removed before `fetch`. */
-    headers?: Record<string, string | undefined>;
-};
-/**
- * Request descriptor produced by an HTTP action request factory.
- *
- * @remarks Pass this object to `client.request(...)` for a raw `Response` or
- * `client.json(...)` for parsed JSON handling.
- */
-export type RouteRequest<TResult = any> = {
-    /** Method schema used for client-side validation. */
-    schema: RouteSchema;
-    /** Parsed route pattern used to generate the request URL. */
-    path: RoutePattern;
-    /** HTTP method to send. */
-    method: string;
-    /** Validated route arguments and request options. */
-    args: RouteArgs;
-    /** Phantom result type consumed by `client.json(...)`. */
-    $result: TResult;
-};
-/** `Response` whose `.json()` method resolves to a known payload type. */
-export type RouteResponse<TResult = any> = Response & {
-    json(): Promise<TResult>;
-};
-/** Infer the JSON response payload type from an action schema. */
-export type InferRouteResponse<T extends RouteSchema> = T extends {
-    response: Unchecked<infer TResponse>;
-} ? TResponse : void;
-type InferRouteSchemaBody<TSchema> = TSchema extends MutationRouteSchema ? TSchema extends {
-    body: infer TBody;
-} ? z.infer<TBody> : unknown : never;
-type InferRouteArgsBody<TArgs> = TArgs extends {
-    body?: infer TBody;
-} ? TBody : never;
-/**
- * Infer the request body type from an action schema or request factory.
- *
- * @remarks HTTP action schemas can be inspected with
- * `InferRouteBody<typeof action.schema>`. Request factories for mutation actions
- * infer their `body` argument type. Schemas without a body schema infer
- * `unknown`.
- */
-export type InferRouteBody<T> = T extends RouteRequestFactory<any, any> ? InferRouteArgsBody<T['$args']> : T extends RouteSchema ? InferRouteSchemaBody<T> : never;
-/**
- * Callable factory attached to an HTTP action.
- *
- * @remarks Calling a factory validates no data by itself; it creates a typed
- * `RouteRequest` descriptor for `createClient` to validate and send.
- */
-export type RouteRequestFactory<T extends RouteSchema, P extends string> = {
-    (...p: RouteArgs<T, P> extends infer TArgs ? {} extends TArgs ? [args?: TArgs] : [args: TArgs] : never): RouteRequest<InferRouteResponse<T>>;
-    /** Inferred argument type for this request factory. */
-    $args: RouteArgs<T, P>;
-    /** Inferred JSON response type for this request factory. */
-    $response: InferRouteResponse<T>;
-};

package/dist/types.js

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