shokupan 0.10.5 → 0.12.0

package/dist/router.d.ts

@@ -1,6 +1,5 @@
 import { ShokupanContext } from './context';
 import { Shokupan } from './shokupan';
-import { SurrealDatastore } from './util/datastore';
 import { $appRoot, $childControllers, $childRouters, $isApplication, $isMounted, $isRouter, $mountPath, $parent, $routes } from './util/symbol';
 import { GuardAPISpec, HeadersInit, JSXRenderer, Method, MethodAPISpec, Middleware, OpenAPIOptions, ProcessResult, RequestOptions, RouteMetadata, RouteParams, ShokupanController, ShokupanHandler, ShokupanHooks, ShokupanRoute, ShokupanRouteConfig, StaticServeOptions } from './util/types';
 export declare const RouterRegistry: Map<string, ShokupanRouter<any>>;
@@ -74,7 +73,27 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
     private [$parent];
     [$childRouters]: ShokupanRouter<T>[];
     [$childControllers]: ShokupanController[];
-    get db(): SurrealDatastore | undefined;
+    private _hasOnResponseEndHook;
+    private _hasOnRequestStartHook;
+    private _hasOnRequestEndHook;
+    private _hasOnResponseStartHook;
+    private _hasOnErrorHook;
+    private _hasOnRequestTimeoutHook;
+    private _hasOnReadTimeoutHook;
+    private _hasOnWriteTimeoutHook;
+    private _hasBeforeValidateHook;
+    private _hasAfterValidateHook;
+    get hasOnResponseEndHook(): boolean;
+    get hasOnRequestStartHook(): boolean;
+    get hasOnRequestEndHook(): boolean;
+    get hasOnResponseStartHook(): boolean;
+    get hasOnErrorHook(): boolean;
+    get hasOnRequestTimeoutHook(): boolean;
+    get hasOnReadTimeoutHook(): boolean;
+    get hasOnWriteTimeoutHook(): boolean;
+    get hasBeforeValidateHook(): boolean;
+    get hasAfterValidateHook(): boolean;
+    requestTimeout?: number;
     private hookCache;
     private hooksInitialized;
     middleware: Middleware[];
@@ -85,10 +104,13 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         development: boolean;
         enableAsyncLocalStorage: boolean;
         enableOpenApiGen: boolean;
+        blockOnOpenApiGen: boolean;
         enableAsyncApiGen: boolean;
+        blockOnAsyncApiGen: boolean;
         reusePort: boolean;
         controllersOnly: boolean;
         enableTracing?: boolean;
+        queryParserMode?: "extended" | "simple" | "strict";
         jsonParser?: "native" | "parse-json" | "secure-json-parse";
         autoBackpressureFeedback?: boolean;
         autoBackpressureLevel?: number;
@@ -108,10 +130,13 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
             fatal: (msg: string, props: Record<string, any>) => void;
         };
         readTimeout: number;
+        maxBodySize?: number;
         requestTimeout: number;
         writeTimeout: number;
         renderer: JSXRenderer;
         serverFactory: import('.').ServerFactory;
+        adapter?: "bun" | "node" | "wintercg" | import('./util/adapter').ServerAdapter;
+        fileSystem?: import('./util/adapter/filesystem').FileSystemAdapter;
         hooks: ShokupanHooks<Record<string, any>> | ShokupanHooks<Record<string, any>>[];
         validateStatusCodes: boolean;
         surreal?: {
@@ -148,6 +173,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
                 spec_url: string;
             }>;
         };
+        securityHeaders?: boolean | any;
     }>;
     get root(): Shokupan<any>;
     [$routes]: ShokupanRoute[];
@@ -160,7 +186,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * Middleware will run for all routes matched by this router.
      */
     use(middleware: Middleware): this;
-    getComponentRegistry(): {
+    get registry(): {
         metadata: RouteMetadata;
         middleware: {
             name: string;
@@ -195,6 +221,13 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
                 routes: any[];
             };
         }[];
+        events: {
+            type: 'event';
+            name: string;
+            handlerName: string;
+            metadata: RouteMetadata;
+            _fn: ShokupanHandler<T>;
+        }[];
     };
     constructor(config?: ShokupanRouteConfig);
     private isRouterInstance;
@@ -202,10 +235,18 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * Registers an event handler for WebSocket.
      */
     event(name: string, handler: ShokupanHandler<T>): this;
+    /**
+     * Registers a lifecycle hook dynamically.
+     */
+    hook(name: keyof ShokupanHooks, handler: Function): this;
     /**
      * Finds an event handler(s) by name.
      */
     findEvent(name: string): ShokupanHandler<T>[] | null;
+    /**
+     * Registers a controller instance to the router.
+     */
+    bindController(controller: any): void;
     /**
      * Returns all registered event handlers.
      */
@@ -248,7 +289,6 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
     testRequest(options: RequestOptions): Promise<ProcessResult>;
     private wrapWithHooks;
     private mountRouter;
-    private scanControllerRoutes;
     /**
      * Find a route matching the given method and path.
      * @param method HTTP method
@@ -260,7 +300,6 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
         params: Record<string, string>;
     } | null;
     private parsePath;
-    requestTimeout?: number;
     /**
      * Adds a route to the router.
      *
@@ -297,7 +336,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    get<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    get<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a GET route to the router.
      *
@@ -305,14 +344,14 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    get<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    get<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a POST route to the router.
      *
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    post<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    post<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a POST route to the router.
      *
@@ -320,14 +359,14 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    post<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    post<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a PUT route to the router.
      *
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    put<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    put<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a PUT route to the router.
      *
@@ -335,14 +374,14 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    put<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    put<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a DELETE route to the router.
      *
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    delete<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    delete<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a DELETE route to the router.
      *
@@ -350,14 +389,14 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    delete<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    delete<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a PATCH route to the router.
      *
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    patch<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    patch<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a PATCH route to the router.
      *
@@ -365,14 +404,14 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    patch<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    patch<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a OPTIONS route to the router.
      *
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    options<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    options<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a OPTIONS route to the router.
      *
@@ -380,14 +419,14 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    options<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    options<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a HEAD route to the router.
      *
      * @param path - URL path
      * @param handlers - Route handler functions
      */
-    head<Path extends string>(path: Path, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    head<Path extends string>(path: Path, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a HEAD route to the router.
      *
@@ -395,7 +434,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * @param spec - OpenAPI specification for the route
      * @param handlers - Route handler functions
      */
-    head<Path extends string>(path: Path, spec: MethodAPISpec, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
+    head<Path extends string>(path: Path, spec: MethodAPISpec, handler: ShokupanHandler<T, RouteParams<Path>>, ...handlers: ShokupanHandler<T, RouteParams<Path>>[]): any;
     /**
      * Adds a guard to the router that applies to all routes added **after** this point.
      * Guards must return true or call `ctx.next()` to allow the request to continue.
@@ -427,6 +466,7 @@ export declare class ShokupanRouter<T extends Record<string, any> = Record<strin
      * Now includes runtime analysis of handler functions to infer request/response types.
      */
     generateApiSpec(options?: OpenAPIOptions): Promise<any>;
+    hasHooks(name: keyof ShokupanHooks): boolean;
     private ensureHooksInitialized;
     runHooks(name: keyof ShokupanHooks, ...args: any[]): void | Promise<void[]>;
 }

package/dist/server.d.ts

@@ -0,0 +1,22 @@
+import { Shokupan } from './shokupan';
+/**
+ * Shokupan Server
+ *
+ * Responsible for the lifecycle of the HTTP server (listen, stop)
+ * and managing the underlying adapter (Bun, Node, etc).
+ */
+export declare class ShokupanServer {
+    private app;
+    private server?;
+    private adapter?;
+    constructor(app: Shokupan);
+    /**
+     * Starts the application server.
+     * @param port The port to listen on.
+     */
+    listen(port?: number): Promise<any>;
+    /**
+     * Stops the server.
+     */
+    stop(closeActiveConnections?: boolean): Promise<void>;
+}

package/dist/shokupan.d.ts

@@ -1,9 +1,9 @@
-import { $dispatch } from './util/symbol';
-import { Middleware, ProcessResult, RequestOptions, ShokupanConfig, ShokupanPlugin } from './util/types';
 import { Server } from 'bun';
 import { ShokupanRouter } from './router';
 import { SurrealDatastore } from './util/datastore';
 import { ShokupanRequest } from './util/request';
+import { $dispatch } from './util/symbol';
+import { Middleware, ProcessResult, RequestOptions, ShokupanConfig, ShokupanPlugin } from './util/types';
 /**
  * Shokupan Application
  *
@@ -72,11 +72,15 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
     readonly applicationConfig: ShokupanConfig;
     openApiSpec?: any;
     asyncApiSpec?: any;
+    private openApiSpecPromise?;
+    private asyncApiSpecPromise?;
     private composedMiddleware?;
     private cpuMonitor?;
-    private server?;
+    server?: Server<any>;
+    private httpServer?;
     private datastore?;
     dbPromise?: Promise<any>;
+    private rootTrie?;
     get db(): SurrealDatastore | undefined;
     get logger(): {
         verbose: boolean;
@@ -88,6 +92,9 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
     };
     constructor(applicationConfig?: ShokupanConfig);
     private initDatastore;
+    /**
+     * Adds middleware to the application.
+     */
     /**
      * Adds middleware to the application.
      */
@@ -109,6 +116,17 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
      * This happens after generateOpenApi() but before the server starts listening (or at least before it finishes startup if async).
      */
     onSpecAvailable(callback: (spec: any) => void | Promise<void>): this;
+    /**
+     * Starts the application server.
+     *
+     * @param port - The port to listen on. If not specified, the port from the configuration is used. If that is not specified, port 3000 is used.
+     * @returns The server instance.
+     */
+    /**
+     * Prepare the application for listening.
+     * Use this if you want to initialize the app without starting the server immediately.
+     */
+    start(): Promise<void>;
     /**
      * Starts the application server.
      *
@@ -150,4 +168,14 @@ export declare class Shokupan<T = any> extends ShokupanRouter<T> {
      */
     fetch(req: Request, server?: Server<any>): Promise<Response>;
     private handleRequest;
+    /**
+     * Compiles all routes into a master Trie for O(1) router lookup.
+     * Use this if adding routes dynamically after start (not recommended but possible).
+     */
+    compile(): void;
+    private flattenRoutes;
+    find(method: string, path: string): {
+        handler: import('.').ShokupanHandler<T>;
+        params: Record<string, string>;
+    };
 }

package/dist/util/adapter/bun.d.ts

@@ -0,0 +1,8 @@
+import { Server } from 'bun';
+import { Shokupan } from '../../shokupan';
+import { ServerAdapter } from './interface';
+export declare class BunAdapter implements ServerAdapter {
+    private server?;
+    listen(port: number, app: Shokupan): Promise<Server<any>>;
+    stop(): Promise<void>;
+}

package/dist/util/adapter/filesystem.d.ts

@@ -0,0 +1,20 @@
+export interface FileSystemAdapter {
+    readFile(path: string): Promise<Uint8Array | string | ReadableStream>;
+    stat?(path: string): Promise<{
+        size: number;
+        mtime: Date;
+    }>;
+}
+/**
+ * Default file system adapter that uses Bun.file for Bun and Node.js fs.promises for Node.js.
+ */
+export declare class DefaultFileSystemAdapter implements FileSystemAdapter {
+    readFile(path: string): Promise<Uint8Array | string | ReadableStream>;
+    stat(path: string): Promise<{
+        size: number;
+        mtime: Date;
+    }>;
+}
+export declare class NoOpFileSystemAdapter implements FileSystemAdapter {
+    readFile(path: string): Promise<Uint8Array | string | ReadableStream>;
+}

package/dist/util/adapter/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bun';
+export * from './interface';
+export * from './node';
+export * from './wintercg';

package/dist/util/adapter/interface.d.ts

@@ -0,0 +1,12 @@
+import { Server } from 'bun';
+import { Shokupan } from '../../shokupan';
+export interface ServerAdapter {
+    /**
+     * Start listening on the specified port.
+     */
+    listen(port: number, app: Shokupan): Promise<Server<any>>;
+    /**
+     * Stop the server.
+     */
+    stop?(): Promise<void>;
+}

package/dist/util/adapter/node.d.ts

@@ -0,0 +1,8 @@
+import { Server } from 'bun';
+import { Shokupan } from '../../shokupan';
+import { ServerAdapter } from './interface';
+export declare class NodeAdapter implements ServerAdapter {
+    private server?;
+    listen(port: number, app: Shokupan): Promise<Server<any>>;
+    stop(): Promise<void>;
+}

package/dist/util/adapter/wintercg.d.ts

@@ -0,0 +1,5 @@
+import { Shokupan } from '../../shokupan';
+import { ServerAdapter } from './interface';
+export declare class WinterCGAdapter implements ServerAdapter {
+    listen(port: number, app: Shokupan): Promise<any>;
+}

package/dist/util/body-parser.d.ts

@@ -0,0 +1,30 @@
+import { ShokupanRequest } from './request';
+import { ShokupanConfig } from './types';
+/**
+ * Utility class for parsing request bodies.
+ * Handles size limits, parsing, and caching logic detached from the Context.
+ */
+export declare class BodyParser {
+    /**
+     * Parses the body of a request based on Content-Type header.
+     * @param req The ShokupanRequest object
+     * @param config Application configuration for limits and parser options
+     * @returns The parsed body or throws an error
+     */
+    static parse(req: ShokupanRequest<any>, config?: ShokupanConfig): Promise<{
+        type: string;
+        body: any;
+    }>;
+    /**
+     * Parsing helper for JSON
+     */
+    static parseJson(req: ShokupanRequest<any>, parserType: 'native' | 'parse-json' | 'secure-json-parse', maxBodySize: number): Promise<any>;
+    /**
+     * Parsing helper for FormData
+     */
+    static parseFormData(req: ShokupanRequest<any>, maxBodySize: number): Promise<FormData>;
+    /**
+     * Reads raw body as string with size enforcement
+     */
+    static readRawBody(req: ShokupanRequest<any>, maxBodySize: number): Promise<string>;
+}

package/dist/util/controller-scanner.d.ts

@@ -0,0 +1,4 @@
+import { ShokupanRouter } from '../router';
+export declare class ControllerScanner {
+    static scan<T extends Record<string, any>>(router: ShokupanRouter<T>, prefix: string, controller: any): void;
+}

package/dist/util/cpu-monitor.d.ts

@@ -3,7 +3,9 @@ export declare class SystemCpuMonitor {
     private interval;
     private lastCpus;
     private currentUsage;
+    private osStub;
     constructor(intervalMs?: number);
+    private init;
     start(): void;
     stop(): void;
     getUsage(): number;

package/dist/util/decorators.d.ts

@@ -5,9 +5,26 @@ import { AsyncAPISpec, GuardAPISpec, MethodAPISpec, Middleware } from './types';
  */
 export declare function Controller(path?: string): (target: any) => void;
 /**
- * Decorator: Applies middleware to a class or method.
+ * Registers this class as a **Singleton** service.
+ * A single instance will be created and shared across the process.
  */
-export declare function Use(...middleware: Middleware[]): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
+export declare function Injectable(scope: 'singleton'): ClassDecorator;
+/**
+ * Registers this class as an **Instanced** (Transient) service.
+ * A new instance will be created every time dependency is resolved.
+ */
+export declare function Injectable(scope: 'instanced'): ClassDecorator;
+/**
+ * Property/Parameter Decorator: Injects a service.
+ * Used on class properties or constructor parameters.
+ */
+export declare function Inject(token: any): PropertyDecorator & ParameterDecorator;
+/**
+ * Decorator: Applies middleware OR injects dependencies.
+ * - Class/Method: Middleware
+ * - Property/Parameter: Dependency Injection
+ */
+export declare function Use(tokenOrMiddleware?: any | Middleware, ...moreMiddleware: Middleware[]): (target: any, propertyKey?: string, indexOrDescriptor?: PropertyDescriptor | number) => void;
 /**
  * Decorator: Binds a parameter to the request body.
  */
@@ -76,4 +93,4 @@ export declare function Event(eventName: string): (target: any, propertyKey: str
 /**
  * Decorator: Applies a rate limit to a class or method.
  */
-export declare function RateLimit(options: RateLimitOptions): (target: any, propertyKey?: string, descriptor?: PropertyDescriptor) => void;
+export declare function RateLimit(options: RateLimitOptions): (target: any, propertyKey?: string, indexOrDescriptor?: PropertyDescriptor | number) => void;

package/dist/util/di.d.ts

@@ -6,13 +6,8 @@ export declare class Container {
     static register<T>(target: new (...args: any[]) => T, instance: T): void;
     static get<T>(target: new (...args: any[]) => T): T | undefined;
     static has(target: any): boolean;
+    private static cache;
+    private static resolvingStack;
     static resolve<T>(target: new (...args: any[]) => T): T;
+    static teardown(): Promise<void>;
 }
-/**
- * Decorator to mark a class as injectable (Service).
- */
-export declare function Injectable(): (target: any) => void;
-/**
- * Property Decorator: Injects a service.
- */
-export declare function Inject(token: any): (target: any, key: string) => void;

package/dist/util/metadata.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lightweight Polyfill for Reflect Metadata API.
+ *
+ * Replaces the need for 'reflect-metadata' package to reduce bundle size
+ * while maintaining compatibility with TypeScript's emitDecoratorMetadata.
+ */
+export declare function defineMetadata(key: string | symbol, value: any, target: any, propertyKey?: string | symbol): void;
+export declare function getMetadata(key: string | symbol, target: any, propertyKey?: string | symbol): any;
+declare global {
+    namespace Reflect {
+        function defineMetadata(metadataKey: any, metadataValue: any, target: Object, propertyKey?: string | symbol): void;
+        function getMetadata(metadataKey: any, target: Object, propertyKey?: string | symbol): any;
+        function metadata(metadataKey: any, metadataValue: any): {
+            (target: Function): void;
+            (target: Object, propertyKey: string | symbol): void;
+        };
+    }
+}

package/dist/util/middleware-tracker.d.ts

@@ -0,0 +1,10 @@
+import { Middleware, ShokupanHandler } from '../util/types';
+export declare class MiddlewareTracker {
+    static wrap(handler: Middleware | ShokupanHandler<any>, context: {
+        file: string;
+        line: number;
+        name?: string;
+        isBuiltin?: boolean;
+        pluginName?: string;
+    }): any;
+}

package/dist/util/request.d.ts

@@ -18,6 +18,7 @@ declare class ShokupanRequestBase {
     text(): Promise<string>;
     formData(): Promise<FormData>;
     constructor(props: ShokupanRequestProps);
+    clone(): ShokupanRequest<any>;
 }
 /**
  * This type is used to add properties to the request object.

package/dist/util/symbol.d.ts

@@ -29,6 +29,7 @@ export declare const $cachedProtocol: unique symbol;
 export declare const $cachedHost: unique symbol;
 export declare const $cachedOrigin: unique symbol;
 export declare const $cachedQuery: unique symbol;
+export declare const $cachedCookies: unique symbol;
 export declare const $ws: unique symbol;
 export declare const $socket: unique symbol;
 export declare const $io: unique symbol;