rpc4next 0.1.4 → 0.1.6

package/README.md

@@ -9,7 +9,7 @@ Inspired by Hono RPC and Pathpida, **rpc4next** automatically generates a type-s
 ## ✨ Features
 
 - ✅ 既存の `app/**/route.ts` および `app/**/page.tsx` を活用するため、新たなハンドラファイルの作成は不要
-- ✅ ルート、パラメータ、リクエストボディ、レスポンスの型安全なクライアント生成
+- ✅ ルート、パラメータ、クエリパラメータ、 リクエストボディ、レスポンスの型安全なクライアント生成
 - ✅ 最小限のセットアップで、カスタムサーバー不要
 - ✅ 動的ルート（`[id]`、`[...slug]` など）に対応
 - ✅ CLI による自動クライアント用型定義生成
@@ -30,20 +30,30 @@ npm install rpc4next
 ### 2. Define API Routes in Next.js
 
 Next.js プロジェクト内の既存の `app/**/route.ts` と `app/**/page.tsx` ファイルをそのまま利用できます。
+さらに、クエリパラメータ（searchParams）の型安全性を有効にするには、対象のファイル内で `Query` または `OptionalQuery` 型を定義し、`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;
-  return NextResponse.json({ name: `User ${id}` });
+  const q = req.nextUrl.searchParams.get("q");
+  return NextResponse.json({ id, q });
 }
 ```
 
+🚩 Query or OptionalQuery 型を export することで、searchParams の型も自動的にクライアントに反映されます。
+
 - **RPCとしてresponseの戻り値の推論が機能するのは、対象となる `route.ts` の HTTPメソッドハンドラ内で`NextResponse.json()` をしている物のみになります**
 
 ---
@@ -102,14 +112,16 @@ export const rpc = createClient<PathStructure>();
 import { rpc } from "@/lib/rpcClient";
 
 export default async function Page() {
-  const res = await rpc.api.user._id("123").$get();
+  const res = await rpc.api.user._id("123").$get({
+    query: { q: "hello", page: 1 },
+  });
   const json = await res.json();
-  return <div>{json.name}</div>;
+  return <div>{json.q}</div>;
 }
 ```
 
 - エディタの補完機能により、利用可能なエンドポイントが自動的に表示されます。
-- リクエストの構造（params, searchParams）はサーバーコードから推論され、レスポンスも型安全に扱えます。
+- リクエストの構造（params, query）はサーバーコードから推論され、レスポンスも型安全に扱えます。
 
 ---
 
@@ -126,7 +138,7 @@ export default async function Page() {
 
 2. **クライアント側補完強化**
 
-   - `status`, `content-type`, `json()`, `text()` などがステータスに応じて適切に補完される
+   - `status`, `content-type`, `json()`, `text()` などが適切に補完される
 
 3. **サーバー側 params / query も型安全**
    - `routeHandlerFactory()` を使えば、`params`, `query` も型推論可能

package/dist/cli/cli-handler.js

@@ -15,12 +15,6 @@ const handleCli = (baseDir, outputPath, options, logger) => {
         logger.error("Error: --params-file requires a filename.");
         return 1;
     }
-    (0, generator_1.generate)({
-        baseDir: resolvedBaseDir,
-        outputPath: resolvedOutputPath,
-        paramsFileName: options.paramsFile || null,
-        logger,
-    });
     if (options.watch) {
         (0, watcher_1.setupWatcher)(resolvedBaseDir, () => {
             (0, generator_1.generate)({
@@ -31,6 +25,14 @@ const handleCli = (baseDir, outputPath, options, logger) => {
             });
         }, logger);
     }
+    else {
+        (0, generator_1.generate)({
+            baseDir: resolvedBaseDir,
+            outputPath: resolvedOutputPath,
+            paramsFileName: options.paramsFile || null,
+            logger,
+        });
+    }
     return 0;
 };
 exports.handleCli = handleCli;

package/dist/cli/core/alias.d.ts

@@ -0,0 +1 @@
+export declare const createImportAlias: (path: string, name: string) => string;

package/dist/cli/core/alias.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImportAlias = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const createImportAlias = (path, name) => {
+    const hash = crypto_1.default
+        .createHash("md5")
+        .update(`${path}::${name}`)
+        .digest("hex")
+        .slice(0, 16);
+    return `${name}_${hash}`;
+};
+exports.createImportAlias = createImportAlias;

package/dist/cli/core/cache.d.ts

@@ -0,0 +1,14 @@
+export declare const visitedDirsCache: Map<string, boolean>;
+export declare const scanAppDirCache: Map<string, {
+    pathStructure: string;
+    imports: {
+        statement: string;
+        path: string;
+    }[];
+    paramsTypes: {
+        paramsType: string;
+        path: string;
+    }[];
+}>;
+export declare const clearVisitedDirsCacheAbove: (targetPath: string) => void;
+export declare const clearScanAppDirCacheAbove: (targetPath: string) => void;

package/dist/cli/{cache.js → core/cache.js}

@@ -3,22 +3,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearVisitedDirsCacheAbove = exports.clearCntCache = exports.cntCache = exports.visitedDirsCache = void 0;
+exports.clearScanAppDirCacheAbove = exports.clearVisitedDirsCacheAbove = exports.scanAppDirCache = exports.visitedDirsCache = void 0;
 const path_1 = __importDefault(require("path"));
+// Caches
 exports.visitedDirsCache = new Map();
-exports.cntCache = {};
-const clearCntCache = () => {
-    Object.keys(exports.cntCache).forEach((key) => delete exports.cntCache[key]);
-};
-exports.clearCntCache = clearCntCache;
-const clearVisitedDirsCacheAbove = (targetPath) => {
+exports.scanAppDirCache = new Map();
+// Generic function to clear cache entries above a target path
+const clearCacheAbove = (cache, targetPath) => {
     const basePath = path_1.default.resolve(targetPath);
-    for (const key of exports.visitedDirsCache.keys()) {
+    [...cache.keys()].forEach((key) => {
         const normalizedKey = path_1.default.resolve(key);
         if (normalizedKey === basePath ||
             basePath.startsWith(normalizedKey + path_1.default.sep)) {
-            exports.visitedDirsCache.delete(key);
+            cache.delete(key);
         }
-    }
+    });
+};
+// Specific clear functions using the generic one
+const clearVisitedDirsCacheAbove = (targetPath) => {
+    clearCacheAbove(exports.visitedDirsCache, targetPath);
 };
 exports.clearVisitedDirsCacheAbove = clearVisitedDirsCacheAbove;
+const clearScanAppDirCacheAbove = (targetPath) => {
+    clearCacheAbove(exports.scanAppDirCache, targetPath);
+};
+exports.clearScanAppDirCacheAbove = clearScanAppDirCacheAbove;

package/dist/cli/{route-scanner.d.ts → core/route-scanner.d.ts}

@@ -1,3 +1,7 @@
+/*!
+ * Inspired by pathpida (https://github.com/aspida/pathpida),
+ * especially the design and UX of its CLI.
+ */
 export declare const hasTargetFiles: (dirPath: string) => boolean;
 export declare const scanAppDir: (output: string, input: string, indent?: string, parentParams?: {
     paramName: string;

package/dist/cli/{route-scanner.js → core/route-scanner.js}

@@ -1,6 +1,8 @@
 "use strict";
-// Inspired by pathpida (https://github.com/aspida/pathpida)
-// Some parts of this code are based on or adapted from the pathpida project
+/*!
+ * Inspired by pathpida (https://github.com/aspida/pathpida),
+ * especially the design and UX of its CLI.
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -12,7 +14,7 @@ const cache_1 = require("./cache");
 const constants_1 = require("./constants");
 const scan_utils_1 = require("./scan-utils");
 const type_utils_1 = require("./type-utils");
-const constants_2 = require("../lib/constants");
+const constants_2 = require("../../lib/constants");
 const endPointFileNames = new Set(constants_1.END_POINT_FILE_NAMES);
 const hasTargetFiles = (dirPath) => {
     // Return cached result if available
@@ -48,6 +50,9 @@ const hasTargetFiles = (dirPath) => {
 };
 exports.hasTargetFiles = hasTargetFiles;
 const scanAppDir = (output, input, indent = "", parentParams = []) => {
+    if (cache_1.scanAppDirCache.has(input)) {
+        return cache_1.scanAppDirCache.get(input);
+    }
     indent += constants_1.INDENT;
     const pathStructures = [];
     const imports = [];
@@ -95,6 +100,7 @@ const scanAppDir = (output, input, indent = "", parentParams = []) => {
                             : "";
                 return { paramName: param, keyName: `${prefix}${param}` };
             })();
+            let nextParams = params;
             if (isDynamic || isCatchAll || isOptionalCatchAll) {
                 const routeType = {
                     isGroup,
@@ -103,10 +109,10 @@ const scanAppDir = (output, input, indent = "", parentParams = []) => {
                     isCatchAll,
                     isDynamic,
                 };
-                params.push({ paramName, routeType });
+                nextParams = [...params, { paramName, routeType }];
             }
             const isSkipDir = isGroup || isParallel;
-            const { pathStructure: childPathStructure, imports: childImports, paramsTypes: childParamsTypes, } = (0, exports.scanAppDir)(output, fullPath, isSkipDir ? indent.replace(constants_1.INDENT, "") : indent, [...params]);
+            const { pathStructure: childPathStructure, imports: childImports, paramsTypes: childParamsTypes, } = (0, exports.scanAppDir)(output, fullPath, isSkipDir ? indent.replace(constants_1.INDENT, "") : indent, nextParams);
             imports.push(...childImports);
             paramsTypes.push(...childParamsTypes);
             if (isSkipDir) {
@@ -158,10 +164,12 @@ const scanAppDir = (output, input, indent = "", parentParams = []) => {
     const pathStructure = pathStructures.length > 0
         ? `${typeString}${typeString ? " & " : ""}{${constants_1.NEWLINE}${pathStructures.join(`,${constants_1.NEWLINE}`)}${constants_1.NEWLINE}${indent.replace(constants_1.INDENT, "")}}`
         : typeString;
-    return {
+    const result = {
         pathStructure,
         imports,
         paramsTypes,
     };
+    cache_1.scanAppDirCache.set(input, result);
+    return result;
 };
 exports.scanAppDir = scanAppDir;

package/dist/cli/{scan-utils.d.ts → core/scan-utils.d.ts}

@@ -1,5 +1,4 @@
-import { HttpMethod } from "../lib/types";
-export declare const createImportAlias: (type: string, key: string) => string;
+import { HttpMethod } from "../../lib/types";
 export declare const scanFile: <T extends string | undefined>(outputFile: string, inputFile: string, findCallBack: (fileContents: string) => T, typeCallBack: (type: NonNullable<T>, importAlias: string) => string) => {
     importName: string;
     importPath: string;

package/dist/cli/{scan-utils.js → core/scan-utils.js}

@@ -3,27 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scanRoute = exports.scanQuery = exports.scanFile = exports.createImportAlias = void 0;
+exports.scanRoute = exports.scanQuery = exports.scanFile = void 0;
 const fs_1 = __importDefault(require("fs"));
-const cache_1 = require("./cache");
+const alias_1 = require("./alias");
 const constants_1 = require("./constants");
 const path_utils_1 = require("./path-utils");
 const type_utils_1 = require("./type-utils");
-// 連番付与
-const createImportAlias = (type, key) => {
-    if (!cache_1.cntCache[key]) {
-        cache_1.cntCache[key] = 0;
-    }
-    return `${type}_${cache_1.cntCache[key]++}`;
-};
-exports.createImportAlias = createImportAlias;
 const scanFile = (outputFile, inputFile, findCallBack, typeCallBack) => {
     const fileContents = fs_1.default.readFileSync(inputFile, "utf8");
     const type = findCallBack(fileContents);
     if (!type)
         return;
     const relativeImportPath = (0, path_utils_1.createRelativeImportPath)(outputFile, inputFile);
-    const importAlias = (0, exports.createImportAlias)(type, type);
+    const importAlias = (0, alias_1.createImportAlias)(relativeImportPath, type);
     return {
         importName: importAlias,
         importPath: relativeImportPath,

package/dist/cli/core/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/core/types.js

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

package/dist/cli/debounce.d.ts

@@ -1 +1 @@
-export declare const debounce: <T extends (...args: any[]) => void>(func: T, delay: number) => (...args: Parameters<T>) => void;
+export declare const debounceOnceRunningWithTrailing: <T extends (...args: any[]) => Promise<void> | void>(func: T, delay: number) => (...args: Parameters<T>) => void;

package/dist/cli/debounce.js

@@ -1,14 +1,43 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.debounce = void 0;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const debounce = (func, delay) => {
-    let timer;
+exports.debounceOnceRunningWithTrailing = void 0;
+const debounceOnceRunningWithTrailing = (func, delay) => {
+    let timer = null;
+    let isRunning = false;
+    let pendingArgs = null;
+    const execute = (...args) => __awaiter(void 0, void 0, void 0, function* () {
+        isRunning = true;
+        try {
+            yield func(...args);
+        }
+        finally {
+            isRunning = false;
+            if (pendingArgs) {
+                const nextArgs = pendingArgs;
+                pendingArgs = null;
+                execute(...nextArgs);
+            }
+        }
+    });
     return (...args) => {
-        clearTimeout(timer);
+        if (timer)
+            clearTimeout(timer);
         timer = setTimeout(() => {
-            func(...args);
+            if (isRunning) {
+                pendingArgs = args !== null && args !== void 0 ? args : [];
+                return;
+            }
+            execute(...(args !== null && args !== void 0 ? args : []));
         }, delay);
     };
 };
-exports.debounce = debounce;
+exports.debounceOnceRunningWithTrailing = debounceOnceRunningWithTrailing;

package/dist/cli/generator.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generate = void 0;
 const fs_1 = __importDefault(require("fs"));
-const generate_path_structure_1 = require("./generate-path-structure");
+const generate_path_structure_1 = require("./core/generate-path-structure");
 const generate = ({ baseDir, outputPath, paramsFileName, logger, }) => {
     logger.info("Generating...");
     const { pathStructure, paramsTypes } = (0, generate_path_structure_1.generatePages)(outputPath, baseDir);

package/dist/cli/types.d.ts

@@ -1,5 +1,3 @@
-import type { END_POINT_FILE_NAMES } from "./constants";
-export type EndPointFileNames = (typeof END_POINT_FILE_NAMES)[number];
 export interface Logger {
     info: (msg: string) => void;
     success: (msg: string) => void;

package/dist/cli/watcher.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupWatcher = void 0;
 const chokidar_1 = __importDefault(require("chokidar"));
-const cache_1 = require("./cache");
+const cache_1 = require("./core/cache");
 const debounce_1 = require("./debounce");
 const setupWatcher = (baseDir, onGenerate, logger) => {
     logger.info(`Watching ${baseDir}...`);
@@ -14,12 +14,12 @@ const setupWatcher = (baseDir, onGenerate, logger) => {
     // Once the debounced function starts executing, no new watcher events will be processed until it completes.
     // This is due to JavaScript's single-threaded event loop: the current debounced function runs to completion,
     // and any new change events are queued until the execution finishes.
-    const debouncedGenerate = (0, debounce_1.debounce)(() => {
+    const debouncedGenerate = (0, debounce_1.debounceOnceRunningWithTrailing)(() => {
         changedPaths.forEach((path) => {
             (0, cache_1.clearVisitedDirsCacheAbove)(path);
+            (0, cache_1.clearScanAppDirCacheAbove)(path);
         });
         changedPaths.clear();
-        (0, cache_1.clearCntCache)();
         onGenerate();
     }, 300);
     const watcher = chokidar_1.default.watch(baseDir, {
@@ -28,6 +28,8 @@ const setupWatcher = (baseDir, onGenerate, logger) => {
         ignored: (path, stats) => !!(stats === null || stats === void 0 ? void 0 : stats.isFile()) && !isTargetFiles(path),
     });
     watcher.on("ready", () => {
+        // First execution
+        debouncedGenerate();
         watcher.on("all", (event, path) => {
             if (isTargetFiles(path)) {
                 logger.info(`[${event}] ${path}`);

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

@@ -1,2 +1,6 @@
-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>;
+import type { FuncParams, UrlOptions, ClientOptions, BodyOptions, HeadersOptions } from "./types";
+export declare const httpMethod: (key: string, paths: string[], params: FuncParams, dynamicKeys: string[], defaultOptions: ClientOptions) => (methodParam?: {
+    url?: UrlOptions;
+    body?: BodyOptions;
+    requestHeaders?: HeadersOptions;
+}, options?: ClientOptions) => Promise<Response>;

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

@@ -45,15 +45,32 @@ const normalizeHeaders = (headers) => {
     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);
+    return (methodParam, options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        let methodParamBody = undefined;
+        let methodParamContentType = undefined;
+        if ((_a = methodParam === null || methodParam === void 0 ? void 0 : methodParam.body) === null || _a === void 0 ? void 0 : _a.json) {
+            methodParamContentType = "application/json";
+            methodParamBody = JSON.stringify(methodParam.body.json);
+        }
+        const methodParamHeaders = (_b = methodParam === null || methodParam === void 0 ? void 0 : methodParam.requestHeaders) === null || _b === void 0 ? void 0 : _b.headers;
+        const methodParamCookies = (_c = methodParam === null || methodParam === void 0 ? void 0 : methodParam.requestHeaders) === null || _c === void 0 ? void 0 : _c.cookies;
+        const urlObj = (0, url_1.createUrl)([...paths], params, dynamicKeys)(methodParam === null || methodParam === void 0 ? void 0 : methodParam.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 innerHeaders = normalizeHeaders(methodParamHeaders ? methodParamHeaders : innerInit.headers);
         const mergedHeaders = Object.assign(Object.assign({}, defaultHeaders), innerHeaders);
+        if (methodParamContentType) {
+            mergedHeaders["content-type"] = methodParamContentType;
+        }
+        if (methodParamCookies) {
+            mergedHeaders["cookie"] = Object.entries(methodParamCookies)
+                .map(([key, value]) => `${key}=${value}`)
+                .join("; ");
+        }
         const { headers: _defaultHeaders } = defaultInit, defaultInitWithoutHeaders = __rest(defaultInit, ["headers"]);
         const { headers: _innerHeaders } = innerInit, innerInitWithoutHeaders = __rest(innerInit, ["headers"]);
         const mergedInit = (0, utils_1.deepMerge)(defaultInitWithoutHeaders, innerInitWithoutHeaders);
@@ -61,6 +78,9 @@ const httpMethod = (key, paths, params, dynamicKeys, defaultOptions) => {
         if (Object.keys(mergedHeaders).length > 0) {
             mergedInit.headers = mergedHeaders;
         }
+        if (methodParamBody) {
+            mergedInit.body = methodParamBody;
+        }
         const response = yield customFetch(urlObj.path, mergedInit);
         return response;
     });

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

@@ -1,3 +1,8 @@
+/*!
+ * 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 type { FuncParams, DynamicPathProxyAsFunction, ClientOptions, DynamicPathProxyAsProperty } from "./types";
 export declare const createRpcProxy: <T extends object>(options: ClientOptions, paths?: string[], params?: FuncParams, dynamicKeys?: string[]) => T;
 /**

package/dist/helper/client/rpc.js

@@ -1,6 +1,9 @@
 "use strict";
-// Inspired by Hono (https://github.com/honojs/hono)
-// Some parts of this code are based on or adapted from the Hono project
+/*!
+ * 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.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRpcHelper = exports.createRpcClient = exports.createRpcProxy = void 0;
 const http_method_1 = require("./http-method");

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

@@ -1,5 +1,6 @@
 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 { RouteHandlerResponse, RouteResponse, ValidationSchema } from "../server/route-types";
+import type { TypedNextResponse, HttpStatusCode, ContentType, ValidationInputFor } from "../server/types";
 import type { NextResponse } from "next/server";
 /**
  * Represents HTTP request headers with optional fields.
@@ -14,7 +15,7 @@ type HttpRequestHeaders = Partial<{
     "Cache-Control": string;
     Connection: string;
     "Content-Length": string;
-    "Content-Type": string;
+    "Content-Type": ContentType;
     Cookie: string;
     Date: string;
     Expect: string;
@@ -52,12 +53,12 @@ type HttpRequestHeaders = Partial<{
 /**
  * Extension of the standard `RequestInit` interface with strongly typed headers.
  */
-export interface TypedRequestInit extends RequestInit {
-    headers?: HttpRequestHeaders | HeadersInit;
+export interface TypedRequestInit<TWithoutHeaders extends "Content-Type" | "Cookie" = never> extends RequestInit {
+    headers?: (Omit<HttpRequestHeaders, TWithoutHeaders> & Record<string, string>) | HeadersInit;
 }
-export type ClientOptions = {
+export type ClientOptions<TWithoutHeaders extends "Content-Type" | "Cookie" = never, TWithoutInit extends "body" | "headers" = never> = {
     fetch?: typeof fetch;
-    init?: TypedRequestInit;
+    init?: Omit<TypedRequestInit<TWithoutHeaders>, TWithoutInit>;
 };
 declare const __proxy: unique symbol;
 export type Endpoint = {
@@ -95,18 +96,46 @@ export type UrlResult<T = unknown> = {
     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 IsNever<T> = [T] extends [never] ? true : false;
+type AllOptional<T> = Partial<T> extends T ? true : false;
+type UrlArgs<T> = T extends IsQuery ? [url: UrlOptions<T>] : [url?: UrlOptions<T>];
+type UrlArgsObj<T> = T extends IsQuery ? {
+    url: UrlOptions<T>;
+} : {
+    url?: UrlOptions<T>;
+};
+export type BodyOptions<TJson = unknown> = {
+    json: TJson;
+};
+type BodyArgsObj<TJson> = IsNever<TJson> extends true ? unknown : {
+    body: BodyOptions<TJson>;
+};
+export type HeadersOptions<THeaders = unknown, TCookies = unknown> = {
+    headers: THeaders;
+    cookies: TCookies;
+};
+type HeadersArgsObj<THeaders = unknown, TCookies = unknown> = IsNever<THeaders> extends true ? IsNever<TCookies> extends true ? unknown : {
+    requestHeaders: Pick<HeadersOptions<THeaders, TCookies>, "cookies">;
+} : IsNever<TCookies> extends true ? {
+    requestHeaders: Pick<HeadersOptions<THeaders, TCookies>, "headers">;
+} : {
+    requestHeaders: HeadersOptions<THeaders, TCookies>;
+};
+type HttpMethodsArgs<T, TValidationSchema extends ValidationSchema, TJson = ValidationInputFor<"json", TValidationSchema>, THeaders = ValidationInputFor<"headers", TValidationSchema>, TCookies = ValidationInputFor<"cookies", TValidationSchema>, TBaseArgs = UrlArgsObj<T> & BodyArgsObj<TJson> & HeadersArgsObj<THeaders, TCookies>> = [
+    ...(AllOptional<TBaseArgs> extends true ? [methodParam?: TBaseArgs] : [methodParam: TBaseArgs]),
+    option?: ClientOptions<(IsNever<TJson> extends true ? never : "Content-Type") | (IsNever<TCookies> extends true ? never : "Cookie"), (IsNever<TJson> extends true ? never : "body") | (IsNever<THeaders> extends true ? never : "headers")>
+];
 type InferHttpMethods<T extends IsHttpMethod> = {
-    [K in keyof T as K extends HttpMethodFuncKey ? K : never]: (...args: HttpMethodsArg<T>) => Promise<InferTypedNextResponseType<T[K]>>;
+    [K in keyof T as K extends HttpMethodFuncKey ? K : never]: (...args: HttpMethodsArgs<T, InferValidationSchema<T[K]>>) => Promise<InferTypedNextResponseType<T[K]>>;
 };
+type InferValidationSchema<T> = T extends (...args: any[]) => RouteHandlerResponse<RouteResponse, infer TValidationSchema> ? TValidationSchema : ValidationSchema;
 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>;
+    $url: (...args: UrlArgs<T>) => UrlResult<T>;
 } & (T extends IsHttpMethod ? InferHttpMethods<T> : unknown);
 type ParamFunction<T, TParamArgs extends unknown[]> = (...args: [...TParamArgs]) => DynamicPathProxyAsFunction<T>;
 type NonEmptyArray<T> = [T, ...T[]];

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

@@ -1,2 +1,3 @@
-import type { Handler, Params, Query, RouteResponse, ValidationSchema } from "./types";
+import type { ValidationSchema, RouteResponse, Handler } from "./route-types";
+import type { Params, Query } 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-route-context.d.ts

@@ -1,4 +1,5 @@
-import type { RouteContext, Query, ValidationSchema, Params } from "./types";
+import type { ValidationSchema } from "./route-types";
+import type { RouteContext, Query, 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>;

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

@@ -1,6 +1,4 @@
 "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");

package/dist/helper/server/route-handler-factory.d.ts

@@ -1,4 +1,9 @@
-import type { Query, Params, RouteBindings, MethodRouteDefinition, RequiredRouteResponse, ErrorHandler } from "./types";
+/*!
+ * Inspired by Hono (https://github.com/honojs/hono),
+ * particularly its routing design and handler interface.
+ */
+import type { RequiredRouteResponse, ErrorHandler, RouteBindings, MethodRouteDefinition } from "./route-types";
+import type { Query, Params } from "./types";
 /**
  * A factory function that creates route handlers for various HTTP methods (GET, POST, etc.).
  *

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

@@ -1,4 +1,8 @@
 "use strict";
+/*!
+ * Inspired by Hono (https://github.com/honojs/hono),
+ * particularly its routing design and handler interface.
+ */
 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) {

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

@@ -0,0 +1,39 @@
+/*!
+ * Portions of this code are based on the Hono project (https://github.com/honojs/hono),
+ * originally created by Yusuke Wada (https://github.com/yusukebe) and developed with
+ * contributions from the Hono community.
+ * 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 type { TypedNextResponse, Query, RouteContext, Params } from "./types";
+import type { HttpMethod } from "../../lib/types";
+import type { NextRequest } from "next/server";
+export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | void>;
+export type RequiredRouteResponse = TypedNextResponse | Promise<TypedNextResponse>;
+export interface RouteBindings {
+    params?: Params | Promise<Params>;
+    query?: Query;
+}
+export interface ValidationSchema {
+    input: {};
+    output: {};
+}
+export type Handler<TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema, TRouteResponse extends RouteResponse = RouteResponse> = (routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => TRouteResponse;
+export type ErrorHandler<TRouteResponse extends RequiredRouteResponse, TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema> = (error: unknown, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => TRouteResponse;
+export type RouteHandlerResponse<TRouteResponse extends RouteResponse, _TValidationSchema extends ValidationSchema> = Promise<Exclude<Awaited<TRouteResponse>, void | undefined>>;
+export type RouteHandler<TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse, TValidationSchema extends ValidationSchema> = (req: NextRequest, segmentData: {
+    params: Promise<TParams>;
+}) => RouteHandlerResponse<TRouteResponse, TValidationSchema>;
+type HttpMethodMapping<THttpMethod extends HttpMethod, TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse, TValidationSchema extends ValidationSchema> = Record<THttpMethod, RouteHandler<TParams, TRouteResponse, TValidationSchema>>;
+export interface MethodRouteDefinition<THttpMethod extends HttpMethod, TBindings extends RouteBindings, TOnErrorResponse extends RequiredRouteResponse, TParams extends TBindings["params"] = TBindings extends {
+    params: infer TValue;
+} ? Awaited<TValue> : Params, TQuery extends TBindings["query"] = TBindings extends {
+    query: infer TValue;
+} ? TValue : Query> {
+    <TV1 extends ValidationSchema = ValidationSchema, TR1 extends RequiredRouteResponse = RequiredRouteResponse>(handler: Handler<TParams, TQuery, TV1, TR1>): HttpMethodMapping<THttpMethod, TParams, TR1 | TOnErrorResponse, TV1>;
+    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TR1 extends RouteResponse = RouteResponse, TR2 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TOnErrorResponse, TV2>;
+    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TV3 extends ValidationSchema = TV1 & TV2, TR1 extends RouteResponse = RouteResponse, TR2 extends RouteResponse = RouteResponse, TR3 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>, handler3: Handler<TParams, TQuery, TV3, TR3>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TR3 | TOnErrorResponse, TV3>;
+    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TV3 extends ValidationSchema = TV1 & TV2, TV4 extends ValidationSchema = TV1 & TV2 & TV3, TR1 extends RouteResponse = RouteResponse, TR2 extends RouteResponse = RouteResponse, TR3 extends RouteResponse = RouteResponse, TR4 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>, handler3: Handler<TParams, TQuery, TV3, TR3>, handler4: Handler<TParams, TQuery, TV4, TR4>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TR3 | TR4 | TOnErrorResponse, TV4>;
+}
+export {};

package/dist/helper/server/route-types.js

@@ -0,0 +1,10 @@
+"use strict";
+/*!
+ * Portions of this code are based on the Hono project (https://github.com/honojs/hono),
+ * originally created by Yusuke Wada (https://github.com/yusukebe) and developed with
+ * contributions from the Hono community.
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,4 +1,4 @@
-import { HttpMethod } from "../../lib/types";
+import type { ValidationSchema } from "./route-types";
 import type { NextResponse, NextRequest } from "next/server";
 type KnownContentType = "application/json" | "text/html" | "text/plain" | "application/javascript" | "text/css" | "image/png" | "image/jpeg" | "image/svg+xml" | "application/pdf" | "application/octet-stream" | "multipart/form-data" | "application/x-www-form-urlencoded";
 /**
@@ -217,34 +217,9 @@ export interface RouteContext<TParams = Params, TQuery = Query, TValidationSchem
      */
     redirect: <TStatus extends RedirectionHttpStatusCode = 302>(url: string, init?: TStatus | TypedResponseInit<TStatus, "">) => TypedNextResponse<undefined, TStatus, "">;
 }
-export type RouteResponse = TypedNextResponse | Promise<TypedNextResponse | void>;
-export type RequiredRouteResponse = TypedNextResponse | Promise<TypedNextResponse>;
-export interface RouteBindings {
-    params?: Params | Promise<Params>;
-    query?: Query;
-}
-export type ValidationTarget = "params" | "query";
-export interface ValidationSchema {
-    input: {};
-    output: {};
-}
+export type ValidationTarget = "params" | "query" | "json" | "headers" | "cookies";
 type ValidationFor<TDirection extends keyof ValidationSchema, TTarget extends ValidationTarget, TSchema extends ValidationSchema> = TTarget extends keyof TSchema[TDirection] ? TSchema[TDirection][TTarget] : never;
-type ValidationInputFor<TTarget extends ValidationTarget, TSchema extends ValidationSchema> = ValidationFor<"input", TTarget, TSchema>;
+export type ValidationInputFor<TTarget extends ValidationTarget, TSchema extends ValidationSchema> = ValidationFor<"input", TTarget, TSchema>;
 type ValidationOutputFor<TTarget extends ValidationTarget, TSchema extends ValidationSchema> = ValidationFor<"output", TTarget, TSchema>;
 export type ConditionalValidationInput<TTarget extends ValidationTarget, TExpected extends ValidationTarget, TSchema extends ValidationSchema, TFallback> = TTarget extends TExpected ? ValidationInputFor<TTarget, TSchema> : TFallback;
-export type Handler<TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema, TRouteResponse extends RouteResponse = RouteResponse> = (routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => TRouteResponse;
-export type ErrorHandler<TRouteResponse extends RequiredRouteResponse, TParams = Params, TQuery = Query, TValidationSchema extends ValidationSchema = ValidationSchema> = (error: unknown, routeContext: RouteContext<TParams, TQuery, TValidationSchema>) => TRouteResponse;
-type RouteHandler<TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse> = (req: NextRequest, segmentData: {
-    params: Promise<TParams>;
-}) => Promise<Exclude<Awaited<TRouteResponse>, void | undefined>>;
-type HttpMethodMapping<THttpMethod extends HttpMethod, TParams extends RouteBindings["params"], TRouteResponse extends RouteResponse> = Record<THttpMethod, RouteHandler<TParams, TRouteResponse>>;
-export interface MethodRouteDefinition<THttpMethod extends HttpMethod, TBindings extends RouteBindings, TOnErrorResponse extends RequiredRouteResponse, TParams extends TBindings["params"] = TBindings extends {
-    params: infer TValue;
-} ? Awaited<TValue> : Params, TQuery extends TBindings["query"] = TBindings extends {
-    query: infer TValue;
-} ? TValue : Query> {
-    <TV1 extends ValidationSchema = ValidationSchema, TR1 extends RequiredRouteResponse = RequiredRouteResponse>(handler: Handler<TParams, TQuery, TV1, TR1>): HttpMethodMapping<THttpMethod, TParams, TR1 | TOnErrorResponse>;
-    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TR1 extends RouteResponse = RouteResponse, TR2 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TOnErrorResponse>;
-    <TV1 extends ValidationSchema = ValidationSchema, TV2 extends ValidationSchema = TV1, TV3 extends ValidationSchema = TV1 & TV2, TR1 extends RouteResponse = RouteResponse, TR2 extends RouteResponse = RouteResponse, TR3 extends RequiredRouteResponse = RequiredRouteResponse>(handler1: Handler<TParams, TQuery, TV1, TR1>, handler2: Handler<TParams, TQuery, TV2, TR2>, handler3: Handler<TParams, TQuery, TV3, TR3>): HttpMethodMapping<THttpMethod, TParams, TR1 | TR2 | TR3 | TOnErrorResponse>;
-}
 export {};

package/dist/helper/server/types.js

@@ -1,4 +1,2 @@
 "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 });

package/dist/helper/server/validators/validator-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const getHeadersObject: () => Promise<Record<string, string>>;
+export declare const getCookiesObject: () => Promise<Record<string, string>>;

package/dist/helper/server/validators/validator-utils.js

@@ -0,0 +1,31 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookiesObject = exports.getHeadersObject = void 0;
+const headers_1 = require("next/headers");
+const getHeadersObject = () => __awaiter(void 0, void 0, void 0, function* () {
+    const headersList = yield (0, headers_1.headers)();
+    const headersObj = {};
+    for (const [key, value] of headersList.entries()) {
+        headersObj[key] = value;
+    }
+    return headersObj;
+});
+exports.getHeadersObject = getHeadersObject;
+const getCookiesObject = () => __awaiter(void 0, void 0, void 0, function* () {
+    const cookiesList = yield (0, headers_1.cookies)();
+    const cookiesObj = {};
+    for (const cookie of cookiesList.getAll()) {
+        cookiesObj[cookie.name] = cookie.value;
+    }
+    return cookiesObj;
+});
+exports.getCookiesObject = getCookiesObject;

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

@@ -1,6 +1,15 @@
-import type { RouteContext, Params, Query, TypedNextResponse, ValidationSchema, ConditionalValidationInput, ValidationTarget } from "../../types";
+/*!
+ * Portions of this code are based on the Hono project (https://github.com/honojs/middleware/tree/main/packages/zod-validator),
+ * originally created by Yusuke Wada (https://github.com/yusukebe) and developed with
+ * contributions from the Hono community.
+ * 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 type { ValidationSchema } from "../../route-types";
+import type { RouteContext, Params, Query, TypedNextResponse, ConditionalValidationInput, ValidationTarget } from "../../types";
 import type { z, ZodSchema } from "zod";
 export declare const zodValidator: <TValidationTarget extends ValidationTarget, 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("../../types").Handler<TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;
+}, 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<TParams, TQuery, TValidationSchema, Promise<Exclude<THookReturn, void> | undefined>>;

package/dist/helper/server/validators/zod/zod-validator.js

@@ -1,6 +1,12 @@
 "use strict";
-// Inspired by Hono (https://github.com/honojs/middleware/tree/main/packages/zod-validator)
-// Some parts of this code are based on or adapted from the Hono project
+/*!
+ * Portions of this code are based on the Hono project (https://github.com/honojs/middleware/tree/main/packages/zod-validator),
+ * originally created by Yusuke Wada (https://github.com/yusukebe) and developed with
+ * contributions from the Hono community.
+ * 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.
+ */
 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) {
@@ -13,6 +19,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zodValidator = void 0;
 const create_handler_1 = require("../../create-handler");
+const validator_utils_1 = require("../validator-utils");
 const zodValidator = (target, schema, hook) => {
     const resolvedHook = hook !== null && hook !== void 0 ? hook : ((result, rc) => {
         if (!result.success) {
@@ -27,6 +34,15 @@ const zodValidator = (target, schema, hook) => {
             if (target === "query") {
                 return rc.req.query();
             }
+            if (target === "json") {
+                return rc.req.json();
+            }
+            if (target === "headers") {
+                return yield (0, validator_utils_1.getHeadersObject)();
+            }
+            if (target === "cookies") {
+                return yield (0, validator_utils_1.getCookiesObject)();
+            }
         }))();
         const result = yield schema.safeParseAsync(value);
         const hookResult = resolvedHook(result, rc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rpc4next",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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",

package/dist/cli/cache.d.ts

@@ -1,4 +0,0 @@
-export declare const visitedDirsCache: Map<string, boolean>;
-export declare const cntCache: Record<string, number>;
-export declare const clearCntCache: () => void;
-export declare const clearVisitedDirsCacheAbove: (targetPath: string) => void;