solidstep 0.3.0 → 0.3.1

package/package.json

@@ -1,70 +1,70 @@
-{
-    "name": "solidstep",
-    "version": "0.3.0",
-    "description": "Next Step SolidJS Framework for building web applications.",
-    "type": "module",
-    "author": "HamzaKV <hamzakv333@gmail.com>",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/HamzaKV/solidstep.git"
-    },
-    "license": "MIT",
-    "exports": {
-        ".": "./index.js",
-        "./hooks/action-state": "./utils/hooks/action-state.js",
-        "./utils/cache": "./utils/cache.js",
-        "./utils/cookies": "./utils/cookies.js",
-        "./utils/cors": "./utils/cors.js",
-        "./utils/csp": "./utils/csp.js",
-        "./utils/csrf": "./utils/csrf.js",
-        "./utils/error-handler": "./utils/error-handler.js",
-        "./utils/fetch.client": "./utils/fetch.client.js",
-        "./utils/fetch.server": "./utils/fetch.server.js",
-        "./utils/loader": "./utils/loader.js",
-        "./utils/logger": "./utils/logger.js",
-        "./utils/meta": "./utils/meta.js",
-        "./utils/redirect": "./utils/redirect.js",
-        "./utils/server-only": "./utils/server-only.js"
-    },
-    "scripts": {
-        "clean": "rimraf ./dist",
-        "copy-files:root": "copyfiles -u 0 README.md package.json generate/**/* LICENSE ./dist",
-        "build": "pnpm clean && tsc && pnpm copy-files:root",
-        "test:local": "pnpm build && cd ./dist && pnpm link --global",
-        "test:local:clean": "pnpm unlink && pnpm clean",
-        "roll": "pnpm build && cd dist && npm publish"
-    },
-    "keywords": [
-        "solidjs",
-        "web-development",
-        "typescript",
-        "npm",
-        "solidstep",
-        "framework"
-    ],
-    "dependencies": {
-        "@vinxi/server-functions": "0.5.1",
-        "pino": "^10.1.0",
-        "seroval": "^1.3.2",
-        "seroval-plugins": "^1.3.2",
-        "undici": "^7.15.0",
-        "vite-plugin-solid": "^2.11.7"
-    },
-    "devDependencies": {
-        "copyfiles": "^2.4.1",
-        "rimraf": "^6.0.1",
-        "solid-js": "^1.9.7",
-        "typescript": "^5.8.3",
-        "vinxi": "^0.5.8"
-    },
-    "peerDependencies": {
-        "solid-js": "^1.9.7",
-        "vinxi": "^0.5.8"
-    },
-    "engines": {
-        "node": ">=20"
-    },
-    "publishConfig": {
-        "access": "public"
-    }
-}
+{
+    "name": "solidstep",
+    "version": "0.3.1",
+    "description": "Next Step SolidJS Framework for building web applications.",
+    "type": "module",
+    "author": "HamzaKV <hamzakv333@gmail.com>",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/HamzaKV/solidstep.git"
+    },
+    "license": "MIT",
+    "exports": {
+        ".": "./index.js",
+        "./hooks/action-state": "./utils/hooks/action-state.js",
+        "./utils/cache": "./utils/cache.js",
+        "./utils/cookies": "./utils/cookies.js",
+        "./utils/cors": "./utils/cors.js",
+        "./utils/csp": "./utils/csp.js",
+        "./utils/csrf": "./utils/csrf.js",
+        "./utils/error-handler": "./utils/error-handler.js",
+        "./utils/fetch.client": "./utils/fetch.client.js",
+        "./utils/fetch.server": "./utils/fetch.server.js",
+        "./utils/loader": "./utils/loader.js",
+        "./utils/logger": "./utils/logger.js",
+        "./utils/meta": "./utils/meta.js",
+        "./utils/redirect": "./utils/redirect.js",
+        "./utils/server-only": "./utils/server-only.js"
+    },
+    "scripts": {
+        "clean": "rimraf ./dist",
+        "copy-files:root": "copyfiles -u 0 README.md package.json generate/**/* LICENSE ./dist",
+        "build": "pnpm clean && tsc && pnpm copy-files:root",
+        "test:local": "pnpm build && cd ./dist && pnpm link --global",
+        "test:local:clean": "pnpm unlink && pnpm clean",
+        "roll": "pnpm build && cd dist && npm publish"
+    },
+    "keywords": [
+        "solidjs",
+        "web-development",
+        "typescript",
+        "npm",
+        "solidstep",
+        "framework"
+    ],
+    "dependencies": {
+        "@vinxi/server-functions": "0.5.1",
+        "pino": "^10.1.0",
+        "seroval": "^1.3.2",
+        "seroval-plugins": "^1.3.2",
+        "undici": "^7.15.0",
+        "vite-plugin-solid": "^2.11.7"
+    },
+    "devDependencies": {
+        "copyfiles": "^2.4.1",
+        "rimraf": "^6.0.1",
+        "solid-js": "^1.9.7",
+        "typescript": "^5.8.3",
+        "vinxi": "^0.5.8"
+    },
+    "peerDependencies": {
+        "solid-js": "^1.9.7",
+        "vinxi": "^0.5.8"
+    },
+    "engines": {
+        "node": ">=20"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"AA4kBA,QAAA,MAAM,OAAO,2FA0XX,CAAC;AAEH,eAAe,OAAO,CAAC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"AAkfA,QAAA,MAAM,OAAO,2FAmXX,CAAC;AAEH,eAAe,OAAO,CAAC"}

package/server.js

@@ -1,4 +1,4 @@
-import { eventHandler, toWebRequest, setHeader, setResponseStatus } from 'vinxi/http';
+import { eventHandler, toWebRequest, setHeader, setResponseStatus, } from 'vinxi/http';
 import { getManifest } from 'vinxi/manifest';
 import { generateHydrationScript, renderToString } from 'solid-js/web';
 import fileRoutes, {} from 'vinxi/routes';
@@ -8,52 +8,31 @@ import { handleServerFunction } from './utils/server-action.server';
 import { readFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { createNode, insertRoute, matchRoute, } from './utils/path-router';
+// Module cache for dynamically imported modules
+const moduleCache = new Map();
+const getCachedModule = async (importFn) => {
+    const key = importFn.src;
+    if (moduleCache.has(key)) {
+        return moduleCache.get(key);
+    }
+    const module = await importFn.import();
+    moduleCache.set(key, module);
+    return module;
+};
 const isPageFile = (file) => file.endsWith('page.tsx') ||
     file.endsWith('page.jsx') ||
     file.endsWith('page.ts') ||
     file.endsWith('page.js');
 const isRouteFile = (file) => file.endsWith('route.ts') || file.endsWith('route.js');
-const parseSegment = (part) => {
-    if (part.startsWith('[[') && part.endsWith(']]')) {
-        return `:^*${part.slice(5, -2)}`;
-    }
-    return part.startsWith('[')
-        ? `:${part.slice(1, -1).replace(/\.\.\./, '*')}`
-        : part;
-};
-const createMatcher = (routePath) => {
-    const keys = [];
-    const segments = routePath.split('/').map((part) => {
-        if (part.startsWith(':')) {
-            if (part.startsWith(':^*')) {
-                // Catch-all inclusive
-                keys.push(part.slice(3));
-                return '?(.*)?';
-            }
-            if (part.startsWith(':*')) {
-                // Catch-all
-                keys.push(part.slice(2));
-                return '.*';
-            }
-            // Standard param
-            keys.push(part.slice(1));
-            return '([^/]+)';
-        }
-        return part;
-    });
-    return {
-        regex: new RegExp(`^${segments.join('/')}$`),
-        keys,
-    };
-};
 const getNormalizedPath = (path, clean) => {
-    const segments = path.split('/').slice(2).map(parseSegment);
+    const segments = path.split('/').slice(2);
     if (clean)
         return `/${segments.filter((s) => !s.startsWith('(')).join('/')}`;
     return `/${segments.join('/')}`;
 };
 const createRouteManifest = async () => {
-    const entries = {};
+    const rootNode = createNode();
     const allRoutes = [];
     const layoutsMap = new Map();
     const loadingPagesMap = new Map();
@@ -102,7 +81,6 @@ const createRouteManifest = async () => {
                     const groupName = group.path
                         .split('/')
                         .filter((s) => !s.startsWith('('))
-                        .map(parseSegment)
                         .at(-1);
                     if (!groupName)
                         continue;
@@ -134,11 +112,8 @@ const createRouteManifest = async () => {
                     });
                 }
             }
-            const { regex: matcherRegex, keys } = createMatcher(routePath);
-            entries[routePath] = {
+            const entry = {
                 type: 'page',
-                regex: matcherRegex,
-                paramKeys: keys,
                 mainPage: {
                     manifestPath: fileRoute.path,
                     page: fileRoute.$component,
@@ -170,47 +145,19 @@ const createRouteManifest = async () => {
                 layouts: layouts,
                 groups: groups,
             };
+            insertRoute(rootNode, routePath, entry);
         }
         else if (src && isRouteFile(src)) {
-            const { regex: matcherRegex, keys } = createMatcher(routePath);
-            entries[routePath] = {
+            const entry = {
                 type: 'route',
-                regex: matcherRegex,
-                paramKeys: keys,
+                routePath,
                 handler: fileRoute.$handler,
                 manifestPath: fileRoute.path,
             };
+            insertRoute(rootNode, routePath, entry);
         }
     }
-    return entries;
-};
-const extractRouteParams = (route, url) => {
-    const routeSegments = route.split('/').filter(s => !(s.startsWith('('))).filter(Boolean);
-    const urlSegments = url.split('/').filter(Boolean);
-    const params = {};
-    let matched = true;
-    for (let i = 0; i < routeSegments.length; i++) {
-        const routeSeg = routeSegments[i];
-        const urlSeg = urlSegments[i];
-        const isDynamic = routeSeg.startsWith('[') && routeSeg.endsWith(']');
-        if (isDynamic) {
-            if (routeSeg.includes('...')) {
-                // Catch-all parameter
-                const isCatchAll = routeSeg.startsWith('[[') && routeSeg.endsWith(']]');
-                const paramName = routeSeg.slice(isCatchAll ? 5 : 4, isCatchAll ? -2 : -1);
-                params[paramName] = urlSegments.slice(i);
-                break; // No more segments to match
-            }
-            const paramName = routeSeg.slice(1, -1);
-            params[paramName] = urlSeg;
-        }
-        else if (routeSeg !== urlSeg) {
-            matched = false;
-            break;
-        }
-    }
-    if (matched)
-        return { route, params };
+    return rootNode;
 };
 const template = `
     <!DOCTYPE html>
@@ -244,7 +191,7 @@ const generateHtmlHead = (meta) => {
         .join('\n');
     return head;
 };
-const render = async ({ toRender, entry, routeParams, searchParams, req, pageOptions, cspNonce, error }) => {
+const render = async ({ toRender, entry, routeParams, searchParams, req, pageOptions, cspNonce, error, }) => {
     const url = new URL(req.url);
     const path = url.pathname;
     const cachedEntry = getCache(path);
@@ -264,12 +211,12 @@ const render = async ({ toRender, entry, routeParams, searchParams, req, pageOpt
         const moduleSrc = `${layout.layout.src}&pick=$css`;
         const moduleAssets = await clientManifest.inputs[moduleSrc].assets();
         assets.push(...moduleAssets);
-        const { default: layoutModule } = await layout.layout.import();
+        const { default: layoutModule } = await getCachedModule(layout.layout);
         const { loader: layoutLoader } = layout.loader
-            ? await layout.loader.import()
+            ? await getCachedModule(layout.loader)
             : { loader: null };
         const { generateMeta: generateMetaPage } = layout.generateMeta
-            ? await layout.generateMeta.import()
+            ? await getCachedModule(layout.generateMeta)
             : { generateMeta: null };
         let data = {};
         if (generateMetaPage) {
@@ -299,9 +246,9 @@ const render = async ({ toRender, entry, routeParams, searchParams, req, pageOpt
                     const moduleSrc = `${group.page.src}&pick=$css`;
                     const moduleAssets = await clientManifest.inputs[moduleSrc].assets();
                     assets.push(...moduleAssets);
-                    const { default: groupPage } = await group.page.import();
+                    const { default: groupPage } = await getCachedModule(group.page);
                     const { loader: groupLoader } = group.loader
-                        ? await group.loader.import()
+                        ? await getCachedModule(group.loader)
                         : { loader: null };
                     let data = {};
                     if (groupLoader) {
@@ -339,12 +286,12 @@ const render = async ({ toRender, entry, routeParams, searchParams, req, pageOpt
         const moduleSrc = `${pageToRender.page.src}&pick=$css`;
         const moduleAssets = await clientManifest.inputs[moduleSrc].assets();
         assets.push(...moduleAssets);
-        const { default: page } = await pageToRender.page.import();
+        const { default: page } = await getCachedModule(pageToRender.page);
         const { loader: pageLoader } = pageToRender.loader
-            ? await pageToRender.loader.import()
+            ? await getCachedModule(pageToRender.loader)
             : { loader: null };
         const { generateMeta } = pageToRender.generateMeta
-            ? await pageToRender.generateMeta.import()
+            ? await getCachedModule(pageToRender.generateMeta)
             : { generateMeta: null };
         let data = {};
         if (pageLoader) {
@@ -395,7 +342,7 @@ const render = async ({ toRender, entry, routeParams, searchParams, req, pageOpt
         loaderData: loaderData,
     };
 };
-let routeManifest = {};
+let routeManifest = null;
 const hydrationScript = ({ nonce, }) => {
     const script = generateHydrationScript();
     return nonce
@@ -418,46 +365,25 @@ const onStart = async () => {
     }
 };
 onStart();
+const clientManifest = getManifest('client');
 const handler = eventHandler(async (event) => {
     const req = toWebRequest(event);
     try {
         if (req.url?.includes('_server')) {
             return handleServerFunction(event);
         }
-        const clientManifest = getManifest('client');
-        if (!routeManifest || Object.keys(routeManifest).length === 0) {
+        if (!routeManifest) {
             routeManifest = await createRouteManifest();
         }
         const cspNonce = event.locals?.cspNonce;
-        const url = new URL(req.url).pathname;
-        // extract route params and search params
-        let params = {};
-        const searchParams = {};
-        const [pathnamePart, searchParamPart] = url.split('?');
-        if (searchParamPart) {
-            for (const param of searchParamPart.split('&')) {
-                const [key, value] = param.split('=');
-                searchParams[key] = decodeURIComponent(value || '');
-            }
-        }
-        let matched;
-        for (const entry of Object.values(routeManifest)) {
-            const match = entry.regex.exec(pathnamePart);
-            if (match) {
-                matched = entry;
-                if (entry.paramKeys) {
-                    const routePath = matched && matched.type === 'route'
-                        ? matched.manifestPath.split('/').slice(2).join('/')
-                        : matched && matched.type === 'page'
-                            ? matched.mainPage.manifestPath.split('/').slice(2).join('/')
-                            : '/';
-                    params = extractRouteParams(routePath, pathnamePart)?.params || {};
-                }
-                break;
-            }
-        }
+        const urlObj = new URL(req.url);
+        const pathnamePart = urlObj.pathname;
+        const searchParams = Object.fromEntries(urlObj.searchParams);
+        const match = matchRoute(routeManifest, pathnamePart);
+        const matched = match?.handler;
+        const params = match?.params || {};
         if (matched && matched.type === 'route') {
-            const routeModule = await matched.handler.import();
+            const routeModule = await getCachedModule(matched.handler);
             const reqMethod = req.method?.toUpperCase();
             if (reqMethod) {
                 const handler = routeModule[reqMethod];
@@ -514,10 +440,14 @@ const handler = eventHandler(async (event) => {
                 try {
                     if (!matched) {
                         try {
-                            const notFoundPage = routeManifest['/'];
+                            const match = matchRoute(routeManifest, '/');
+                            const notFoundEntry = match.handler;
+                            if (!notFoundEntry) {
+                                throw new Error('No not-found page configured');
+                            }
                             const { rendered, documentMeta, documentAssets, loaderData, } = await render({
                                 toRender: 'not-found',
-                                entry: notFoundPage,
+                                entry: notFoundEntry,
                                 routeParams: {},
                                 searchParams: {},
                                 req: req,
@@ -547,8 +477,10 @@ const handler = eventHandler(async (event) => {
                         }
                     }
                     else {
-                        const { options } = matched.mainPage.options
-                            ? await matched.mainPage.options.import()
+                        const { options } = matched
+                            .mainPage.options
+                            ? await getCachedModule(matched.mainPage
+                                .options)
                             : { options: {} };
                         if (options?.responseHeaders) {
                             const headers = options.responseHeaders;
@@ -651,7 +583,8 @@ const handler = eventHandler(async (event) => {
                         console.error(e1);
                     }
                     try {
-                        const errorPage = matched.errorPage;
+                        const errorPage = matched
+                            .errorPage;
                         if (!errorPage) {
                             throw e1;
                         }
@@ -663,7 +596,7 @@ const handler = eventHandler(async (event) => {
                             req: req,
                             pageOptions: {},
                             cspNonce,
-                            error: e1
+                            error: e1,
                         });
                         assets.push(...documentAssets);
                         clientHydrationScript = `

package/utils/cache.js

@@ -39,7 +39,7 @@ export const getCache = (key) => {
     const entry = cacheMap.get(key);
     if (!entry || !entry.expiresAt)
         return null;
-    if (entry.expiresAt && entry.expiresAt < Date.now()) {
+    if (entry.expiresAt && entry.expiresAt < performance.now()) {
         cacheMap.delete(key);
         if (entry.prev)
             entry.prev.next = entry.next;
@@ -58,14 +58,14 @@ export const setCache = (key, value, ttlMs) => {
     if (cacheMap.has(key)) {
         const node = cacheMap.get(key);
         node.value = value;
-        node.expiresAt = ttlMs ? Date.now() + ttlMs : null;
+        node.expiresAt = ttlMs ? performance.now() + ttlMs : null;
         moveToFront(node);
         return;
     }
     const newNode = {
         key,
         value,
-        expiresAt: ttlMs ? Date.now() + ttlMs : null
+        expiresAt: ttlMs ? performance.now() + ttlMs : null
     };
     newNode.next = head;
     if (head)

package/utils/path-router.d.ts

@@ -0,0 +1,70 @@
+export type Import = {
+    src: string;
+    import: any;
+};
+export type RoutePageHandler = {
+    type: 'page';
+    mainPage: {
+        manifestPath: string;
+        page: Import;
+        loader?: Import;
+        generateMeta?: Import;
+        options?: Import;
+    };
+    loadingPage?: {
+        manifestPath: string;
+        page: Import;
+        generateMeta?: Import;
+    };
+    errorPage?: {
+        manifestPath: string;
+        page: Import;
+        generateMeta?: Import;
+    };
+    notFoundPage?: {
+        manifestPath: string;
+        page: Import;
+        generateMeta?: Import;
+    };
+    layouts: {
+        manifestPath: string;
+        layout: Import;
+        loader?: Import;
+        generateMeta?: Import;
+    }[];
+    groups?: {
+        [key: string]: {
+            manifestPath: string;
+            page: Import;
+            loader?: Import;
+        };
+    };
+};
+export type RouteHandler = {
+    type: 'route';
+    handler: Import;
+    manifestPath: string;
+} | RoutePageHandler;
+type Params = Record<string, string | string[]>;
+export type RouteNode = {
+    staticChildren: Map<string, RouteNode>;
+    paramChild?: {
+        name: string;
+        node: RouteNode;
+    };
+    catchAllChild?: {
+        name: string;
+        optional: boolean;
+        node: RouteNode;
+    };
+    handler?: RouteHandler;
+};
+export declare const createNode: () => RouteNode;
+export declare const insertRoute: (root: RouteNode, path: string, handler: RouteHandler) => void;
+type MatchResult = {
+    handler: RouteHandler;
+    params: Params;
+} | null;
+export declare const matchRoute: (root: RouteNode, path: string) => MatchResult;
+export {};
+//# sourceMappingURL=path-router.d.ts.map

package/utils/path-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-router.d.ts","sourceRoot":"","sources":["../../utils/path-router.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,MAAM,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,GAAG,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE;QACN,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,WAAW,CAAC,EAAE;QACV,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,SAAS,CAAC,EAAE;QACR,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,YAAY,CAAC,EAAE;QACX,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,OAAO,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;KACzB,EAAE,CAAC;IACJ,MAAM,CAAC,EAAE;QACL,CAAC,GAAG,EAAE,MAAM,GAAG;YACX,YAAY,EAAE,MAAM,CAAC;YACrB,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,CAAC,EAAE,MAAM,CAAC;SACnB,CAAC;KACL,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,YAAY,GAClB;IACE,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;CACxB,GACC,gBAAgB,CAAC;AAEvB,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;AAEhD,MAAM,MAAM,SAAS,GAAG;IACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAEvC,UAAU,CAAC,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,SAAS,CAAC;KACnB,CAAA;IAED,aAAa,CAAC,EAAE;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,OAAO,CAAC;QAClB,IAAI,EAAE,SAAS,CAAC;KACnB,CAAA;IAED,OAAO,CAAC,EAAE,YAAY,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,UAAU,QAAO,SAE5B,CAAC;AAyCH,eAAO,MAAM,WAAW,GACpB,MAAM,SAAS,EACf,MAAM,MAAM,EACZ,SAAS,YAAY,SAyCxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACf,OAAO,EAAE,YAAY,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;CACjB,GAAG,IAAI,CAAA;AAER,eAAO,MAAM,UAAU,GACnB,MAAM,SAAS,EACf,MAAM,MAAM,KACb,WAmDF,CAAA"}

package/utils/path-router.js

@@ -0,0 +1,97 @@
+export const createNode = () => ({
+    staticChildren: new Map()
+});
+const parseSegment = (segment) => {
+    // [[...slug]]
+    if (segment.startsWith('[[...') && segment.endsWith(']]')) {
+        return { type: 'catchAll', name: segment.slice(5, -2), optional: true };
+    }
+    // [...slug]
+    if (segment.startsWith('[...') && segment.endsWith(']')) {
+        return { type: 'catchAll', name: segment.slice(4, -1), optional: false };
+    }
+    // [id]
+    if (segment.startsWith('[') && segment.endsWith(']')) {
+        return { type: 'param', name: segment.slice(1, -1) };
+    }
+    return { type: 'static', value: segment };
+};
+export const insertRoute = (root, path, handler) => {
+    const segments = path.split('/').filter(Boolean);
+    let node = root;
+    for (const segment of segments) {
+        const parsed = parseSegment(segment);
+        if (parsed.type === 'static' && parsed.value) {
+            if (!node.staticChildren.has(parsed.value)) {
+                node.staticChildren.set(parsed.value, createNode());
+            }
+            node = node.staticChildren.get(parsed.value);
+            continue;
+        }
+        if (parsed.type === 'param') {
+            if (!node.paramChild) {
+                node.paramChild = {
+                    name: parsed.name,
+                    node: createNode()
+                };
+            }
+            node = node.paramChild.node;
+            continue;
+        }
+        if (parsed.type === 'catchAll') {
+            if (!node.catchAllChild) {
+                node.catchAllChild = {
+                    name: parsed.name,
+                    optional: parsed.optional,
+                    node: createNode()
+                };
+            }
+            node = node.catchAllChild.node;
+            break; // catch-all always consumes the rest
+        }
+    }
+    node.handler = handler;
+};
+export const matchRoute = (root, path) => {
+    const segments = path.split('/').filter(Boolean);
+    const params = {};
+    const walk = (node, index) => {
+        // End of path
+        if (index === segments.length) {
+            if (node.handler)
+                return node.handler;
+            // Optional catch-all can match empty
+            if (node.catchAllChild?.optional) {
+                params[node.catchAllChild.name] = [];
+                return node.catchAllChild.node.handler ?? null;
+            }
+            return null;
+        }
+        const segment = segments[index];
+        // 1. Static
+        const staticChild = node.staticChildren.get(segment);
+        if (staticChild) {
+            const res = walk(staticChild, index + 1);
+            if (res)
+                return res;
+        }
+        // 2. Param
+        if (node.paramChild) {
+            params[node.paramChild.name] = segment;
+            const res = walk(node.paramChild.node, index + 1);
+            if (res)
+                return res;
+            delete params[node.paramChild.name];
+        }
+        // 3. Catch-all
+        if (node.catchAllChild) {
+            params[node.catchAllChild.name] = segments.slice(index);
+            return node.catchAllChild.node.handler ?? null;
+        }
+        return null;
+    };
+    const handler = walk(root, 0);
+    if (!handler)
+        return null;
+    return { handler, params };
+};