rpc4next 0.4.0 → 0.4.10

package/dist/index.js

@@ -0,0 +1 @@
+export*from"./rpc/server";export*from"./rpc/client";

package/dist/rpc/client/client-utils.d.ts

@@ -1,5 +1,11 @@
 import type { HttpMethodFuncKey } from "./types";
+/**
+ * Returns true if the given key represents a dynamic segment.
+ */
 export declare const isDynamic: (key: string) => boolean;
+/**
+ * Returns true if the key represents a catch-all or optional catch-all segment.
+ */
 export declare const isCatchAllOrOptional: (key: string) => boolean;
 export declare const isHttpMethod: (value: string) => value is HttpMethodFuncKey;
 export declare const deepMerge: <T extends object, U extends object>(target: T, source: U) => T;

package/dist/rpc/client/client-utils.js

@@ -1 +1 @@
-import{DYNAMIC_PREFIX as i,CATCH_ALL_PREFIX as a,OPTIONAL_CATCH_ALL_PREFIX as p,HTTP_METHOD_FUNC_KEYS as u}from"../lib/constants";const T=t=>t.startsWith(i),l=t=>t.startsWith(a)||t.startsWith(p),y=new Set(u),A=t=>y.has(t),c=t=>typeof t=="object"&&t!==null&&!Array.isArray(t),d=(t,n)=>{const s={...t};for(const e in n)if(Object.prototype.hasOwnProperty.call(n,e)){const r=t[e],o=n[e];c(r)&&c(o)?s[e]=d(r,o):s[e]=o}return s};export{d as deepMerge,l as isCatchAllOrOptional,T as isDynamic,A as isHttpMethod};
+import{DYNAMIC_PREFIX as i,CATCH_ALL_PREFIX as a,OPTIONAL_CATCH_ALL_PREFIX as p,HTTP_METHOD_FUNC_KEYS as u}from"rpc4next-shared";const T=t=>t.startsWith(i),l=t=>t.startsWith(a)||t.startsWith(p),y=new Set(u),A=t=>y.has(t),c=t=>typeof t=="object"&&t!==null&&!Array.isArray(t),d=(t,n)=>{const s={...t};for(const e in n)if(Object.prototype.hasOwnProperty.call(n,e)){const r=t[e],o=n[e];c(r)&&c(o)?s[e]=d(r,o):s[e]=o}return s};export{d as deepMerge,l as isCatchAllOrOptional,T as isDynamic,A as isHttpMethod};

package/dist/rpc/client/http-method.d.ts

@@ -1,6 +1,22 @@
 import type { FuncParams, UrlOptions, ClientOptions, BodyOptions, HeadersOptions } from "./types";
+/** Local, non-breaking extension for future body shapes */
+type ExtendedBodyOptions = BodyOptions & {
+    text?: string;
+    formData?: FormData;
+    urlencoded?: URLSearchParams;
+    raw?: BodyInit;
+};
+/**
+ * Build a typed HTTP method invoker.
+ * - Header precedence: default < options.init < methodParam.requestHeaders
+ * - Do NOT override user-specified `content-type`.
+ * - Merge cookies instead of clobbering.
+ * - Never attach a body for GET/HEAD.
+ * - Provide basic body-shape inference (json/text/formData/urlencoded) while keeping current types compatible.
+ */
 export declare const httpMethod: (key: string, paths: string[], params: FuncParams, dynamicKeys: string[], defaultOptions: ClientOptions) => (methodParam?: {
     url?: UrlOptions;
-    body?: BodyOptions;
+    body?: ExtendedBodyOptions;
     requestHeaders?: HeadersOptions;
 }, options?: ClientOptions) => Promise<Response>;
+export {};

package/dist/rpc/client/http-method.js

@@ -1 +1 @@
-import{deepMerge as R}from"./client-utils";import{createUrl as T}from"./url";import{normalizeHeaders as p}from"../lib/headers";const W=(f,u,h,y,d)=>async(e,a)=>{let s,r;e?.body?.json&&(r="application/json",s=JSON.stringify(e.body.json));const m=e?.requestHeaders?.headers,c=e?.requestHeaders?.cookies,l=T([...u],h,y)(e?.url),H=f.replace(/^\$/,"").toUpperCase(),g=a?.fetch??d.fetch??fetch,i=d.init??{},o=a?.init??{},I=p(i.headers??i.headersInit),O=p(m??o.headers??o.headersInit),t={...I,...O};r&&(t["content-type"]=r),c&&(t.cookie=Object.entries(c).map(([j,q])=>`${j}=${q}`).join("; "));const{headers:k,headersInit:B,...b}=i,{headers:U,headersInit:_,...C}=o,n=R(b,C);return n.method=H,Object.keys(t).length>0&&(n.headers=t),s&&(n.body=s),await g(l.path,n)};export{W as httpMethod};
+import{deepMerge as x}from"./client-utils";import{createUrl as R}from"./url";import{normalizeHeaders as l}from"../lib/headers";const H=n=>{if(!n)return{};const{headers:i,headersInit:m,...p}=n;return p},U=n=>"content-type"in n?!0:Object.keys(n).some(i=>i.toLowerCase()==="content-type"),B=(n,i,m,p,g)=>async(d,O)=>{const a=n.replace(/^\$/,"").toUpperCase(),I=R([...i],m,p)(d?.url),C=O?.fetch??g.fetch??fetch,f=g.init,u=O?.init,w=l(f?.headers??f?.headersInit),T=l(u?.headers??u?.headersInit),j=l(d?.requestHeaders?.headers),o={...w,...T,...j},b=o.cookie,y=d?.requestHeaders?.cookies;if(y&&Object.keys(y).length>0){const s=Object.entries(y).map(([h,k])=>`${h}=${k}`).join("; ");o.cookie=b?`${b}; ${s}`:s}let t,r;const e=d?.body;e?.json!==void 0?(t=JSON.stringify(e.json),r="application/json"):typeof e?.text=="string"?(t=e.text,r="text/plain; charset=utf-8"):e?.formData instanceof FormData?(t=e.formData,r=void 0):e?.urlencoded instanceof URLSearchParams?(t=e.urlencoded,r="application/x-www-form-urlencoded; charset=UTF-8"):e?.raw!==void 0&&(t=e.raw,r=void 0),(a==="GET"||a==="HEAD")&&(t=void 0),!U(o)&&t&&r&&(o["content-type"]=r);const c=x(H(f),H(u));c.method=a,Object.keys(o).length>0&&(c.headers=o),t!==void 0&&(c.body=t);try{return await C(I.path,c)}catch(s){const h=s instanceof Error?s.message:String(s);throw new Error(`[httpMethod] ${a} ${I.path} failed: ${h}`)}};export{B as httpMethod};

package/dist/rpc/client/match.d.ts

@@ -1,5 +1,12 @@
+type ParamValue = string | string[] | undefined;
+/**
+ * Match a URL (string) against a pre-defined path pattern array.
+ * @param paths e.g. ["/", "users", "_id"] or ["users", "_id"]
+ * @param dynamicKeys keys in the same order the capturing groups appear
+ */
 export declare const matchPath: (paths: string[], dynamicKeys: string[]) => (input: string) => {
-    params: Record<string, string | string[] | undefined>;
+    params: Record<string, ParamValue>;
     query: Record<string, string | string[] | undefined>;
     hash: string | undefined;
 } | null;
+export {};

package/dist/rpc/client/match.js

@@ -1 +1 @@
-import{isCatchAllOrOptional as g}from"./client-utils";import{replaceDynamicSegments as R}from"./url";import{searchParamsToObject as C}from"../lib/search-params";const U=(r,o)=>c=>{const e=new URL(c,"http://dummy"),s=e.pathname,m=`/${r.slice(1).join("/")}`,i=R(m,{optionalCatchAll:"(?:/(.*))?",catchAll:"/([^/]+(?:/[^/]+)*)",dynamic:"/([^/]+)"}),t=new RegExp(`^${i}/?$`).exec(s);if(!t)return null;const l=o.reduce((h,a,d)=>{const u=a.replace(/^_+/,""),n=t[d+1],f=g(a)?n===void 0||n===""?void 0:n.split("/").filter(Boolean).map(decodeURIComponent):decodeURIComponent(n);return{...h,[u]:f}},{}),p=C(e.searchParams);return{params:l,query:p,hash:e.hash?decodeURIComponent(e.hash.slice(1)):void 0}};export{U as matchPath};
+import{isCatchAllOrOptional as w}from"./client-utils";import{replaceDynamicSegments as x}from"./url";import{searchParamsToObject as L}from"../lib/search-params";const o=n=>{if(n!=null)try{return decodeURIComponent(n)}catch{return n}},$=n=>{const e=n.join("/").replace(/\/+/g,"/");return(e.startsWith("/")?e:`/${e}`).replace(/\/+$/,"")||"/"},O=(n,e)=>{const l=$(n),u=x(l,{optionalCatchAll:"(?:/(.*))?",catchAll:"/([^/]+(?:/[^/]+)*)",dynamic:"/([^/]+)"}),m=new RegExp(`^${u}(?:/)?$`);return p=>{let t;try{t=new URL(p,"http://dummy")}catch{return null}const f=t.pathname,d=m.exec(f);if(!d)return null;const a={};for(let s=0;s<e.length;s++){const h=e[s],i=h.replace(/^_+/,""),r=d[s+1];if(w(h))if(r==null||r==="")a[i]=void 0;else{const R=r.split("/").filter(Boolean).map(c=>o(c)).filter(c=>c!==void 0);a[i]=R}else a[i]=o(r)}const g=L(t.searchParams),P=t.hash?t.hash.slice(1):void 0,y=o(P);return{params:a,query:g,hash:y}}};export{O as matchPath};

package/dist/rpc/client/rpc.js

@@ -2,4 +2,4 @@
  * Inspired by the design of Hono (https://github.com/honojs/hono)
  * and pathpida (https://github.com/aspida/pathpida)
  * particularly their routing structures and developer experience.
- */import{isDynamic as f}from"./client-utils";const s=(n,e,t,c,o)=>new Proxy(u=>{const r=t.at(-1),i=o.at(-1);if(u===void 0)throw new Error(`Missing value for dynamic parameter: ${i}`);if(r&&i&&f(r))return s(n,e,[...t],{...c,[i]:u},o);throw new Error(`${r} is not dynamic`)},{get(u,r){const i=n(r,{paths:t,params:c,dynamicKeys:o,options:e});return i!==void 0?i:f(r)?s(n,e,[...t,r],c,[...o,r]):s(n,e,[...t,r],c,o)}}),l=n=>(e="/",t={})=>s(n,t,[e],{},[]);export{l as makeCreateRpc};
+ */import{isDynamic as g}from"./client-utils";const l=(r,e,n,s,o)=>{const p=function(){};return new Proxy(p,{apply(a,u,t){const i=t[0],c=n[n.length-1],f=o[o.length-1];if(!c||!g(c))throw new Error(`Cannot apply a value: "${c??""}" is not a dynamic segment.`);if(i===void 0){const d=f??c;throw new Error(`Missing value for dynamic parameter: ${String(d)}`)}return l(r,e,n,{...s,[f]:i},o)},get(a,u){if(u==="then"||typeof u=="symbol")return;const t=String(u),i=r(t,{paths:n,params:s,dynamicKeys:o,options:e});return i!==void 0?i:g(t)?l(r,e,[...n,t],s,[...o,t]):l(r,e,[...n,t],s,o)}})},T=r=>(e="/",n={})=>l(r,n,[e],{},[]);export{T as makeCreateRpc};

package/dist/rpc/client/types.d.ts

@@ -1,10 +1,10 @@
-import type { OPTIONAL_CATCH_ALL_PREFIX, CATCH_ALL_PREFIX, DYNAMIC_PREFIX, HTTP_METHOD_FUNC_KEYS } from "../lib/constants";
 import type { ContentType } from "../lib/content-type-types";
 import type { HttpRequestHeaders } from "../lib/http-request-headers-types";
 import type { HttpStatusCode } from "../lib/http-status-code-types";
 import type { RouteHandlerResponse, RouteResponse, ValidationSchema } from "../server/route-types";
 import type { TypedNextResponse, ValidationInputFor } from "../server/types";
 import type { NextResponse } from "next/server";
+import type { OPTIONAL_CATCH_ALL_PREFIX, CATCH_ALL_PREFIX, DYNAMIC_PREFIX, HTTP_METHOD_FUNC_KEYS } from "rpc4next-shared";
 type DistributeOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 /**
  * Extension of the standard `RequestInit` interface with strongly typed headers.

package/dist/rpc/client/url.d.ts

@@ -1,8 +1,126 @@
 import type { UrlOptions, UrlResult, FuncParams } from "./types";
+/**
+ * Builds a URL suffix string from optional query and hash values.
+ *
+ * This utility generates the trailing portion of a URL, consisting of:
+ * - A query string (e.g. `?key=value&foo=bar`)
+ * - A hash fragment (e.g. `#section`)
+ *
+ * If both are present, they are concatenated in the order:
+ * `?query#hash`.
+ *
+ * If `url` is `undefined` or neither `query` nor `hash` is provided,
+ * an empty string is returned.
+ *
+ * @example
+ * buildUrlSuffix({
+ *   query: { page: "1", sort: "asc" },
+ *   hash: "top"
+ * });
+ * // => "?page=1&sort=asc#top"
+ *
+ * @example
+ * buildUrlSuffix({ hash: "section" });
+ * // => "#section"
+ *
+ * @example
+ * buildUrlSuffix();
+ * // => ""
+ *
+ * @param url - Optional URL options containing query parameters and/or a hash fragment.
+ * @returns A URL suffix string beginning with `?` and/or `#`, or an empty string if none exist.
+ */
 export declare const buildUrlSuffix: (url?: UrlOptions) => string;
+/**
+ * Replaces dynamic route segment markers in a base path string.
+ *
+ * This utility transforms special placeholder patterns in `basePath`
+ * into concrete replacement strings.
+ *
+ * It supports three types of dynamic segments:
+ *
+ * - **Optional catch-all**: `"/_____<name>"` (5 underscores)
+ * - **Catch-all**: `"/___<name>"` (3 underscores)
+ * - **Dynamic segment**: `"/_<name>"` (1 underscore)
+ *
+ * Each matched segment (including its leading slash) is replaced
+ * with the corresponding value from the `replacements` object.
+ *
+ * Replacement is performed in the following order:
+ * 1. optionalCatchAll
+ * 2. catchAll
+ * 3. dynamic
+ *
+ * This ordering ensures that longer patterns are processed before
+ * shorter ones to avoid partial matching.
+ *
+ * @example
+ * ```ts
+ * replaceDynamicSegments(
+ *   "/users/_id/posts/___slug/files/_____path",
+ *   {
+ *     dynamic: ":id",
+ *     catchAll: "*",
+ *     optionalCatchAll: "**",
+ *   }
+ * );
+ * ```
+ *
+ * @param basePath - The path string containing dynamic segment markers.
+ * @param replacements - Replacement strings for each dynamic segment type.
+ * @param replacements.optionalCatchAll - Replacement for `"/_____<name>"` segments.
+ * @param replacements.catchAll - Replacement for `"/___<name>"` segments.
+ * @param replacements.dynamic - Replacement for `"/_<name>"` segments.
+ *
+ * @returns A new path string with all dynamic segment markers replaced.
+ */
 export declare const replaceDynamicSegments: (basePath: string, replacements: {
     optionalCatchAll: string;
     catchAll: string;
     dynamic: string;
 }) => string;
+/**
+ * Creates a URL builder for a route definition.
+ *
+ * This function takes a list of path segments (e.g. `["api", "users", "[id]"]`),
+ * a params object, and a list of dynamic keys used in the path, then returns a
+ * function that can build a concrete URL string plus related metadata.
+ *
+ * Dynamic segments are replaced using `dynamicKeys`:
+ * - If `params[key]` is an array, it is treated as a catch-all segment and each
+ *   element is URL-encoded then joined by `/`.
+ * - If `params[key]` is `undefined`, the segment is removed (useful for optional
+ *   segments).
+ * - Otherwise, the value is URL-encoded and substituted into the segment.
+ *
+ * The returned builder optionally appends a suffix (e.g. query/hash) via
+ * `buildUrlSuffix(url)` and also produces a Next.js-style `pathname` by converting
+ * dynamic markers using `replaceDynamicSegments`.
+ *
+ * In addition, params keys are normalized by removing leading underscores
+ * (e.g. `__id` -> `id`) in the returned `params`.
+ *
+ * @param paths - Path segments. The first element is treated as an optional base
+ * URL, and the remaining segments form the route path.
+ * @param params - Parameters used to replace dynamic segments. Values may be
+ * `string`, `string[]`, or `undefined` depending on the segment type.
+ * @param dynamicKeys - Keys representing dynamic segments present in the path,
+ * used to substitute values from `params`.
+ * @returns A builder function that accepts URL options and returns a `UrlResult`.
+ *
+ * @example
+ * ```ts
+ * const build = createUrl(
+ *   ["https://example.com", "users", "id"],
+ *   { id: "a b" },
+ *   ["id"],
+ * );
+ *
+ * const result = build({ query: { page: "1" } });
+ * // result.path: "https://example.com/users/a%20b?page=1"
+ * // result.relativePath: "/users/a%20b?page=1"
+ * // result.pathname: "/users/[$1]" (depending on replaceDynamicSegments behavior)
+ * // result.params: { id: "a b" }
+ * ```
+ */
 export declare const createUrl: (paths: string[], params: FuncParams, dynamicKeys: string[]) => (url?: UrlOptions) => UrlResult;

package/dist/rpc/lib/headers.d.ts

@@ -1 +1,36 @@
+/**
+ * Normalizes various `HeadersInit` formats into a plain object
+ * with lower-cased header names.
+ *
+ * This utility converts `Headers`, an array of `[key, value]` tuples,
+ * or a plain object into a `Record<string, string>`.
+ *
+ * All header names are converted to lowercase to ensure
+ * case-insensitive consistency when accessing header values.
+ *
+ * @param headers - A `HeadersInit` value (`Headers`, `[string, string][]`, or `Record<string, string>`).
+ *                  If `undefined`, an empty object is returned.
+ *
+ * @returns A plain object whose keys are lower-cased header names
+ *          and whose values are header strings.
+ *
+ * @example
+ * ```ts
+ * const headers = new Headers({
+ *   "Content-Type": "application/json",
+ *   "Authorization": "Bearer token",
+ * });
+ *
+ * const normalized = normalizeHeaders(headers);
+ * // {
+ * //   "content-type": "application/json",
+ * //   "authorization": "Bearer token"
+ * // }
+ * ```
+ *
+ * @remarks
+ * - If duplicate header names exist (ignoring case),
+ *   the last encountered value will overwrite previous ones.
+ * - This function does not merge multiple values for the same header.
+ */
 export declare const normalizeHeaders: (headers?: HeadersInit) => Record<string, string>;

package/dist/rpc/lib/search-params.d.ts

@@ -1 +1,35 @@
+/**
+ * Converts a `URLSearchParams` instance into a plain object.
+ *
+ * This utility aggregates query parameters into an object where:
+ * - The first occurrence of a key becomes a `string`
+ * - If the same key appears multiple times, the value becomes a `string[]`
+ *
+ * The returned object is cast to the generic type `T`. This is a **type-level**
+ * convenience: the runtime output only contains `string` or `string[]` values
+ * (no `undefined` keys are produced).
+ *
+ * @typeParam T - The desired return shape. Must be a record of `string` keys
+ * with values `string | string[] | undefined`. Note: `undefined` is allowed in
+ * the type to support downstream optional fields, but is not produced at runtime.
+ *
+ * @param searchParams - The `URLSearchParams` to convert.
+ * @returns A plain object containing the query parameters.
+ *
+ * @example
+ * ```ts
+ * const sp = new URLSearchParams("q=chatgpt&tag=a&tag=b");
+ * const obj = searchParamsToObject(sp);
+ * // => { q: "chatgpt", tag: ["a", "b"] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Params = { q?: string; tag?: string[] };
+ * const sp = new URLSearchParams("q=hello&tag=a&tag=b");
+ * const obj = searchParamsToObject<Params>(sp);
+ * // obj.q is typed as string | undefined
+ * // obj.tag is typed as string[] | undefined
+ * ```
+ */
 export declare const searchParamsToObject: <T extends Record<string, string | string[] | undefined>>(searchParams: URLSearchParams) => T;

package/dist/rpc/lib/types.d.ts

@@ -1,2 +1 @@
-import type { HTTP_METHODS } from "./constants";
-export type HttpMethod = (typeof HTTP_METHODS)[number];
+export type { HttpMethod } from "rpc4next-shared";

package/dist/rpc/server/handler.d.ts

@@ -1,4 +1,4 @@
 import type { ValidationSchema, RouteResponse, Handler } from "./route-types";
 import type { Params, Query } from "./types";
-import type { HttpMethod } from "../lib/types";
+import type { HttpMethod } from "rpc4next-shared";
 export declare const createHandler: <THttpMethod extends HttpMethod, TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>() => <TRouteResponse extends RouteResponse>(handler: Handler<THttpMethod, TParams, TQuery, TValidationSchema, TRouteResponse>) => Handler<THttpMethod, TParams, TQuery, TValidationSchema, TRouteResponse>;

package/dist/rpc/server/route-handler-factory.js

@@ -1,4 +1,4 @@
 /*!
  * Inspired by Hono (https://github.com/honojs/hono),
  * particularly its routing design and handler interface.
- */import{createRouteContext as d}from"./route-context";const i=(o,e)=>async(n,s)=>{const a=d(n,s);try{for(const t of o){const r=await t(a);if(r instanceof Response)return r}throw new Error("No handler returned a response")}catch(t){return await e(t,a)}},T=o=>()=>{const e=n=>(...s)=>{const t=i(s,o??((r,p)=>{throw r}));return{[n]:t}};return{get:e("GET"),post:e("POST"),put:e("PUT"),delete:e("DELETE"),patch:e("PATCH"),head:e("HEAD"),options:e("OPTIONS")}};export{T as routeHandlerFactory};
+ */import{createRouteContext as d}from"./route-context";const i=(o,e)=>async(n,s)=>{const a=d(n,s);try{for(const r of o){const t=await r(a);if(t instanceof Response)return t}throw new Error("No handler returned a response")}catch(r){return await e(r,a)}},T=o=>()=>{const e=n=>((...s)=>{const r=i(s,o??((t,p)=>{throw t}));return{[n]:r}});return{get:e("GET"),post:e("POST"),put:e("PUT"),delete:e("DELETE"),patch:e("PATCH"),head:e("HEAD"),options:e("OPTIONS")}};export{T as routeHandlerFactory};

package/dist/rpc/server/route-types.d.ts

@@ -7,8 +7,8 @@
  * Hono is licensed under the MIT License.
  */
 import type { TypedNextResponse, Query, RouteContext, Params } from "./types";
-import type { HttpMethod } from "../lib/types";
 import type { NextRequest } from "next/server";
+import type { HttpMethod } from "rpc4next-shared";
 export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | void>;
 export type RequiredRouteResponse = TypedNextResponse | Promise<TypedNextResponse>;
 export interface RouteBindings {

package/dist/rpc/server/types.d.ts

@@ -2,8 +2,8 @@ import type { ValidationSchema } from "./route-types";
 import type { ContentType } from "../lib/content-type-types";
 import type { HttpResponseHeaders } from "../lib/http-response-headers-types";
 import type { HttpStatusCode, RedirectionHttpStatusCode, SuccessfulHttpStatusCode } from "../lib/http-status-code-types";
-import type { HttpMethod } from "../lib/types";
 import type { NextResponse, NextRequest } from "next/server";
+import type { HttpMethod } from "rpc4next-shared";
 /**
  * Represents the result of an HTTP response status check.
  *

package/dist/rpc/server/validators/validator.d.ts

@@ -6,7 +6,7 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
-import type { HttpMethod } from "../../lib/types";
 import type { ValidationSchema } from "../route-types";
 import type { Params, Query, RouteContext, TypedNextResponse, ValidatedData, ValidationTarget } from "../types";
+import type { HttpMethod } from "rpc4next-shared";
 export declare const validator: <THttpMethod extends HttpMethod, TValidationTarget extends ValidationTarget<THttpMethod>, TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>() => <TTypedNextResponse extends TypedNextResponse>(target: TValidationTarget, validateHandler: (value: object, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => Promise<ValidatedData | TTypedNextResponse>) => import("../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<TTypedNextResponse | undefined>>;

package/dist/rpc/server/validators/validator.js

@@ -5,4 +5,4 @@
  * This code has been adapted and modified for this project.
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
- */import{createHandler as i}from"../handler";import{getCookiesObject as n,getHeadersObject as s}from"./validator-utils";const T=()=>(e,r)=>i()(async t=>{const o=await(async()=>{if(e==="params")return await t.req.params();if(e==="query")return t.req.query();if(e==="json")return t.req.json();if(e==="headers")return await s();if(e==="cookies")return await n();throw new Error(`Unexpected target: ${e}`)})(),a=await r(o,t);if(a instanceof Response)return a;t.req.addValidatedData(e,a)});export{T as validator};
+ */import{createHandler as n}from"../handler";import{getCookiesObject as i,getHeadersObject as s}from"./validator-utils";const T=()=>(e,r)=>n()(async t=>{const o=await(async()=>{if(e==="params")return await t.req.params();if(e==="query")return t.req.query();if(e==="json")return t.req.json();if(e==="headers")return await s();if(e==="cookies")return await i();throw new Error(`Unexpected target: ${e}`)})(),a=await r(o,t);if(a instanceof Response)return a;t.req.addValidatedData(e,a)});export{T as validator};

package/dist/rpc/server/validators/zod/zod-validator.d.ts

@@ -6,11 +6,11 @@
  * Original copyright belongs to Yusuke Wada and the Hono project contributors.
  * Hono is licensed under the MIT License.
  */
-import type { HttpMethod } from "../../../lib/types";
 import type { ValidationSchema } from "../../route-types";
 import type { RouteContext, Params, Query, TypedNextResponse, ConditionalValidationInput, ValidationTarget } from "../../types";
+import type { HttpMethod } from "rpc4next-shared";
 import type { z, ZodSchema } from "zod";
 export declare const zValidator: <THttpMethod extends HttpMethod, TValidationTarget extends ValidationTarget<THttpMethod>, TSchema extends ZodSchema<any>, TParams extends ConditionalValidationInput<TValidationTarget, "params", TValidationSchema, Params> & Params, TQuery extends ConditionalValidationInput<TValidationTarget, "query", TValidationSchema, Query> & Query, TInput = z.input<TSchema>, TOutput = z.output<TSchema>, TValidationSchema extends ValidationSchema = {
     input: Record<TValidationTarget, TInput>;
     output: Record<TValidationTarget, TOutput>;
-}, THookReturn extends TypedNextResponse | void = TypedNextResponse<z.SafeParseError<TInput>, 400, "application/json"> | void>(target: TValidationTarget, schema: TSchema, hook?: (result: z.SafeParseReturnType<TInput, TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;
+}, THookReturn extends TypedNextResponse | void = TypedNextResponse<z.ZodSafeParseError<TInput>, 400, "application/json"> | void>(target: TValidationTarget, schema: TSchema, hook?: (result: z.ZodSafeParseResult<TOutput>, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => THookReturn) => import("../../route-types").Handler<THttpMethod, TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;

package/package.json

@@ -1,22 +1,25 @@
 {
   "name": "rpc4next",
-  "version": "0.4.0",
   "description": "Inspired by Hono RPC and Pathpida, rpc4next brings a lightweight and intuitive RPC solution to Next.js, making server-client communication seamless",
   "author": "watanabe-1",
   "license": "MIT",
+  "version": "0.4.10",
   "repository": {
     "type": "git",
-    "url": "https://github.com/watanabe-1/rpc4next"
+    "url": "git+https://github.com/watanabe-1/rpc4next.git",
+    "directory": "packages/rpc4next"
   },
   "homepage": "https://github.com/watanabe-1/rpc4next#readme",
   "bugs": {
     "url": "https://github.com/watanabe-1/rpc4next/issues"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "next.js",
     "rpc",
-    "typescript",
-    "cli"
+    "typescript"
   ],
   "type": "module",
   "module": "dist/index.js",
@@ -24,10 +27,17 @@
   "files": [
     "dist"
   ],
-  "bin": {
-    "rpc4next": "dist/rpc/cli/index.js"
-  },
   "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
     "./client": {
       "import": {
         "types": "./dist/rpc/client/index.d.ts",
@@ -57,44 +67,42 @@
         "types": "./dist/rpc/server/validators/zod/index.d.ts",
         "default": "./dist/rpc/server/validators/zod/index.js"
       }
+    },
+    "./lib/constants": {
+      "import": {
+        "types": "./dist/rpc/lib/constants.d.ts",
+        "default": "./dist/rpc/lib/constants.js"
+      },
+      "default": {
+        "types": "./dist/rpc/lib/constants.d.ts",
+        "default": "./dist/rpc/lib/constants.js"
+      }
+    },
+    "./lib/types": {
+      "import": {
+        "types": "./dist/rpc/lib/types.d.ts",
+        "default": "./dist/rpc/lib/types.js"
+      },
+      "default": {
+        "types": "./dist/rpc/lib/types.d.ts",
+        "default": "./dist/rpc/lib/types.js"
+      }
     }
   },
   "scripts": {
     "build": "bun run clean && bun build.ts && bun run build:types",
-    "build:types": "tsc -p tsconfig.build-types.json",
-    "clean": "bun -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build:types": "tsc -b --force tsconfig.build-types.json",
+    "clean": "bun -e \"const fs=require('fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('tsconfig.build-types.tsbuildinfo',{force:true}); fs.rmSync('tsconfig.tsbuildinfo',{force:true});\"",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage.enabled true",
     "test:ui": "vitest --ui --coverage.enabled true",
     "test:watch": "vitest --watch",
-    "lint": "eslint \"**/*.ts\"",
-    "lint:fix": "eslint \"**/*.ts\" --fix",
-    "typecheck": "tsc --noEmit"
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "typecheck": "tsc -b tsconfig.build.json --noEmit"
   },
   "dependencies": {
-    "chalk": "^5.4.1",
-    "chokidar": "^4.0.3",
-    "commander": "^13.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.15.3",
-    "@vitest/coverage-v8": "^3.1.2",
-    "@vitest/eslint-plugin": "^1.1.43",
-    "@vitest/ui": "^3.1.2",
-    "esbuild": "^0.25.3",
-    "eslint": "^9.25.1",
-    "eslint-config-prettier": "^10.1.2",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-unused-imports": "^4.1.4",
-    "mock-fs": "^5.5.0",
-    "msw": "^2.7.5",
-    "next": "15.3.1",
-    "prettier": "^3.5.3",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.31.1",
-    "vitest": "^3.1.2",
-    "zod": "^3.24.3"
+    "rpc4next-shared": "workspace:*"
   },
   "peerDependencies": {
     "next": "^14.0.0 || ^15.0.0"

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 watanabe-1
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,320 +0,0 @@
-# rpc4next
-
-Lightweight, type-safe RPC system for Next.js App Router projects.
-
-Inspired by Hono RPC and Pathpida, **rpc4next** automatically generates a type-safe client for your existing `route.ts` **and** `page.tsx` files, enabling seamless server-client communication with full type inference.
-
----
-
-## ✨ Features
-
-- ✅ ルート、パラメータ、クエリパラメータ、 リクエストボディ、レスポンスの型安全なクライアント生成
-- ✅ 既存の `app/**/route.ts` および `app/**/page.tsx` を活用するため、新たなハンドラファイルの作成は不要
-- ✅ 最小限のセットアップで、カスタムサーバー不要
-- ✅ 動的ルート（`[id]`、`[...slug]` など）に対応
-- ✅ CLI による自動クライアント用型定義生成
-
----
-
-## 🚀 Getting Started
-
-### 1. Install rpc4next
-
-```bash
-npm install rpc4next
-```
-
-### 2. Define API Routes in Next.js
-
-Next.js プロジェクト内の既存の `app/**/route.ts` と `app/**/page.tsx` ファイルをそのまま利用できます。
-さらに、クエリパラメータ（searchParams）の型安全性を有効にするには、対象のファイル内で `Query` 型を定義し、`export` してください。
-
-```ts
-// app/api/user/[id]/route.ts
-import { NextRequest, NextResponse } from "next/server";
-
-// searchParams用の型定義
-export type Query = {
-  q: string; // 必須
-  page?: number; // 任意
-};
-
-export async function GET(
-  req: NextRequest,
-  segmentData: { params: Promise<{ id: string }> }
-) {
-  const { id } = await segmentData.params;
-  const q = req.nextUrl.searchParams.get("q");
-  return NextResponse.json({ id, q });
-}
-```
-
-🚩 Query 型を export することで、searchParams の型も自動的にクライアントに反映されます。
-
-- **RPCとしてresponseの戻り値の推論が機能するのは、対象となる `route.ts` の HTTPメソッドハンドラ内で`NextResponse.json()` をしている関数のみになります**
-
----
-
-### 3. Generate Type Definitions with CLI
-
-CLI を利用して、Next.js のルート構造から型安全な RPC クライアントの定義を自動生成します。
-
-```bash
-npx rpc4next <baseDir> <outputPath>
-```
-
-- `<baseDir>`: Next.js の Appルータが配置されたベースディレクトリ
-- `<outputPath>`: 生成された型定義ファイルの出力先
-
-#### オプション
-
-- **ウォッチモード**  
-  ファイル変更を検知して自動的に再生成する場合は `--watch` or `-w` オプションを付けます。
-
-  ```bash
-  npx rpc4next <baseDir> <outputPath> --watch
-  ```
-
-- **パラメータ型ファイルの生成**  
-  各ルートに対して個別のパラメータ型定義ファイルを生成する場合は、`--params-file` or `-p` オプションにファイル名を指定します。
-
-  ```bash
-  npx rpc4next <baseDir> <outputPath> --generate-params-types <paramsFileName>
-  ```
-
----
-
-### 4. Create Your RPC Client
-
-生成された型定義ファイルを基に、RPC クライアントを作成します。
-
-```ts
-// lib/rpcClient.ts
-import { createClient } from "rpc4next/client";
-import type { PathStructure } from "あなたが生成した型定義ファイル";
-
-export const rpc = createClient<PathStructure>();
-```
-
----
-
-### 5. Use It in Your Components
-
-コンポーネント内で生成された RPC クライアントを使用します。
-
-```tsx
-// app/page.tsx
-import { rpc } from "@/lib/rpcClient";
-
-export default async function Page() {
-  const res = await rpc.api.user._id("123").$get({
-    query: { q: "hello", page: 1 },
-  });
-  const json = await res.json();
-  return <div>{json.q}</div>;
-}
-```
-
-- エディタの補完機能により、利用可能なエンドポイントが自動的に表示されます。
-- リクエストの構造（params, query）はサーバーコードから推論され、レスポンスも型安全に扱えます。
-
----
-
-## ✅ さらに型安全にしたい場合 `createRouteHandler` による Next.js の型安全強化
-
-### 📌 主なメリット
-
-1. **レスポンス型安全**
-
-   - ステータス、Content-Type、Body がすべて型で保証される
-   - クライアントは受け取るレスポンス型を完全に推論可能
-
-2. **クライアント側補完強化**
-
-   - `status`, `content-type`, `json()`, `text()` などが適切に補完される
-
-3. **サーバー側 params / query も型安全**
-   - `createRouteHandler()` + `zValidator()` を使えば、`params`, `query`, `headers`, `cookies`, `json` も型推論・バリデーション可能
-   - `createRouteHandler()` + `zValidator()` を使えば、`Query` 型もexportする必要なし
-
----
-
-### ✅ 基本的な使い方
-
-```ts
-const createRouteHandler = routeHandlerFactory((err, rc) =>
-  rc.text("error", { status: 400 })
-);
-
-const { POST } = createRouteHandler().post(async (rc) => rc.text("plain text"));
-```
-
-これだけで、POSTリクエストの返り値に、レスポンスの内容 (`json`, `text`など)、`status`, `content-type` が型付けされるようになります。
-
----
-
-### 👤 サーバー側でのより型安全なルート作成
-
-`createRouteHandler()` と `zValidator()` を使うことで、各リクエストパーツに対して **型安全なバリデーション** をかけられます。
-
-#### シンプルな例
-
-```ts
-import { createRouteHandler } from "@/path/to/createRouteHandler";
-import { zValidator } from "@/path/to/zValidator";
-import { z } from "zod";
-
-// Zodスキーマを定義
-const paramsSchema = z.object({
-  userId: z.string(),
-});
-
-// バリデーション付きルートハンドラを作成
-export const { GET } = createRouteHandler<{
-  params: z.infer<typeof paramsSchema>;
-}>().get(
-  zValidator("params", paramsSchema), // paramsを検証
-  async (rc) => {
-    const params = rc.req.valid("params"); // バリデーション済みparamsを取得
-    return rc.json({ message: `User ID is ${params.userId}` });
-  }
-);
-```
-
-## ✅ サポートされているバリデーションターゲット
-
-サーバー側では，次のリクエスト部分を型安全に検証できます：
-
-| ターゲット | 説明                                                |
-| :--------- | :-------------------------------------------------- |
-| `params`   | URLパラメータ ( `/user/:id` の `id`など)            |
-| `query`    | クエリパラメータ (`?q=xxx&page=1`など)              |
-| `headers`  | リクエストヘッダー                                  |
-| `cookies`  | クッキー                                            |
-| `json`     | リクエストボディ (Content-Type: `application/json`) |
-
----
-
-### 🔥 複数ターゲットを同時に検証する例
-
-```ts
-import { createRouteHandler } from "@/path/to/createRouteHandler";
-import { zValidator } from "@/path/to/zValidator";
-import { z } from "zod";
-
-const querySchema = z.object({
-  page: z.string().regex(/^\d+$/),
-});
-
-const jsonSchema = z.object({
-  name: z.string(),
-  age: z.number(),
-});
-
-export const { POST } = createRouteHandler<{
-  query: z.infer<typeof querySchema>;
-}>().post(
-  zValidator("query", querySchema),
-  zValidator("json", jsonSchema),
-  async (rc) => {
-    const query = rc.req.valid("query");
-    const body = rc.req.valid("json");
-    return rc.json({ query, body });
-  }
-);
-```
-
-- `query`と`json`を別々のスキーマで検証
-- **成功時は型安全に取得可能** (`rc.req.valid('query')`, `rc.req.valid('json')`)
-
----
-
-これにより，クライアント側とサーバー側が、全面的に**型でつながる**ので，ミスを何次も防げ，開発体験を大幅に向上できます。
-
----
-
-### ⚡ バリデーション失敗時のカスタムエラーハンドリング
-
-- デフォルトでは、バリデーション失敗時に自動で `400 Bad Request` を返します。
-- 必要に応じて、**カスタムフック**でエラー対応を制御できます。
-
-```ts
-zValidator("params", paramsSchema, (result, rc) => {
-  if (!result.success) {
-    return rc.json({ error: result.error.errors }, { status: 422 });
-  }
-});
-```
-
-> （フック内でレスポンスを返さない場合は、通常通り例外がスローされます）
-
----
-
-## 📡 クライアント側での使い方
-
-`rpc4next`で作成したクライアントは、`createRouteHandler` と `zValidator` で作成したルートハンドラの内容にしたがって　**params, query, headers, cookies, json** を型安全に送信できます。
-
-例：
-
-```ts
-import { createRpcClient } from "@/path/to/rpc-client";
-import type { PathStructure } from "@/path/to/generated-types";
-
-const client = createRpcClient<PathStructure>("http://localhost:3000");
-
-async function callUserApi() {
-  const res = await client.api.menu.test.$post({
-    body: { json: { age: 20, name: "foo" } },
-    url: { query: { page: "1" } },
-  });
-
-  if (res.ok) {
-    const json = await res.json();
-
-    // ✅ 正常時は次の型が推論されます
-    // const json: {
-    //   query: {
-    //     page: string;
-    //   };
-    //   body: {
-    //     name: string;
-    //     age: number;
-    //   };
-    // }
-  } else {
-    const error = await res.json();
-
-    // ⚠️ バリデーションエラー時は次の型が推論されます
-    // const error:
-    //   | SafeParseError<{
-    //       page: string;
-    //     }>
-    //   | SafeParseError<{
-    //       name: string;
-    //       age: number;
-    //     }>;
-  }
-}
-```
-
-- エディタの補完機能により、送信できるターゲットが明示されます
-- サーバー側の型定義に基づいて、**型のズレを防止**できます
-
----
-
-これらのように、リクエスト時にはさまざまなターゲット (`params`, `query`, `headers`, `cookies`, `json`) を送信できます。
-
-さらに、サーバー側では、これらを**個別に型付け、バリデーション**できます。
-
----
-
-## 🚧 Requirements
-
-- Next.js 14+ (App Router 使用)
-- Node.js 18+
-
----
-
-## 💼 License
-
-MIT

package/dist/rpc/cli/index.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import{Command as Wt}from"commander";import xt from"path";var I=["page.tsx","route.ts"],w=0,$=1,M=1,W=20,Y="\u2192";import U from"path";var tt=(t,r)=>{let e=S(U.relative(U.dirname(t),r)).replace(/\.tsx?$/,"");return e.startsWith("../")||(e="./"+e),e},S=t=>t.replace(/\\/g,"/"),C=t=>U.relative(process.cwd(),t);import dt from"fs";import wt from"path";var et=["Query"],R="  ",h=`
-`,_=";",H=";",j="Endpoint",X="QueryKey",G="ParamsKey",rt=[j,G,X],ot="rpc4next/client";import ht from"fs";import b from"path";import k from"path";var g=new Map,N=new Map,nt=(t,r)=>{let e=k.resolve(r);[...t.keys()].forEach(o=>{let n=k.resolve(o);(n===e||e.startsWith(n+k.sep))&&t.delete(o)})},st=t=>{nt(g,t)},it=t=>{nt(N,t)};import bt from"fs";import Dt from"crypto";var at=(t,r)=>{let e=Dt.createHash("md5").update(`${t}::${r}`).digest("hex").slice(0,16);return`${r}_${e}`};var L=(t,r)=>!t||!r?"":`Record<${t}, ${r}>`,O=t=>t.length===0||t.some(({name:r,type:e})=>!r||!e)?"":`{ ${t.map(({name:r,type:e})=>`"${r}": ${e}`).join(`${H} `)}${t.length>1?H:""} }`,D=(t,r,e)=>!t||!r?"":e?`import type { ${t} as ${e} } from "${r}"${_}`:`import type { ${t} } from "${r}"${_}`;var pt=(t,r,e,o)=>{let n=bt.readFileSync(r,"utf8"),i=e(n);if(!i)return;let s=tt(t,r),p=at(s,i);return{importName:p,importPath:s,importStatement:D(i,s,p),type:o(i,p)}},ct=(t,r)=>pt(t,r,e=>et.find(o=>new RegExp(`export (interface ${o} ?{|type ${o} ?=)`).test(e)),(e,o)=>L(X,o)),mt=(t,r,e)=>pt(t,r,o=>[e].find(n=>new RegExp(`export (async )?(function ${n} ?\\(|const ${n} ?=|\\{[^}]*\\b${n}\\b[^}]*\\} ?=|const \\{[^}]*\\b${n}\\b[^}]*\\} ?=|\\{[^}]*\\b${n}\\b[^}]*\\} from)`).test(o)),(o,n)=>O([{name:`$${o.toLowerCase()}`,type:`typeof ${n}`}]));var vt=["GET","HEAD","OPTIONS","POST","PUT","DELETE","PATCH"],lt="_____",ut="___",ft="_",K=vt.filter(t=>t!=="OPTIONS"),re=K.map(t=>`$${t.toLowerCase()}`);var Tt=new Set(I),Et=t=>{if(g.has(t))return g.get(t);let r=ht.readdirSync(t,{withFileTypes:!0});for(let e of r){let{name:o}=e,n=b.join(t,o);if(o==="node_modules"||o.startsWith("_")||o.startsWith("(.)")||o.startsWith("(..)")||o.startsWith("(...)"))return g.set(t,!1),!1;if(e.isFile()&&Tt.has(o))return g.set(t,!0),!0;if(e.isDirectory()&&Et(n))return g.set(t,!0),!0}return g.set(t,!1),!1},Ft=(t,{isDynamic:r,isCatchAll:e,isOptionalCatchAll:o})=>{let n=t;return r&&(n=n.replace(/^\[+|\]+$/g,"")),(e||o)&&(n=n.replace(/^\.{3}/,"")),{paramName:n,keyName:`${o?lt:e?ut:r?ft:""}${n}`}},Q=(t,r,e="",o=[])=>{if(N.has(r))return N.get(r);let n=e,i=e+R,s=[],p=[],a=[],m=[],c=[...o],x=ht.readdirSync(r,{withFileTypes:!0}).filter(y=>{if(y.isDirectory()){let P=b.join(r,y.name);return Et(P)}return Tt.has(y.name)}).sort();for(let y of x){let P=S(b.join(r,y.name));if(y.isDirectory()){let l=y.name,T=l.startsWith("(")&&l.endsWith(")"),u=l.startsWith("@"),f=l.startsWith("[[...")&&l.endsWith("]]"),E=l.startsWith("[...")&&l.endsWith("]"),d=l.startsWith("[")&&l.endsWith("]"),{paramName:At,keyName:It}=Ft(l,{isDynamic:d,isCatchAll:E,isOptionalCatchAll:f}),Rt=d||E||f?[...c,{paramName:At,routeType:{isDynamic:d,isCatchAll:E,isOptionalCatchAll:f,isGroup:T,isParallel:u}}]:c,z=T||u,{pathStructure:J,imports:Lt,paramsTypes:Ot}=Q(t,P,z?n:i,Rt);if(p.push(...Lt),m.push(...Ot),z){let Z=J.match(/^\s*\{([\s\S]*)\}\s*$/);Z&&s.push(`${i}${Z[1].trim()}`)}else s.push(`${i}"${It}": ${J}`)}else{let l=ct(t,P);if(l){let{importStatement:T,importPath:u,type:f}=l;p.push({statement:T,path:u}),a.push(f)}if(K.forEach(T=>{let u=mt(t,P,T);if(u){let{importStatement:f,importPath:E,type:d}=u;p.push({statement:f,path:E}),a.push(d)}}),a.push(j),c.length>0){let T=c.map(({paramName:f,routeType:E})=>{let d=E.isCatchAll?"string[]":E.isOptionalCatchAll?"string[] | undefined":"string";return{name:f,type:d}}),u=O(T);m.push({paramsType:u,dirPath:b.dirname(P)}),a.push(L(G,u))}}}let A=a.join(" & "),F=s.length>0?`{${h}${s.join(`,${h}`)}${h}${n}}`:"",q={pathStructure:A&&F?`${A} & ${F}`:A||F,imports:p,paramsTypes:m};return N.set(r,q),q};var gt=(t,r)=>{let{pathStructure:e,imports:o,paramsTypes:n}=Q(t,r),i=`export type PathStructure = ${e}${_}`,s=o.length?`${o.sort((c,x)=>c.path.localeCompare(x.path,void 0,{numeric:!0})).map(c=>c.statement).join(h)}`:"",p=rt.filter(c=>e.includes(c)),a=D(p.join(" ,"),ot),m=n.map(({paramsType:c,dirPath:x})=>({paramsType:`export type Params = ${c}${_}`,dirPath:x}));return{pathStructure:`${a}${h}${s}${h}${h}${i}`,paramsTypes:m}};import v from"chalk";var B=(t,r,e="\u2192",o=24)=>t.padEnd(o)+` ${e} ${r}`,V=(t=0)=>R.repeat(t),yt=()=>({info:(t,r={})=>{let{indentLevel:e=0,event:o}=r,n=o?`${v.cyan(`[${o}]`)} `:"";console.log(`${V(e)}${n}${t}`)},success:(t,r={})=>{let{indentLevel:e=0}=r;console.log(`${V(e)}${v.green("\u2713")} ${t}`)},error:(t,r={})=>{let{indentLevel:e=0}=r;console.error(`${V(e)}${v.red("\u2717")} ${v.red(t)}`)}});var Pt=({baseDir:t,outputPath:r,paramsFileName:e,logger:o})=>{o.info("Generating types...",{event:"generate"});let{pathStructure:n,paramsTypes:i}=gt(r,t);dt.writeFileSync(r,n),o.success(B("Path structure type",C(r),Y,W),{indentLevel:M}),e&&(i.forEach(({paramsType:s,dirPath:p})=>{let a=wt.join(p,e);dt.writeFileSync(a,s)}),o.success(B("Params types",e,Y,W),{indentLevel:M}))};import Mt from"chokidar";var St=(t,r)=>{let e=null,o=!1,n=null,i=async(...s)=>{o=!0;try{await t(...s)}finally{if(o=!1,n){let p=n;n=null,i(...p)}}};return(...s)=>{e&&clearTimeout(e),e=setTimeout(()=>{if(o){n=s;return}i(...s)},r)}};var _t=(t,r,e)=>{e.info(`${C(t)}`,{event:"watch"});let o=a=>I.some(m=>a.endsWith(m)),n=new Set,i=St(()=>{n.forEach(a=>{st(a),it(a)}),n.clear(),r()},300),s=Mt.watch(t,{ignoreInitial:!0,ignored:(a,m)=>!!m?.isFile()&&!o(a)});s.on("ready",()=>{i(),s.on("all",(a,m)=>{if(o(m)){let c=C(m);e.info(c,{event:a}),n.add(m),i()}})}),s.on("error",a=>{a instanceof Error?e.error(`Watcher error: ${a.message}`):e.error(`Unknown watcher error: ${String(a)}`)});let p=()=>{s.close().then(()=>{e.info("Watcher closed.",{event:"watch"})}).catch(a=>{e.error(`Failed to close watcher: ${a.message}`)})};process.on("SIGINT",p),process.on("SIGTERM",p)};var $t=(t,r,e,o)=>{try{return Pt({baseDir:t,outputPath:r,paramsFileName:e,logger:o}),w}catch(n){return n instanceof Error?o.error(`Failed to generate: ${n.message}`):o.error(`Unknown error occurred during generate: ${String(n)}`),$}},Ct=(t,r,e,o)=>{let n=S(xt.resolve(t)),i=S(xt.resolve(r)),s=typeof e.paramsFile=="string"?e.paramsFile:null;return e.paramsFile!==void 0&&!s?(o.error("Error: --params-file requires a filename."),$):e.watch?(_t(n,()=>{$t(n,i,s,o)},o),w):$t(n,i,s,o)};var Nt=(t,r=yt())=>{let e=new Wt;e.description("Generate RPC client type definitions based on the Next.js path structure.").argument("<baseDir>","Base directory containing Next.js paths for type generation").argument("<outputPath>","Output path for the generated type definitions").option("-w, --watch","Watch mode: regenerate on file changes").option("-p, --params-file [filename]","Generate params types file with specified filename").action(async(o,n,i)=>{try{let s=await Ct(o,n,i,r);i.watch||process.exit(s)}catch(s){r.error(`Unexpected error occurred:${s instanceof Error?s.message:String(s)}`),process.exit($)}}),e.parse(t)};Nt(process.argv);
-/*!
- * Inspired by pathpida (https://github.com/aspida/pathpida),
- * especially the design and UX of its CLI.
- */

package/dist/rpc/lib/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const HTTP_METHODS: readonly ["GET", "HEAD", "OPTIONS", "POST", "PUT", "DELETE", "PATCH"];
-export declare const OPTIONAL_CATCH_ALL_PREFIX = "_____";
-export declare const CATCH_ALL_PREFIX = "___";
-export declare const DYNAMIC_PREFIX = "_";
-export declare const HTTP_METHODS_EXCLUDE_OPTIONS: ("GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "PATCH")[];
-export declare const HTTP_METHOD_FUNC_KEYS: ("$get" | "$head" | "$post" | "$put" | "$delete" | "$patch")[];

package/dist/rpc/lib/constants.js

@@ -1 +0,0 @@
-const T=["GET","HEAD","OPTIONS","POST","PUT","DELETE","PATCH"],t="_____",E="___",e="_",o=T.filter(_=>_!=="OPTIONS"),P=o.map(_=>`$${_.toLowerCase()}`);export{E as CATCH_ALL_PREFIX,e as DYNAMIC_PREFIX,T as HTTP_METHODS,o as HTTP_METHODS_EXCLUDE_OPTIONS,P as HTTP_METHOD_FUNC_KEYS,t as OPTIONAL_CATCH_ALL_PREFIX};