@carno.js/core 1.0.2 → 1.0.3

package/src/metadata.ts

@@ -1,46 +1,46 @@
-import { Scope } from './container/Container';
-
-/**
- * Controller options for the @Controller decorator.
- */
-export interface ControllerOptions {
-    path?: string;
-    scope?: Scope;
-    children?: any[];
-}
-
-/**
- * Controller metadata stored on controller classes.
- */
-export interface ControllerMeta {
-    path: string;
-    scope?: Scope;
-    children?: any[];
-}
-
-/**
- * Route metadata stored on controllers.
- */
-export interface RouteInfo {
-    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
-    path: string;
-    handlerName: string;
-}
-
-/**
- * Middleware metadata.
- */
-export interface MiddlewareInfo {
-    handler: Function;
-    target?: string;
-}
-
-/**
- * Metadata keys.
- */
-export const CONTROLLER_META = Symbol('turbo:controller');
-export const ROUTES_META = Symbol('turbo:routes');
-export const PARAMS_META = Symbol('turbo:params');
-export const MIDDLEWARE_META = Symbol('turbo:middleware');
-export const SERVICE_META = Symbol('turbo:service');
-export const INJECT_META = Symbol('turbo:inject');
+import { Scope } from './container/Container';
+
+/**
+ * Controller options for the @Controller decorator.
+ */
+export interface ControllerOptions {
+    path?: string;
+    scope?: Scope;
+    children?: any[];
+}
+
+/**
+ * Controller metadata stored on controller classes.
+ */
+export interface ControllerMeta {
+    path: string;
+    scope?: Scope;
+    children?: any[];
+}
+
+/**
+ * Route metadata stored on controllers.
+ */
+export interface RouteInfo {
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
+    path: string;
+    handlerName: string;
+}
+
+/**
+ * Middleware metadata.
+ */
+export interface MiddlewareInfo {
+    handler: Function;
+    target?: string;
+}
+
+/**
+ * Metadata keys.
+ */
+export const CONTROLLER_META = Symbol('turbo:controller');
+export const ROUTES_META = Symbol('turbo:routes');
+export const PARAMS_META = Symbol('turbo:params');
+export const MIDDLEWARE_META = Symbol('turbo:middleware');
+export const SERVICE_META = Symbol('turbo:service');
+export const INJECT_META = Symbol('turbo:inject');

package/src/middleware/CarnoMiddleware.ts

@@ -1,14 +1,14 @@
-import type { Context } from '../context/Context';
-
-/**
- * Closure function to call the next middleware in the chain.
- */
-export type CarnoClosure = () => void | Promise<void>;
-
-/**
- * Interface for onion-style middleware.
- * Middleware must call next() to continue the chain.
- */
-export interface CarnoMiddleware {
-  handle(ctx: Context, next: CarnoClosure): void | Promise<void>;
-}
+import type { Context } from '../context/Context';
+
+/**
+ * Closure function to call the next middleware in the chain.
+ */
+export type CarnoClosure = () => void | Promise<void>;
+
+/**
+ * Interface for onion-style middleware.
+ * Middleware must call next() to continue the chain.
+ */
+export interface CarnoMiddleware {
+  handle(ctx: Context, next: CarnoClosure): void | Promise<void>;
+}

package/src/router/RadixRouter.ts

@@ -1,225 +1,225 @@
-/**
- * Ultra-fast Radix Router for Turbo.
- * 
- * Optimizations:
- * - Char code comparisons (no string allocations)
- * - Frozen empty params object
- * - O(1) method lookup via char code index
- * - Minimal allocations in hot path
- */
-
-const EMPTY_PARAMS: Readonly<Record<string, string>> = Object.freeze({});
-
-interface Node<T> {
-    part: string;
-    store: T | null;
-    children: Map<number, Node<T>> | null;
-    paramChild: ParamNode<T> | null;
-    wildcardStore: T | null;
-}
-
-interface ParamNode<T> {
-    name: string;
-    store: T | null;
-    child: Node<T> | null;
-}
-
-export interface RouteMatch<T> {
-    store: T;
-    params: Record<string, string>;
-}
-
-function createNode<T>(part: string): Node<T> {
-    return {
-        part,
-        store: null,
-        children: null,
-        paramChild: null,
-        wildcardStore: null
-    };
-}
-
-export class RadixRouter<T> {
-    private roots: Record<string, Node<T>> = {};
-
-    add(method: string, path: string, store: T): void {
-        if (path === '') path = '/';
-        if (path[0] !== '/') path = '/' + path;
-
-        const isWildcard = path.endsWith('*');
-
-        if (isWildcard) path = path.slice(0, -1);
-
-        let node = this.roots[method];
-
-        if (!node) {
-            node = this.roots[method] = createNode('/');
-        }
-
-        let i = 0;
-        const len = path.length;
-
-        while (i < len) {
-            const char = path.charCodeAt(i);
-
-            if (char === 58) {
-                const paramStart = i + 1;
-                let paramEnd = paramStart;
-
-                while (paramEnd < len && path.charCodeAt(paramEnd) !== 47) {
-                    paramEnd++;
-                }
-
-                const paramName = path.slice(paramStart, paramEnd);
-
-                if (!node.paramChild) {
-                    node.paramChild = { name: paramName, store: null, child: null };
-                }
-
-                if (paramEnd >= len) {
-                    node.paramChild.store = store;
-                    return;
-                }
-
-                if (!node.paramChild.child) {
-                    node.paramChild.child = createNode(path.slice(paramEnd));
-                }
-
-                node = node.paramChild.child;
-                i = paramEnd;
-                continue;
-            }
-
-            let segmentEnd = i;
-
-            while (segmentEnd < len && path.charCodeAt(segmentEnd) !== 47 && path.charCodeAt(segmentEnd) !== 58) {
-                segmentEnd++;
-            }
-
-            if (segmentEnd < len && path.charCodeAt(segmentEnd) === 47) {
-                segmentEnd++;
-            }
-
-            const segment = path.slice(i, segmentEnd);
-
-            if (segment === node.part) {
-                i = segmentEnd;
-                continue;
-            }
-
-            if (!node.children) {
-                node.children = new Map();
-            }
-
-            const firstChar = segment.charCodeAt(0);
-            let child = node.children.get(firstChar);
-
-            if (!child) {
-                child = createNode(segment);
-                node.children.set(firstChar, child);
-            }
-
-            node = child;
-            i = segmentEnd;
-        }
-
-        if (isWildcard) {
-            node.wildcardStore = store;
-        } else {
-            node.store = store;
-        }
-    }
-
-    find(method: string, path: string): RouteMatch<T> | null {
-        const root = this.roots[method];
-
-        if (!root) return null;
-
-        return this.matchPath(root, path, 0, path.length);
-    }
-
-    private matchPath(
-        node: Node<T>,
-        path: string,
-        start: number,
-        len: number
-    ): RouteMatch<T> | null {
-        const partLen = node.part.length;
-        const end = start + partLen;
-
-        if (partLen > 1) {
-            if (end > len) return null;
-
-            for (let i = 1, j = start + 1; i < partLen; i++, j++) {
-                if (node.part.charCodeAt(i) !== path.charCodeAt(j)) {
-                    return null;
-                }
-            }
-        }
-
-        if (end === len) {
-            if (node.store !== null) {
-                return { store: node.store, params: EMPTY_PARAMS };
-            }
-
-            if (node.wildcardStore !== null) {
-                return { store: node.wildcardStore, params: { '*': '' } };
-            }
-
-            return null;
-        }
-
-        if (node.children) {
-            const child = node.children.get(path.charCodeAt(end));
-
-            if (child) {
-                const result = this.matchPath(child, path, end, len);
-
-                if (result) return result;
-            }
-        }
-
-        if (node.paramChild) {
-            const param = node.paramChild;
-            let paramEnd = end;
-
-            while (paramEnd < len && path.charCodeAt(paramEnd) !== 47) {
-                paramEnd++;
-            }
-
-            if (paramEnd === end) return null;
-
-            const paramValue = path.slice(end, paramEnd);
-
-            if (paramEnd >= len) {
-                if (param.store !== null) {
-                    return {
-                        store: param.store,
-                        params: { [param.name]: paramValue }
-                    };
-                }
-            } else if (param.child) {
-                const result = this.matchPath(param.child, path, paramEnd, len);
-
-                if (result) {
-                    if (result.params === EMPTY_PARAMS) {
-                        result.params = { [param.name]: paramValue };
-                    } else {
-                        result.params[param.name] = paramValue;
-                    }
-
-                    return result;
-                }
-            }
-        }
-
-        if (node.wildcardStore !== null) {
-            return {
-                store: node.wildcardStore,
-                params: { '*': path.slice(end) }
-            };
-        }
-
-        return null;
-    }
-}
+/**
+ * Ultra-fast Radix Router for Turbo.
+ * 
+ * Optimizations:
+ * - Char code comparisons (no string allocations)
+ * - Frozen empty params object
+ * - O(1) method lookup via char code index
+ * - Minimal allocations in hot path
+ */
+
+const EMPTY_PARAMS: Readonly<Record<string, string>> = Object.freeze({});
+
+interface Node<T> {
+    part: string;
+    store: T | null;
+    children: Map<number, Node<T>> | null;
+    paramChild: ParamNode<T> | null;
+    wildcardStore: T | null;
+}
+
+interface ParamNode<T> {
+    name: string;
+    store: T | null;
+    child: Node<T> | null;
+}
+
+export interface RouteMatch<T> {
+    store: T;
+    params: Record<string, string>;
+}
+
+function createNode<T>(part: string): Node<T> {
+    return {
+        part,
+        store: null,
+        children: null,
+        paramChild: null,
+        wildcardStore: null
+    };
+}
+
+export class RadixRouter<T> {
+    private roots: Record<string, Node<T>> = {};
+
+    add(method: string, path: string, store: T): void {
+        if (path === '') path = '/';
+        if (path[0] !== '/') path = '/' + path;
+
+        const isWildcard = path.endsWith('*');
+
+        if (isWildcard) path = path.slice(0, -1);
+
+        let node = this.roots[method];
+
+        if (!node) {
+            node = this.roots[method] = createNode('/');
+        }
+
+        let i = 0;
+        const len = path.length;
+
+        while (i < len) {
+            const char = path.charCodeAt(i);
+
+            if (char === 58) {
+                const paramStart = i + 1;
+                let paramEnd = paramStart;
+
+                while (paramEnd < len && path.charCodeAt(paramEnd) !== 47) {
+                    paramEnd++;
+                }
+
+                const paramName = path.slice(paramStart, paramEnd);
+
+                if (!node.paramChild) {
+                    node.paramChild = { name: paramName, store: null, child: null };
+                }
+
+                if (paramEnd >= len) {
+                    node.paramChild.store = store;
+                    return;
+                }
+
+                if (!node.paramChild.child) {
+                    node.paramChild.child = createNode(path.slice(paramEnd));
+                }
+
+                node = node.paramChild.child;
+                i = paramEnd;
+                continue;
+            }
+
+            let segmentEnd = i;
+
+            while (segmentEnd < len && path.charCodeAt(segmentEnd) !== 47 && path.charCodeAt(segmentEnd) !== 58) {
+                segmentEnd++;
+            }
+
+            if (segmentEnd < len && path.charCodeAt(segmentEnd) === 47) {
+                segmentEnd++;
+            }
+
+            const segment = path.slice(i, segmentEnd);
+
+            if (segment === node.part) {
+                i = segmentEnd;
+                continue;
+            }
+
+            if (!node.children) {
+                node.children = new Map();
+            }
+
+            const firstChar = segment.charCodeAt(0);
+            let child = node.children.get(firstChar);
+
+            if (!child) {
+                child = createNode(segment);
+                node.children.set(firstChar, child);
+            }
+
+            node = child;
+            i = segmentEnd;
+        }
+
+        if (isWildcard) {
+            node.wildcardStore = store;
+        } else {
+            node.store = store;
+        }
+    }
+
+    find(method: string, path: string): RouteMatch<T> | null {
+        const root = this.roots[method];
+
+        if (!root) return null;
+
+        return this.matchPath(root, path, 0, path.length);
+    }
+
+    private matchPath(
+        node: Node<T>,
+        path: string,
+        start: number,
+        len: number
+    ): RouteMatch<T> | null {
+        const partLen = node.part.length;
+        const end = start + partLen;
+
+        if (partLen > 1) {
+            if (end > len) return null;
+
+            for (let i = 1, j = start + 1; i < partLen; i++, j++) {
+                if (node.part.charCodeAt(i) !== path.charCodeAt(j)) {
+                    return null;
+                }
+            }
+        }
+
+        if (end === len) {
+            if (node.store !== null) {
+                return { store: node.store, params: EMPTY_PARAMS };
+            }
+
+            if (node.wildcardStore !== null) {
+                return { store: node.wildcardStore, params: { '*': '' } };
+            }
+
+            return null;
+        }
+
+        if (node.children) {
+            const child = node.children.get(path.charCodeAt(end));
+
+            if (child) {
+                const result = this.matchPath(child, path, end, len);
+
+                if (result) return result;
+            }
+        }
+
+        if (node.paramChild) {
+            const param = node.paramChild;
+            let paramEnd = end;
+
+            while (paramEnd < len && path.charCodeAt(paramEnd) !== 47) {
+                paramEnd++;
+            }
+
+            if (paramEnd === end) return null;
+
+            const paramValue = path.slice(end, paramEnd);
+
+            if (paramEnd >= len) {
+                if (param.store !== null) {
+                    return {
+                        store: param.store,
+                        params: { [param.name]: paramValue }
+                    };
+                }
+            } else if (param.child) {
+                const result = this.matchPath(param.child, path, paramEnd, len);
+
+                if (result) {
+                    if (result.params === EMPTY_PARAMS) {
+                        result.params = { [param.name]: paramValue };
+                    } else {
+                        result.params[param.name] = paramValue;
+                    }
+
+                    return result;
+                }
+            }
+        }
+
+        if (node.wildcardStore !== null) {
+            return {
+                store: node.wildcardStore,
+                params: { '*': path.slice(end) }
+            };
+        }
+
+        return null;
+    }
+}