@carno.js/core 0.2.8 → 0.2.10

package/dist/route/JITCompiler.js

@@ -2,137 +2,244 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileRouteHandler = compileRouteHandler;
 exports.compileValidatedHandler = compileValidatedHandler;
+const TEXT_HEADERS = Object.freeze({
+    'Content-Type': 'text/html'
+});
+const JSON_HEADERS = Object.freeze({
+    'Content-Type': 'application/json'
+});
+function isBodyInitResult(result) {
+    if (!result) {
+        return false;
+    }
+    if (result instanceof ReadableStream) {
+        return true;
+    }
+    if (result instanceof Blob || result instanceof ArrayBuffer) {
+        return true;
+    }
+    if (ArrayBuffer.isView(result)) {
+        return true;
+    }
+    return result instanceof FormData || result instanceof URLSearchParams;
+}
+/**
+ * Cria handler inline com response building integrado.
+ * Usado quando não há parâmetros.
+ */
+function createInlineResponseHandler(handler, isAsync) {
+    if (isAsync) {
+        return async (c) => {
+            const r = await handler();
+            const s = c.getResponseStatus() || 200;
+            if (typeof r === 'string')
+                return new Response(r, { status: s, headers: TEXT_HEADERS });
+            if (r instanceof Response)
+                return r;
+            if (r == null)
+                return new Response('', { status: s, headers: TEXT_HEADERS });
+            if (typeof r === 'number' || typeof r === 'boolean') {
+                return new Response(String(r), { status: s, headers: TEXT_HEADERS });
+            }
+            if (isBodyInitResult(r)) {
+                return new Response(r, { status: s });
+            }
+            return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
+        };
+    }
+    return (c) => {
+        const r = handler();
+        const s = c.getResponseStatus() || 200;
+        if (typeof r === 'string')
+            return new Response(r, { status: s, headers: TEXT_HEADERS });
+        if (r instanceof Response)
+            return r;
+        if (r == null)
+            return new Response('', { status: s, headers: TEXT_HEADERS });
+        if (typeof r === 'number' || typeof r === 'boolean') {
+            return new Response(String(r), { status: s, headers: TEXT_HEADERS });
+        }
+        if (isBodyInitResult(r)) {
+            return new Response(r, { status: s });
+        }
+        return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
+    };
+}
 function escapeKey(key) {
-    return key.replace(/['"\\]/g, '\\$&');
+    return key.replace(/['\"\\]/g, '\\$&');
 }
-function buildArgExpression(param, index) {
+/**
+ * Gera expressão de acesso a parâmetro inline.
+ * Otimizado para evitar chamadas de função quando possível.
+ */
+function buildArgExpression(param) {
     const key = param.key ? escapeKey(param.key) : undefined;
     switch (param.type) {
         case 'param':
-            return key ? `ctx.param['${key}']` : 'ctx.param';
+            return key ? `c.param['${key}']` : 'c.param';
         case 'query':
-            return key ? `ctx.query['${key}']` : 'ctx.query';
+            return key ? `c.query['${key}']` : 'c.query';
         case 'body':
-            return key ? `ctx.body['${key}']` : 'ctx.body';
+            return key ? `c.body['${key}']` : 'c.body';
         case 'headers':
-            return key
-                ? `ctx.headers.get('${key}')`
-                : 'ctx.headers';
+            return key ? `c.headers.get('${key}')` : 'c.headers';
         case 'req':
-            return 'ctx.req';
+            return 'c.req';
         case 'locals':
-            return 'ctx.locals';
-        case 'di':
-            return `resolvers[${index}](ctx)`;
+            return 'c.locals';
         default:
-            return `resolvers[${index}](ctx)`;
+            return 'undefined';
     }
 }
+/**
+ * Compila route handler em função otimizada.
+ *
+ * Estratégias de otimização:
+ * - Inline de acesso a parâmetros
+ * - Bind do handler no compile time
+ * - Código gerado monomórfico
+ * - Sem overhead de resolvers array
+ */
+/**
+ * Compila route handler em função otimizada que retorna Response inline.
+ *
+ * Estratégias de otimização:
+ * - Inline de acesso a parâmetros
+ * - Inline de response building (elimina executeFastPath)
+ * - Bind do handler no compile time
+ * - Código gerado monomórfico
+ * - Headers pré-frozen para otimização V8
+ */
 function compileRouteHandler(instance, methodName, paramInfos) {
     const handler = instance[methodName].bind(instance);
     if (paramInfos.length === 0) {
-        return () => handler();
+        return createInlineResponseHandler(handler, false);
     }
-    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
     const hasDIParam = paramInfos.some((p) => p.type === 'di');
     if (hasDIParam) {
         return createFallbackHandler(handler, paramInfos);
     }
+    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
     const argExpressions = paramInfos.map(buildArgExpression);
+    const argsCode = argExpressions.join(',');
     if (hasBodyParam) {
-        return createAsyncHandler(handler, argExpressions);
+        const code = `return async function(c){
+await c.getBody();
+const r=await h(${argsCode});
+const s=c.getResponseStatus()||200;
+if(typeof r==='string')return new Response(r,{status:s,headers:TH});
+if(r instanceof Response)return r;
+if(r==null)return new Response('',{status:s,headers:TH});
+if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
+if(isBI(r))return new Response(r,{status:s});
+return new Response(JSON.stringify(r),{status:s,headers:JH});
+}`;
+        return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
     }
-    return createSyncHandler(handler, argExpressions);
-}
-function createSyncHandler(handler, argExpressions) {
-    const code = `
-    return function compiledHandler(ctx) {
-      return handler(${argExpressions.join(', ')});
-    }
-  `;
-    return new Function('handler', code)(handler);
-}
-function createAsyncHandler(handler, argExpressions) {
-    const code = `
-    return async function compiledHandler(ctx) {
-      await ctx.getBody();
-      return handler(${argExpressions.join(', ')});
-    }
-  `;
-    return new Function('handler', code)(handler);
+    const code = `return function(c){
+const r=h(${argsCode});
+const s=c.getResponseStatus()||200;
+if(typeof r==='string')return new Response(r,{status:s,headers:TH});
+if(r instanceof Response)return r;
+if(r==null)return new Response('',{status:s,headers:TH});
+if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
+if(isBI(r))return new Response(r,{status:s});
+return new Response(JSON.stringify(r),{status:s,headers:JH});
+}`;
+    return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
 }
+/**
+ * Handler fallback para casos com DI.
+ */
 function createFallbackHandler(handler, paramInfos) {
     return (ctx) => {
-        const args = [];
-        for (const param of paramInfos) {
-            switch (param.type) {
-                case 'param':
-                    args.push(param.key ? ctx.param[param.key] : ctx.param);
-                    break;
-                case 'query':
-                    args.push(param.key ? ctx.query[param.key] : ctx.query);
-                    break;
-                case 'body':
-                    args.push(param.key ? ctx.body[param.key] : ctx.body);
-                    break;
-                case 'headers':
-                    args.push(param.key ? ctx.headers.get(param.key) : ctx.headers);
-                    break;
-                case 'req':
-                    args.push(ctx.req);
-                    break;
-                case 'locals':
-                    args.push(ctx.locals);
-                    break;
-                default:
-                    args.push(undefined);
-                    break;
-            }
-        }
+        const args = resolveArgs(paramInfos, ctx);
         return handler(...args);
     };
 }
-function compileValidatedHandler(instance, methodName, paramInfos, validators) {
+/**
+ * Resolve argumentos para fallback handler.
+ */
+function resolveArgs(paramInfos, ctx) {
+    const args = new Array(paramInfos.length);
+    let i = 0;
+    for (const param of paramInfos) {
+        args[i++] = resolveArg(param, ctx);
+    }
+    return args;
+}
+/**
+ * Resolve um argumento individual.
+ */
+function resolveArg(param, ctx) {
+    switch (param.type) {
+        case 'param':
+            return param.key ? ctx.param[param.key] : ctx.param;
+        case 'query':
+            return param.key ? ctx.query[param.key] : ctx.query;
+        case 'body':
+            return param.key ? ctx.body[param.key] : ctx.body;
+        case 'headers':
+            return param.key ? ctx.headers.get(param.key) : ctx.headers;
+        case 'req':
+            return ctx.req;
+        case 'locals':
+            return ctx.locals;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Compila handler com validação inline.
+ */
+function compileValidatedHandler(instance, methodName, paramInfos, validatorAdapter) {
     const handler = instance[methodName].bind(instance);
     const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-    const resolveArg = (ctx, param, index) => {
-        let value;
-        switch (param.type) {
-            case 'param':
-                value = param.key ? ctx.param[param.key] : ctx.param;
-                break;
-            case 'query':
-                value = param.key ? ctx.query[param.key] : ctx.query;
-                break;
-            case 'body':
-                value = param.key ? ctx.body[param.key] : ctx.body;
-                break;
-            case 'headers':
-                value = param.key ? ctx.headers.get(param.key) : ctx.headers;
-                break;
-            case 'req':
-                value = ctx.req;
-                break;
-            case 'locals':
-                value = ctx.locals;
-                break;
-            default:
-                value = undefined;
-        }
-        if (param.needsValidation && validators[index]) {
-            return validators[index](value);
-        }
-        return value;
-    };
+    if (paramInfos.length === 0) {
+        return createInlineResponseHandler(handler, false);
+    }
+    const { argAssignments, argList, tokenParams, tokenValues, } = buildValidatedArgs(paramInfos);
     if (hasBodyParam) {
-        return async (ctx) => {
-            await ctx.getBody();
-            const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
-            return handler(...args);
-        };
+        const code = `return async function(c){\nawait c.getBody();\n${argAssignments}\nconst r=await h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
+        return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
     }
-    return (ctx) => {
-        const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
-        return handler(...args);
+    const code = `return function(c){\n${argAssignments}\nconst r=h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
+    return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
+}
+function buildValidatedArgs(paramInfos) {
+    const assignments = [];
+    const args = [];
+    const tokenParams = [];
+    const tokenValues = [];
+    let index = 0;
+    for (const param of paramInfos) {
+        const argName = `a${index}`;
+        const argExpr = buildArgExpression(param);
+        const tokenName = getTokenParamName(param, index, tokenParams, tokenValues);
+        const valueExpr = buildValidatedExpression(argExpr, tokenName);
+        assignments.push(`const ${argName}=${valueExpr};`);
+        args.push(argName);
+        index += 1;
+    }
+    return {
+        argAssignments: assignments.join('\n'),
+        argList: args.join(','),
+        tokenParams,
+        tokenValues,
     };
 }
+function buildValidatedExpression(argExpr, tokenName) {
+    if (!tokenName) {
+        return argExpr;
+    }
+    return `va.validateAndTransform(${tokenName}, ${argExpr})`;
+}
+function getTokenParamName(param, index, tokenParams, tokenValues) {
+    if (!param.needsValidation || !param.token) {
+        return null;
+    }
+    const tokenName = `t${index}`;
+    tokenParams.push(tokenName);
+    tokenValues.push(param.token);
+    return tokenName;
+}

package/dist/route/ParamResolverFactory.d.ts

@@ -1,6 +1,4 @@
-import { type ValidatorOptions } from 'class-validator';
 import type { Context } from '../domain/Context';
-import type { ParamResolver, AsyncParamResolver } from './CompiledRoute';
 export type ParamDecoratorType = 'body' | 'query' | 'param' | 'headers' | 'req' | 'locals';
 export interface ParamDecoratorMeta {
     fun: (context: Context, data?: any) => any;
@@ -14,6 +12,3 @@ export interface ParamInfo {
     token?: any;
 }
 export declare function analyzeParamDecorator(decoratorMeta: ParamDecoratorMeta | undefined, token: any): ParamInfo;
-export declare function createParamResolver(decoratorMeta: ParamDecoratorMeta | undefined, token: any, validationConfig?: ValidatorOptions): ParamResolver | AsyncParamResolver | null;
-export declare function createParamResolvers(paramMetas: Record<number, ParamDecoratorMeta> | undefined, argTypes: any[], validationConfig?: ValidatorOptions): (ParamResolver | AsyncParamResolver | null)[];
-export declare function hasAnyDIParam(resolvers: (ParamResolver | AsyncParamResolver | null)[]): boolean;

package/dist/route/ParamResolverFactory.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeParamDecorator = analyzeParamDecorator;
-exports.createParamResolver = createParamResolver;
-exports.createParamResolvers = createParamResolvers;
-exports.hasAnyDIParam = hasAnyDIParam;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
-const HttpException_1 = require("../exceptions/HttpException");
 const ValidationCache_1 = require("../utils/ValidationCache");
 function analyzeParamDecorator(decoratorMeta, token) {
     if (!decoratorMeta) {
@@ -53,37 +47,3 @@ function inferTypeFromSource(resolver) {
     }
     return null;
 }
-function createValidationResolver(extractFn, token, validationConfig) {
-    return (context) => {
-        const value = extractFn(context);
-        const obj = (0, class_transformer_1.plainToInstance)(token, value);
-        const errors = (0, class_validator_1.validateSync)(obj, validationConfig);
-        if (errors.length > 0) {
-            throw new HttpException_1.HttpException(errors, 400);
-        }
-        return obj;
-    };
-}
-function createParamResolver(decoratorMeta, token, validationConfig) {
-    if (!decoratorMeta) {
-        return null;
-    }
-    const extractFn = (context) => decoratorMeta.fun(context, decoratorMeta.param);
-    const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
-    if (needsValidation) {
-        return createValidationResolver(extractFn, token, validationConfig);
-    }
-    return extractFn;
-}
-function createParamResolvers(paramMetas, argTypes, validationConfig) {
-    const resolvers = [];
-    for (let i = 0; i < argTypes.length; i++) {
-        const meta = paramMetas?.[i];
-        const token = argTypes[i];
-        resolvers.push(createParamResolver(meta, token, validationConfig));
-    }
-    return resolvers;
-}
-function hasAnyDIParam(resolvers) {
-    return resolvers.some((r) => r === null);
-}

package/dist/route/RouteCompiler.d.ts

@@ -1,19 +1,19 @@
-import { type ValidatorOptions } from 'class-validator';
 import type { TokenRouteWithProvider } from '../container/ContainerConfiguration';
+import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
 import type { Container } from '../container/container';
 import { ProviderScope } from '../domain/provider-scope';
 import { type CompiledRoute } from './CompiledRoute';
 export interface RouteCompilerOptions {
     container: Container;
     controllerScopes: Map<any, ProviderScope>;
-    validationConfig?: ValidatorOptions;
+    validatorAdapter: ValidatorAdapter;
     hasOnRequestHook: boolean;
     hasOnResponseHook: boolean;
 }
 export declare class RouteCompiler {
     private container;
     private controllerScopes;
-    private validationConfig?;
+    private validatorAdapter;
     private hasOnRequestHook;
     private hasOnResponseHook;
     constructor(options: RouteCompilerOptions);
@@ -25,5 +25,4 @@ export declare class RouteCompiler {
     private createStandardRoute;
     private createComplexRoute;
     private createFallbackRoute;
-    private createValidatedHandler;
 }

package/dist/route/RouteCompiler.js

@@ -1,11 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteCompiler = void 0;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
 const provider_scope_1 = require("../domain/provider-scope");
 const Metadata_1 = require("../domain/Metadata");
-const HttpException_1 = require("../exceptions/HttpException");
 const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
 const CompiledRoute_1 = require("./CompiledRoute");
 const ParamResolverFactory_1 = require("./ParamResolverFactory");
@@ -14,7 +11,7 @@ class RouteCompiler {
     constructor(options) {
         this.container = options.container;
         this.controllerScopes = options.controllerScopes;
-        this.validationConfig = options.validationConfig;
+        this.validatorAdapter = options.validatorAdapter;
         this.hasOnRequestHook = options.hasOnRequestHook;
         this.hasOnResponseHook = options.hasOnResponseHook;
     }
@@ -70,7 +67,7 @@ class RouteCompiler {
         const hasBodyParam = paramInfos.some((p) => p.type === 'body');
         let boundHandler;
         if (hasValidation) {
-            boundHandler = this.createValidatedHandler(instance, route.methodName, paramInfos, hasBodyParam);
+            boundHandler = (0, JITCompiler_1.compileValidatedHandler)(instance, route.methodName, paramInfos, this.validatorAdapter);
         }
         else {
             boundHandler = (0, JITCompiler_1.compileRouteHandler)(instance, route.methodName, paramInfos);
@@ -156,54 +153,5 @@ class RouteCompiler {
             original: route,
         };
     }
-    createValidatedHandler(instance, methodName, paramInfos, hasBodyParam) {
-        const handler = instance[methodName].bind(instance);
-        const config = this.validationConfig;
-        const resolveArg = (ctx, param) => {
-            let value;
-            switch (param.type) {
-                case 'param':
-                    value = param.key ? ctx.param[param.key] : ctx.param;
-                    break;
-                case 'query':
-                    value = param.key ? ctx.query[param.key] : ctx.query;
-                    break;
-                case 'body':
-                    value = param.key ? ctx.body[param.key] : ctx.body;
-                    break;
-                case 'headers':
-                    value = param.key ? ctx.headers.get(param.key) : ctx.headers;
-                    break;
-                case 'req':
-                    value = ctx.req;
-                    break;
-                case 'locals':
-                    value = ctx.locals;
-                    break;
-                default:
-                    value = undefined;
-            }
-            if (param.needsValidation && param.token) {
-                const obj = (0, class_transformer_1.plainToInstance)(param.token, value);
-                const errors = (0, class_validator_1.validateSync)(obj, config);
-                if (errors.length > 0) {
-                    throw new HttpException_1.HttpException(errors, 400);
-                }
-                return obj;
-            }
-            return value;
-        };
-        if (hasBodyParam) {
-            return async (ctx) => {
-                await ctx.getBody();
-                const args = paramInfos.map((p) => resolveArg(ctx, p));
-                return handler(...args);
-            };
-        }
-        return (ctx) => {
-            const args = paramInfos.map((p) => resolveArg(ctx, p));
-            return handler(...args);
-        };
-    }
 }
 exports.RouteCompiler = RouteCompiler;

package/dist/route/RouteExecutor.js

@@ -24,7 +24,24 @@ class Router {
         if (injector.hasOnResponseHook()) {
             await injector.callHook(events_1.EventType.OnResponse, { context, result });
         }
-        return this.mountResponse(result, context);
+        const status = context.getResponseStatus() || 200;
+        if (result instanceof Response) {
+            return result;
+        }
+        if (result === null || result === undefined) {
+            return new Response("", { status, headers: this.textHeaders });
+        }
+        const resultType = typeof result;
+        if (resultType === "string") {
+            return new Response(result, { status, headers: this.textHeaders });
+        }
+        if (resultType === "number" || resultType === "boolean") {
+            return new Response(String(result), { status, headers: this.textHeaders });
+        }
+        if (this.isBodyInit(result)) {
+            return new Response(result, { status });
+        }
+        return this.createJsonResponse(result, status);
     }
     mountResponse(result, context) {
         const status = context.getResponseStatus() || 200;

package/dist/route/memoirist.d.ts

@@ -18,10 +18,13 @@ export interface Node<T> {
 export declare class Memoirist<T> {
     root: Record<string, Node<T>>;
     history: [string, string, T][];
+    private routeCache;
     private static regex;
     add(method: string, path: string, store: T): FindResult<T>['store'];
     find(method: string, url: string): FindResult<T> | null;
     updateStore(method: string, path: string, oldStore: T, newStore: T): boolean;
+    private buildCacheKey;
+    private invalidateCache;
     private updateHistoryStore;
     private normalizePath;
     private findNode;

package/dist/route/memoirist.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Memoirist = void 0;
+/**
+ * * Empty object shared for static routes without parameters.
+ * * Frozen for V8 optimization and immutability.
+ * * Avoid allocating an empty object on every request in static routes.
+ * */
+const EMPTY_PARAMS = Object.freeze({});
 const createNode = (part, inert) => ({
     part,
     store: null,
@@ -54,6 +60,7 @@ class Memoirist {
     constructor() {
         this.root = {};
         this.history = [];
+        this.routeCache = new Map();
     }
     add(method, path, store) {
         if (typeof path !== 'string')
@@ -62,6 +69,7 @@ class Memoirist {
             path = '/';
         else if (path[0] !== '/')
             path = `/${path}`;
+        this.invalidateCache();
         this.history.push([method, path, store]);
         const isWildcard = path[path.length - 1] === '*';
         if (isWildcard) {
@@ -162,10 +170,16 @@ class Memoirist {
         return node.store;
     }
     find(method, url) {
+        const cacheKey = this.buildCacheKey(method, url);
+        if (this.routeCache.has(cacheKey)) {
+            return this.routeCache.get(cacheKey);
+        }
         const root = this.root[method];
         if (!root)
             return null;
-        return matchRoute(url, url.length, root, 0);
+        const result = matchRoute(url, url.length, root, 0);
+        this.routeCache.set(cacheKey, result);
+        return result;
     }
     updateStore(method, path, oldStore, newStore) {
         const node = this.findNode(method, path);
@@ -175,6 +189,7 @@ class Memoirist {
         if (node.store === oldStore) {
             node.store = newStore;
             this.updateHistoryStore(method, path, newStore);
+            this.invalidateCache();
             return true;
         }
         if (node.params?.store === oldStore) {
@@ -184,15 +199,24 @@ class Memoirist {
                 node.params.names.set(newStore, paramName);
             }
             this.updateHistoryStore(method, path, newStore);
+            this.invalidateCache();
             return true;
         }
         if (node.wildcardStore === oldStore) {
             node.wildcardStore = newStore;
             this.updateHistoryStore(method, path, newStore);
+            this.invalidateCache();
             return true;
         }
         return false;
     }
+    buildCacheKey(method, url) {
+        const normalizedMethod = method.toLowerCase();
+        return `${normalizedMethod}:${url}`;
+    }
+    invalidateCache() {
+        this.routeCache.clear();
+    }
     updateHistoryStore(method, path, newStore) {
         const normalizedPath = this.normalizePath(path);
         for (let i = 0; i < this.history.length; i++) {
@@ -288,7 +312,7 @@ const matchRoute = (url, urlLength, node, startIndex) => {
         if (node.store !== null)
             return {
                 store: node.store,
-                params: {}
+                params: EMPTY_PARAMS
             };
         if (node.wildcardStore !== null)
             return {
@@ -325,7 +349,13 @@ const matchRoute = (url, urlLength, node, startIndex) => {
                 const route = matchRoute(url, urlLength, param.inert, slashIndex);
                 if (route !== null) {
                     const paramName = resolveParamName(param, route.store);
-                    route.params[paramName] = url.substring(endIndex, slashIndex);
+                    const paramValue = url.substring(endIndex, slashIndex);
+                    if (route.params === EMPTY_PARAMS) {
+                        route.params = { [paramName]: paramValue };
+                    }
+                    else {
+                        route.params[paramName] = paramValue;
+                    }
                     return route;
                 }
             }

package/dist/utils/ValidationCache.d.ts

@@ -1,3 +1,5 @@
+import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
+export declare function setValidatorAdapter(adapter: ValidatorAdapter): void;
 export declare function isValidatable(token: Function): boolean;
 export declare function preloadValidationForParams(args: any[]): number[];
 export declare function clearValidationCache(): void;