rpc4next 0.1.0

package/dist/cli/type-utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImport = exports.createObjectType = exports.createRecodeType = void 0;
+const constants_1 = require("./constants");
+const createRecodeType = (key, value) => {
+    if (!key || !value)
+        return "";
+    return `Record<${key}, ${value}>`;
+};
+exports.createRecodeType = createRecodeType;
+const createObjectType = (fields) => {
+    if (fields.length === 0 || fields.some(({ name, type }) => !name || !type))
+        return "";
+    return `{ ${fields
+        .map(({ name, type }) => `"${name}": ${type}`)
+        .join(`${constants_1.TYPE_SEPARATOR} `)}${fields.length > 1 ? constants_1.TYPE_SEPARATOR : ""} }`;
+};
+exports.createObjectType = createObjectType;
+const createImport = (type, path, importAlias) => {
+    if (!type || !path)
+        return "";
+    return importAlias
+        ? `import type { ${type} as ${importAlias} } from "${path}"${constants_1.STATEMENT_TERMINATOR}`
+        : `import type { ${type} } from "${path}"${constants_1.STATEMENT_TERMINATOR}`;
+};
+exports.createImport = createImport;

package/dist/cli/types.d.ts

@@ -0,0 +1,2 @@
+import type { END_POINT_FILE_NAMES } from "./constants";
+export type EndPointFileNames = (typeof END_POINT_FILE_NAMES)[number];

package/dist/cli/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+import type { FuncParams, UrlOptions, ClientOptions } from "./types";
+export declare const httpMethod: (key: string, paths: string[], params: FuncParams, dynamicKeys: string[], defaultOptions: ClientOptions) => (url?: UrlOptions, options?: ClientOptions) => Promise<Response>;

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

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpMethod = void 0;
+const url_1 = require("./url");
+const utils_1 = require("./utils");
+const normalizeHeaders = (headers) => {
+    const result = {};
+    if (!headers)
+        return result;
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => {
+            result[key.toLowerCase()] = value;
+        });
+        return result;
+    }
+    if (Array.isArray(headers)) {
+        headers.forEach(([key, value]) => {
+            result[key.toLowerCase()] = value;
+        });
+        return result;
+    }
+    Object.entries(headers).forEach(([key, value]) => {
+        result[key.toLowerCase()] = value;
+    });
+    return result;
+};
+const httpMethod = (key, paths, params, dynamicKeys, defaultOptions) => {
+    return (url, options) => __awaiter(void 0, void 0, void 0, function* () {
+        const urlObj = (0, url_1.createUrl)([...paths], params, dynamicKeys)(url);
+        const method = key.replace(/^\$/, "").toUpperCase();
+        const customFetch = (options === null || options === void 0 ? void 0 : options.fetch) || defaultOptions.fetch || fetch;
+        const defaultInit = defaultOptions.init || {};
+        const innerInit = (options === null || options === void 0 ? void 0 : options.init) || {};
+        const defaultHeaders = normalizeHeaders(defaultInit.headers);
+        const innerHeaders = normalizeHeaders(innerInit.headers);
+        const mergedHeaders = Object.assign(Object.assign({}, defaultHeaders), innerHeaders);
+        const { headers: _defaultHeaders } = defaultInit, defaultInitWithoutHeaders = __rest(defaultInit, ["headers"]);
+        const { headers: _innerHeaders } = innerInit, innerInitWithoutHeaders = __rest(innerInit, ["headers"]);
+        const mergedInit = (0, utils_1.deepMerge)(defaultInitWithoutHeaders, innerInitWithoutHeaders);
+        mergedInit.method = method;
+        if (Object.keys(mergedHeaders).length > 0) {
+            mergedInit.headers = mergedHeaders;
+        }
+        const response = yield customFetch(urlObj.path, mergedInit);
+        return response;
+    });
+};
+exports.httpMethod = httpMethod;

package/dist/helper/client/index.d.ts

@@ -0,0 +1,2 @@
+export { createRpcClient, createRpcHelper } from "./rpc";
+export type { Endpoint, ParamsKey, QueryKey, OptionalQueryKey } from "./types";

package/dist/helper/client/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcHelper = exports.createRpcClient = void 0;
+var rpc_1 = require("./rpc");
+Object.defineProperty(exports, "createRpcClient", { enumerable: true, get: function () { return rpc_1.createRpcClient; } });
+Object.defineProperty(exports, "createRpcHelper", { enumerable: true, get: function () { return rpc_1.createRpcHelper; } });

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

@@ -0,0 +1 @@
+export declare const matchPath: (paths: string[], dynamicKeys: string[]) => (path: string) => {} | null;

package/dist/helper/client/match.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchPath = void 0;
+const url_1 = require("./url");
+const utils_1 = require("./utils");
+const matchPath = (paths, dynamicKeys) => {
+    return (path) => {
+        const basePath = `/${paths.slice(1).join("/")}`;
+        const regexPattern = (0, url_1.replaceDynamicSegments)(basePath, {
+            optionalCatchAll: "(?:/(.*))?",
+            catchAll: "/([^/]+(?:/[^/]+)*)",
+            dynamic: "/([^/]+)",
+        });
+        // Append /? to match with or without a trailing slash.
+        const match = new RegExp(`^${regexPattern}/?$`).exec(path);
+        if (!match)
+            return null;
+        return dynamicKeys.reduce((acc, key, index) => {
+            const paramKey = key.replace(/^_+/, "");
+            const matchValue = match[index + 1];
+            const paramValue = (0, utils_1.isCatchAllOrOptional)(key)
+                ? matchValue === undefined || matchValue === ""
+                    ? undefined
+                    : matchValue
+                        .split("/")
+                        .filter((segment) => segment.length > 0)
+                        .map((segment) => decodeURIComponent(segment))
+                : decodeURIComponent(matchValue);
+            return Object.assign(Object.assign({}, acc), { [paramKey]: paramValue });
+        }, {});
+    };
+};
+exports.matchPath = matchPath;

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

@@ -0,0 +1,55 @@
+import type { FuncParams, DynamicPathProxyAsFunction, ClientOptions, DynamicPathProxyAsProperty } from "./types";
+export declare const createRpcProxy: <T extends object>(options: ClientOptions, paths?: string[], params?: FuncParams, dynamicKeys?: string[]) => T;
+/**
+ * Creates an RPC client proxy for making HTTP requests with a strongly typed API.
+ *
+ * @template T - The type defining the RPC endpoint structure.
+ * @param baseUrl - The base URL for the RPC client. This URL will be used as the root for all generated endpoint URLs.
+ * @param options - (Optional) Client options to customize the behavior of the RPC client. These options may include a custom fetch function and default request initialization options.
+ * @returns An object that enables you to dynamically build endpoint URLs and execute HTTP requests (such as GET, POST, DELETE, etc.) with full type support.
+ *
+ * @example
+ * ```ts
+ * import { createRpcClient } from "./rpc";
+ * import type { PathStructure } from "./types";
+ *
+ * // Create an RPC client with a base URL
+ * const client = createRpcClient<PathStructure>("http://localhost:3000");
+ *
+ * // Generate a URL for a dynamic endpoint
+ * const urlResult = client.fuga._foo("test").$url();
+ * console.log(urlResult.path);         // "http://localhost:3000/fuga/test"
+ * console.log(urlResult.relativePath);   // "/fuga/test"
+ * console.log(urlResult.pathname);       // "/fuga/[foo]"
+ * console.log(urlResult.params);         // { foo: "test" }
+ *
+ * // Execute a GET request on an endpoint
+ * const response = await client.api.hoge._foo("test").$get();
+ * console.log(await response.json());    // Expected response: { method: "get" }
+ * ```
+ *
+ * The above example demonstrates how to generate URLs with dynamic segments and how to execute HTTP requests.
+ */
+export declare const createRpcClient: <T extends object>(baseUrl: string, options?: ClientOptions) => DynamicPathProxyAsFunction<T>;
+/**
+ * Creates an RPC helper proxy for dynamic path matching based on a given endpoint structure.
+ *
+ * @template T - The type defining the RPC endpoint structure.
+ *
+ * @returns  An object that provides dynamic RPC helper methods for the defined endpoints.
+ *
+ * @example
+ * ```ts
+ * // Create the RPC helper
+ * const rpcHelper = createRpcHelper<PathStructure>();
+ *
+ * // Use the $match method to extract dynamic parameters from a URL path
+ * const match = rpcHelper.fuga._foo.$match("/fuga/test");
+ * // Expected output: { foo: "test" }
+ *
+ * // If the path does not match, it returns null
+ * const noMatch = rpcHelper.fuga._foo.$match("/hoge/test");
+ * // Expected output: null
+ * ```
+ */
+export declare const createRpcHelper: <T extends object>() => DynamicPathProxyAsProperty<T>;

package/dist/helper/client/rpc.js

@@ -0,0 +1,100 @@
+"use strict";
+// Inspired by Hono (https://github.com/honojs/hono)
+// Some parts of this code are based on or adapted from the Hono project
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcHelper = exports.createRpcClient = exports.createRpcProxy = void 0;
+const http_method_1 = require("./http-method");
+const match_1 = require("./match");
+const url_1 = require("./url");
+const utils_1 = require("./utils");
+const createRpcProxy = (options, paths = [], params = {}, dynamicKeys = []) => {
+    const proxy = new Proxy((value) => {
+        var _a, _b;
+        if (value === undefined) {
+            return (0, exports.createRpcProxy)(options, [...paths], params, dynamicKeys);
+        }
+        const newKey = (_a = paths.at(-1)) !== null && _a !== void 0 ? _a : "";
+        if ((0, utils_1.isDynamic)(newKey)) {
+            // Treat as a dynamic parameter
+            return (0, exports.createRpcProxy)(options, [...paths], Object.assign(Object.assign({}, params), { [(_b = dynamicKeys.at(-1)) !== null && _b !== void 0 ? _b : ""]: value }), dynamicKeys);
+        }
+        return (0, exports.createRpcProxy)(options, [...paths], params, dynamicKeys);
+    }, {
+        get: (_, key) => {
+            if (key === "$url") {
+                return (0, url_1.createUrl)([...paths], params, dynamicKeys);
+            }
+            if (key === "$match") {
+                return (0, match_1.matchPath)([...paths], dynamicKeys);
+            }
+            if ((0, utils_1.isHttpMethod)(key)) {
+                return (0, http_method_1.httpMethod)(key, [...paths], params, dynamicKeys, Object.assign({}, options));
+            }
+            if ((0, utils_1.isDynamic)(key)) {
+                // Treat as a dynamic parameter
+                return (0, exports.createRpcProxy)(options, [...paths, key], params, [
+                    ...dynamicKeys,
+                    key,
+                ]);
+            }
+            return (0, exports.createRpcProxy)(options, [...paths, key], params, dynamicKeys);
+        },
+    });
+    return proxy;
+};
+exports.createRpcProxy = createRpcProxy;
+/**
+ * Creates an RPC client proxy for making HTTP requests with a strongly typed API.
+ *
+ * @template T - The type defining the RPC endpoint structure.
+ * @param baseUrl - The base URL for the RPC client. This URL will be used as the root for all generated endpoint URLs.
+ * @param options - (Optional) Client options to customize the behavior of the RPC client. These options may include a custom fetch function and default request initialization options.
+ * @returns An object that enables you to dynamically build endpoint URLs and execute HTTP requests (such as GET, POST, DELETE, etc.) with full type support.
+ *
+ * @example
+ * ```ts
+ * import { createRpcClient } from "./rpc";
+ * import type { PathStructure } from "./types";
+ *
+ * // Create an RPC client with a base URL
+ * const client = createRpcClient<PathStructure>("http://localhost:3000");
+ *
+ * // Generate a URL for a dynamic endpoint
+ * const urlResult = client.fuga._foo("test").$url();
+ * console.log(urlResult.path);         // "http://localhost:3000/fuga/test"
+ * console.log(urlResult.relativePath);   // "/fuga/test"
+ * console.log(urlResult.pathname);       // "/fuga/[foo]"
+ * console.log(urlResult.params);         // { foo: "test" }
+ *
+ * // Execute a GET request on an endpoint
+ * const response = await client.api.hoge._foo("test").$get();
+ * console.log(await response.json());    // Expected response: { method: "get" }
+ * ```
+ *
+ * The above example demonstrates how to generate URLs with dynamic segments and how to execute HTTP requests.
+ */
+const createRpcClient = (baseUrl, options = {}) => (0, exports.createRpcProxy)(options, [baseUrl]);
+exports.createRpcClient = createRpcClient;
+/**
+ * Creates an RPC helper proxy for dynamic path matching based on a given endpoint structure.
+ *
+ * @template T - The type defining the RPC endpoint structure.
+ *
+ * @returns  An object that provides dynamic RPC helper methods for the defined endpoints.
+ *
+ * @example
+ * ```ts
+ * // Create the RPC helper
+ * const rpcHelper = createRpcHelper<PathStructure>();
+ *
+ * // Use the $match method to extract dynamic parameters from a URL path
+ * const match = rpcHelper.fuga._foo.$match("/fuga/test");
+ * // Expected output: { foo: "test" }
+ *
+ * // If the path does not match, it returns null
+ * const noMatch = rpcHelper.fuga._foo.$match("/hoge/test");
+ * // Expected output: null
+ * ```
+ */
+const createRpcHelper = () => (0, exports.createRpcProxy)({}, ["/"]);
+exports.createRpcHelper = createRpcHelper;

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

@@ -0,0 +1,119 @@
+import type { OPTIONAL_CATCH_ALL_PREFIX, CATCH_ALL_PREFIX, DYNAMIC_PREFIX, HTTP_METHOD_FUNC_KEYS } from "../../lib/constants";
+import type { TypedNextResponse, HttpStatusCode, ContentType } from "../server/types";
+import type { NextResponse } from "next/server";
+/**
+ * Represents HTTP request headers with optional fields.
+ * This type includes general request headers, CORS/security-related headers, and client-specific headers.
+ */
+type HttpRequestHeaders = Partial<{
+    Accept: string;
+    "Accept-Charset": string;
+    "Accept-Encoding": string;
+    "Accept-Language": string;
+    Authorization: string;
+    "Cache-Control": string;
+    Connection: string;
+    "Content-Length": string;
+    "Content-Type": string;
+    Cookie: string;
+    Date: string;
+    Expect: string;
+    Forwarded: string;
+    From: string;
+    Host: string;
+    "If-Match": string;
+    "If-Modified-Since": string;
+    "If-None-Match": string;
+    "If-Range": string;
+    "If-Unmodified-Since": string;
+    "Max-Forwards": string;
+    Origin: string;
+    Pragma: string;
+    Range: string;
+    Referer: string;
+    TE: string;
+    Trailer: string;
+    "Transfer-Encoding": string;
+    Upgrade: string;
+    "User-Agent": string;
+    Via: string;
+    Warning: string;
+    "Access-Control-Request-Method": string;
+    "Access-Control-Request-Headers": string;
+    DNT: string;
+    "Sec-Fetch-Dest": string;
+    "Sec-Fetch-Mode": string;
+    "Sec-Fetch-Site": string;
+    "Sec-Fetch-User": string;
+    "Sec-CH-UA": string;
+    "Sec-CH-UA-Platform": string;
+    "Sec-CH-UA-Mobile": string;
+}>;
+/**
+ * Extension of the standard `RequestInit` interface with strongly typed headers.
+ */
+export interface TypedRequestInit extends RequestInit {
+    headers?: HttpRequestHeaders | HeadersInit;
+}
+export type ClientOptions = {
+    fetch?: typeof fetch;
+    init?: TypedRequestInit;
+};
+declare const __proxy: unique symbol;
+export type Endpoint = {
+    [__proxy]?: true;
+};
+export type ParamsKey = "__params";
+type IsParams = Record<ParamsKey, unknown>;
+export type QueryKey = "__query";
+type IsQuery = Record<QueryKey, unknown>;
+export type OptionalQueryKey = "__op_query";
+type IsOptionalQuery = Record<OptionalQueryKey, unknown>;
+export type HttpMethodFuncKey = (typeof HTTP_METHOD_FUNC_KEYS)[number];
+type IsHttpMethod = {
+    [K in HttpMethodFuncKey]?: unknown;
+};
+type IsOptionalCatchAll = `${typeof OPTIONAL_CATCH_ALL_PREFIX}${string}`;
+type IsCatchAll = `${typeof CATCH_ALL_PREFIX}${string}`;
+type IsDynamic = `${typeof DYNAMIC_PREFIX}${string}`;
+export type FuncParams<T = Record<string, string | number | string[] | undefined>> = T;
+type QueryParams<T = Record<string, string | number>> = T;
+type Params<T = unknown> = T extends IsParams ? T[ParamsKey] : Record<string, string>;
+export type UrlOptions<T = unknown> = T extends IsQuery ? {
+    query: T[QueryKey];
+    hash?: string;
+} : T extends IsOptionalQuery ? {
+    query?: T[OptionalQueryKey];
+    hash?: string;
+} : {
+    query?: QueryParams;
+    hash?: string;
+};
+export type UrlResult<T = unknown> = {
+    pathname: string;
+    path: string;
+    relativePath: string;
+    params: Params<T>;
+};
+type UrlArg<T> = T extends IsQuery ? [url: UrlOptions<T>] : [url?: UrlOptions<T>];
+type HttpMethodsArg<T> = [...UrlArg<T>, option?: ClientOptions];
+type InferHttpMethods<T extends IsHttpMethod> = {
+    [K in keyof T as K extends HttpMethodFuncKey ? K : never]: (...args: HttpMethodsArg<T>) => Promise<InferTypedNextResponseType<T[K]>>;
+};
+type InferNextResponseType<T> = T extends (...args: any[]) => Promise<NextResponse<infer U>> ? U : never;
+type InferTypedNextResponseType<T> = T extends (...args: any[]) => Promise<TypedNextResponse> ? Awaited<ReturnType<T>> : TypedNextResponse<InferNextResponseType<T>, HttpStatusCode, ContentType>;
+type PathProxyAsProperty<T> = {
+    $match: (path: string) => Params<T> | null;
+};
+type PathProxyAsFunction<T> = {
+    $url: (...args: UrlArg<T>) => UrlResult<T>;
+} & (T extends IsHttpMethod ? InferHttpMethods<T> : unknown);
+type ParamFunction<T, TParamArgs extends unknown[]> = (...args: [...TParamArgs]) => DynamicPathProxyAsFunction<T>;
+type NonEmptyArray<T> = [T, ...T[]];
+export type DynamicPathProxyAsFunction<T> = Omit<(T extends Endpoint ? PathProxyAsFunction<T> : unknown) & {
+    [K in keyof T]: K extends IsOptionalCatchAll ? ParamFunction<T[K], [value?: string[]]> : K extends IsCatchAll ? ParamFunction<T[K], [value: NonEmptyArray<string>]> : K extends IsDynamic ? ParamFunction<T[K], [value: string | number]> : DynamicPathProxyAsFunction<T[K]>;
+}, QueryKey | OptionalQueryKey | ParamsKey>;
+export type DynamicPathProxyAsProperty<T> = Omit<(T extends Endpoint ? PathProxyAsProperty<T> : unknown) & {
+    [K in keyof T]: K extends unknown ? DynamicPathProxyAsProperty<T[K]> : DynamicPathProxyAsProperty<T[K]>;
+}, QueryKey | OptionalQueryKey | ParamsKey>;
+export {};

package/dist/helper/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import type { UrlOptions, UrlResult, FuncParams } from "./types";
+export declare const buildUrlSuffix: (url?: UrlOptions) => string;
+export declare const replaceDynamicSegments: (basePath: string, replacements: {
+    optionalCatchAll: string;
+    catchAll: string;
+    dynamic: string;
+}) => string;
+export declare const createUrl: (paths: string[], params: FuncParams, dynamicKeys: string[]) => (url?: UrlOptions) => UrlResult;

package/dist/helper/client/url.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUrl = exports.replaceDynamicSegments = exports.buildUrlSuffix = void 0;
+const buildUrlSuffix = (url) => {
+    if (!url)
+        return "";
+    const query = url.query
+        ? "?" + new URLSearchParams(url.query).toString()
+        : "";
+    const hash = url.hash ? `#${url.hash}` : "";
+    return query + hash;
+};
+exports.buildUrlSuffix = buildUrlSuffix;
+const replaceDynamicSegments = (basePath, replacements) => basePath
+    // optionalCatchAll
+    .replace(/\/_{5}(\w+)/g, replacements.optionalCatchAll)
+    // catchAll
+    .replace(/\/_{3}(\w+)/g, replacements.catchAll)
+    // dynamic
+    .replace(/\/_(\w+)/g, replacements.dynamic);
+exports.replaceDynamicSegments = replaceDynamicSegments;
+const createUrl = (paths, params, dynamicKeys) => {
+    const baseUrl = paths.shift();
+    const basePath = `/${paths.join("/")}`;
+    const dynamicPath = dynamicKeys.reduce((acc, key) => {
+        const param = params[key];
+        if (Array.isArray(param)) {
+            return acc.replace(`/${key}`, `/${param.map(encodeURIComponent).join("/")}`);
+        }
+        if (param === undefined) {
+            return acc.replace(`/${key}`, "");
+        }
+        return acc.replace(`/${key}`, `/${encodeURIComponent(param)}`);
+    }, basePath);
+    return (url) => {
+        const relativePath = `${dynamicPath}${(0, exports.buildUrlSuffix)(url)}`;
+        const pathname = (0, exports.replaceDynamicSegments)(basePath, {
+            optionalCatchAll: "/[[...$1]]",
+            catchAll: "/[...$1]",
+            dynamic: "/[$1]",
+        });
+        const cleanedParams = {};
+        for (const key in params) {
+            const cleanedKey = key.replace(/^_+/, "");
+            cleanedParams[cleanedKey] = params[key];
+        }
+        return {
+            pathname,
+            params: cleanedParams,
+            path: baseUrl
+                ? `${baseUrl.replace(/\/$/, "")}${relativePath}`
+                : relativePath,
+            relativePath,
+        };
+    };
+};
+exports.createUrl = createUrl;

package/dist/helper/client/utils.d.ts

@@ -0,0 +1,5 @@
+import type { HttpMethodFuncKey } from "./types";
+export declare const isDynamic: (key: string) => boolean;
+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/helper/client/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = exports.isHttpMethod = exports.isCatchAllOrOptional = exports.isDynamic = void 0;
+const constants_1 = require("../../lib/constants");
+const isDynamic = (key) => key.startsWith(constants_1.DYNAMIC_PREFIX);
+exports.isDynamic = isDynamic;
+const isCatchAllOrOptional = (key) => key.startsWith(constants_1.CATCH_ALL_PREFIX) || key.startsWith(constants_1.OPTIONAL_CATCH_ALL_PREFIX);
+exports.isCatchAllOrOptional = isCatchAllOrOptional;
+const httpMethods = new Set(constants_1.HTTP_METHOD_FUNC_KEYS);
+const isHttpMethod = (value) => httpMethods.has(value);
+exports.isHttpMethod = isHttpMethod;
+const isPlainObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const deepMerge = (target, source) => {
+    const result = Object.assign({}, target);
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const targetValue = target[key];
+            const sourceValue = source[key];
+            if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+                result[key] = (0, exports.deepMerge)(targetValue, sourceValue);
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+};
+exports.deepMerge = deepMerge;

package/dist/helper/server/create-handler.d.ts

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

package/dist/helper/server/create-handler.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHandler = void 0;
+// I want to use currying so that the return value can be inferred.
+const createHandler = () => {
+    return (handler) => {
+        return handler;
+    };
+};
+exports.createHandler = createHandler;

package/dist/helper/server/create-route-context.d.ts

@@ -0,0 +1,5 @@
+import type { RouteContext, Query, ValidationSchema, Params } from "./types";
+import type { NextRequest } from "next/server";
+export declare const createRouteContext: <TParams extends Params, TQuery extends Query, TValidationSchema extends ValidationSchema>(req: NextRequest, segmentData: {
+    params: Promise<TParams>;
+}) => RouteContext<TParams, TQuery, TValidationSchema>;

package/dist/helper/server/create-route-context.js

@@ -0,0 +1,27 @@
+"use strict";
+// Inspired by Hono (https://github.com/honojs/hono)
+// Some parts of this code are based on or adapted from the Hono project
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRouteContext = void 0;
+const server_1 = require("next/server");
+const search_params_to_object_1 = require("./search-params-to-object");
+const createRouteContext = (req, segmentData) => {
+    const validationResults = {};
+    return {
+        req: Object.assign(req, {
+            query: () => (0, search_params_to_object_1.searchParamsToObject)(req.nextUrl.searchParams),
+            params: () => segmentData.params,
+            valid: (target) => {
+                return validationResults[target];
+            },
+            addValidatedData: (target, value) => {
+                validationResults[target] = value;
+            },
+        }),
+        body: (data, init) => new server_1.NextResponse(data, init),
+        json: (data, init) => server_1.NextResponse.json(data, init),
+        text: (data, init) => new server_1.NextResponse(data, Object.assign(Object.assign({}, init), { headers: Object.assign({ "Content-Type": "text/plain" }, init === null || init === void 0 ? void 0 : init.headers) })),
+        redirect: (url, init) => server_1.NextResponse.redirect(url, init),
+    };
+};
+exports.createRouteContext = createRouteContext;

package/dist/helper/server/index.d.ts

@@ -0,0 +1,2 @@
+export { routeHandlerFactory } from "./route-handler-factory";
+export type { ContentType, HttpStatusCode, TypedNextResponse } from "./types";

package/dist/helper/server/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeHandlerFactory = void 0;
+var route_handler_factory_1 = require("./route-handler-factory");
+Object.defineProperty(exports, "routeHandlerFactory", { enumerable: true, get: function () { return route_handler_factory_1.routeHandlerFactory; } });