@shuvi/router 2.0.0-dev.16 → 2.0.0-dev.18

package/esm/matchStaticRoutes.d.ts

@@ -0,0 +1,18 @@
+import { IRouteMatch, PartialLocation } from './types';
+import { IRouteBaseObject } from './matchRoutes';
+/**
+ * Static Route Matching Function
+ *
+ * Optimization features:
+ * 1. O(1) exact match - direct HashMap lookup
+ * 2. Precompiled results - pre-calculate all match results at startup
+ * 3. Zero regex - pure string matching
+ * 4. Memory friendly - matcher instance reuse
+ * 5. Type safe - full TypeScript support
+ *
+ * @param routes Route configuration array
+ * @param location Location to match
+ * @param basename Base path
+ * @returns Match result or null
+ */
+export declare function matchStaticRoutes<T extends IRouteBaseObject>(routes: T[], location: string | PartialLocation, basename?: string): IRouteMatch<T>[] | null;

package/esm/matchStaticRoutes.js

@@ -0,0 +1,210 @@
+import { joinPaths, normalizeBase, resolvePath, stripBase } from './utils';
+/**
+ * Static Route Matcher Class
+ */
+class StaticRouteMatcher {
+    constructor(routes) {
+        this.exactMatchMap = new Map();
+        this.allRoutes = routes;
+        this.prefixTree = this.buildPrefixTree(routes);
+        this.precompileMatches();
+    }
+    /**
+     * Build prefix tree
+     */
+    buildPrefixTree(routes) {
+        const root = {
+            exactRoutes: new Map(),
+            children: new Map(),
+            routes: []
+        };
+        // Flatten all routes
+        const flatRoutes = this.flattenRoutes(routes);
+        for (const { path, routeChain } of flatRoutes) {
+            // Only process static routes
+            if (this.isStaticPath(path)) {
+                this.insertIntoTree(root, path, routeChain);
+            }
+        }
+        return root;
+    }
+    /**
+     * Flatten route structure
+     */
+    flattenRoutes(routes, parentPath = '', parentRoutes = []) {
+        const result = [];
+        routes.forEach(route => {
+            let fullPath;
+            if (route.path === '') {
+                fullPath = parentPath;
+            }
+            else {
+                fullPath = joinPaths([parentPath, route.path]);
+            }
+            const routeChain = [...parentRoutes, route];
+            result.push({ path: fullPath, routeChain });
+            // Recursively process child routes
+            if (route.children) {
+                result.push(...this.flattenRoutes(route.children, fullPath, routeChain));
+            }
+        });
+        return result;
+    }
+    /**
+     * Check if path is static
+     */
+    isStaticPath(path) {
+        return !path.includes(':') && !path.includes('*') && !path.includes('(');
+    }
+    /**
+     * Insert route into prefix tree
+     */
+    insertIntoTree(node, path, routes) {
+        // Store exact match
+        node.exactRoutes.set(path, routes);
+        // Build prefix tree for prefix matching
+        const segments = path.split('/').filter(Boolean);
+        let currentNode = node;
+        for (const segment of segments) {
+            if (!currentNode.children.has(segment)) {
+                currentNode.children.set(segment, {
+                    exactRoutes: new Map(),
+                    children: new Map(),
+                    routes: []
+                });
+            }
+            currentNode = currentNode.children.get(segment);
+        }
+        // Store routes at leaf node
+        currentNode.routes = routes;
+    }
+    /**
+     * Precompile all possible match results
+     */
+    precompileMatches() {
+        for (const [path, routeChain] of this.prefixTree.exactRoutes) {
+            const matches = this.buildMatches(routeChain, path);
+            this.exactMatchMap.set(path, {
+                matches,
+                pathname: path,
+                params: {} // Static routes have no parameters
+            });
+        }
+    }
+    /**
+     * Build match results
+     */
+    buildMatches(routeChain, matchedPathname) {
+        const matches = [];
+        let currentMatchedPath = '/';
+        for (let i = 0; i < routeChain.length; i++) {
+            const route = routeChain[i];
+            if (route.path === '') {
+                // Simulate the exact behavior of matchPathname + joinPaths
+                // When remainingPathname is '/' and path is '', matchPathname returns { pathname: '/' }
+                // Then joinPaths([currentPath, '/']) adds trailing slash
+                currentMatchedPath = joinPaths([currentMatchedPath, '/']);
+            }
+            else {
+                // For non-empty path, use the path directly
+                currentMatchedPath = joinPaths([currentMatchedPath, route.path]);
+            }
+            matches.push({
+                route,
+                pathname: currentMatchedPath,
+                params: Object.freeze({}) // Static routes have no parameters
+            });
+        }
+        return matches;
+    }
+    /**
+     * Match pathname
+     */
+    match(pathname) {
+        // 1. Exact match (O(1))
+        const exactMatch = this.exactMatchMap.get(pathname);
+        if (exactMatch) {
+            return exactMatch;
+        }
+        // 2. Prefix match (for handling trailing slash etc.)
+        return this.findPrefixMatch(pathname);
+    }
+    /**
+     * Find prefix match
+     */
+    findPrefixMatch(pathname) {
+        // Try adding/removing trailing slash
+        const alternatives = [
+            pathname,
+            pathname === '/' ? pathname : pathname.replace(/\/$/, ''),
+            pathname.endsWith('/') ? pathname : pathname + '/'
+        ];
+        for (const alt of alternatives) {
+            const match = this.exactMatchMap.get(alt);
+            if (match) {
+                return match;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get all static route paths (for debugging)
+     */
+    getAllStaticPaths() {
+        return Array.from(this.exactMatchMap.keys()).sort();
+    }
+    /**
+     * Get matching statistics
+     */
+    getStats() {
+        return {
+            totalStaticRoutes: this.exactMatchMap.size,
+            totalRoutes: this.allRoutes.length,
+            staticRatio: (this.exactMatchMap.size / this.allRoutes.length * 100).toFixed(1) + '%'
+        };
+    }
+}
+// Global matcher cache
+const staticMatcherCache = new WeakMap();
+/**
+ * Static Route Matching Function
+ *
+ * Optimization features:
+ * 1. O(1) exact match - direct HashMap lookup
+ * 2. Precompiled results - pre-calculate all match results at startup
+ * 3. Zero regex - pure string matching
+ * 4. Memory friendly - matcher instance reuse
+ * 5. Type safe - full TypeScript support
+ *
+ * @param routes Route configuration array
+ * @param location Location to match
+ * @param basename Base path
+ * @returns Match result or null
+ */
+export function matchStaticRoutes(routes, location, basename = '') {
+    // Normalize input
+    if (typeof location === 'string') {
+        location = resolvePath(location);
+    }
+    let pathname = location.pathname || '/';
+    // Handle basename
+    if (basename) {
+        const normalizedBasename = normalizeBase(basename);
+        const pathnameWithoutBase = stripBase(pathname, normalizedBasename);
+        if (pathnameWithoutBase) {
+            pathname = pathnameWithoutBase;
+        }
+        else {
+            return null;
+        }
+    }
+    // Get or create matcher
+    let matcher = staticMatcherCache.get(routes);
+    if (!matcher) {
+        matcher = new StaticRouteMatcher(routes);
+        staticMatcherCache.set(routes, matcher);
+    }
+    // Execute matching
+    const result = matcher.match(pathname);
+    return result ? result.matches : null;
+}

package/esm/router.d.ts

@@ -4,6 +4,7 @@ interface IRouterOptions<RouteRecord extends IPartialRouteRecord> {
     history: History;
     routes: RouteRecord[];
     caseSensitive?: boolean;
+    staticMode?: boolean;
 }
 export declare const createRouter: <RouteRecord extends IRouteRecord>(options: IRouterOptions<RouteRecord>) => IRouter<RouteRecord>;
 export {};

package/esm/router.js

@@ -5,6 +5,7 @@ import { createEvents, resolvePath } from './utils';
 import { isError, isFunction } from './utils/error';
 import { runQueue } from './utils/async';
 import { getRedirectFromRoutes } from './getRedirectFromRoutes';
+import { matchStaticRoutes } from './matchStaticRoutes';
 const START = {
     matches: [],
     params: {},
@@ -17,11 +18,12 @@ const START = {
     redirected: false
 };
 class Router {
-    constructor({ history, routes }) {
+    constructor({ history, routes, staticMode }) {
         this._pending = null;
         this._cancleHandler = null;
         this._ready = false;
         this._readyDefer = createDefer();
+        this._staticMode = false;
         this._listeners = createEvents();
         this._beforeEachs = createEvents();
         this._beforeResolves = createEvents();
@@ -74,7 +76,7 @@ class Router {
         };
         this.match = (to) => {
             const { _routes: routes } = this;
-            const matches = matchRoutes(routes, to);
+            const matches = this._staticMode ? matchStaticRoutes(routes, to) : matchRoutes(routes, to);
             return matches || [];
         };
         this.replaceRoutes = (routes) => {
@@ -102,6 +104,7 @@ class Router {
         this._history = history;
         this._routes = createRoutesFromArray(routes);
         this._current = START;
+        this._staticMode = !!staticMode;
         this._history.doTransition = this._doTransition.bind(this);
     }
     get ready() {

package/lib/matchStaticRoutes.d.ts

@@ -0,0 +1,18 @@
+import { IRouteMatch, PartialLocation } from './types';
+import { IRouteBaseObject } from './matchRoutes';
+/**
+ * Static Route Matching Function
+ *
+ * Optimization features:
+ * 1. O(1) exact match - direct HashMap lookup
+ * 2. Precompiled results - pre-calculate all match results at startup
+ * 3. Zero regex - pure string matching
+ * 4. Memory friendly - matcher instance reuse
+ * 5. Type safe - full TypeScript support
+ *
+ * @param routes Route configuration array
+ * @param location Location to match
+ * @param basename Base path
+ * @returns Match result or null
+ */
+export declare function matchStaticRoutes<T extends IRouteBaseObject>(routes: T[], location: string | PartialLocation, basename?: string): IRouteMatch<T>[] | null;

package/lib/matchStaticRoutes.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchStaticRoutes = matchStaticRoutes;
+const utils_1 = require("./utils");
+/**
+ * Static Route Matcher Class
+ */
+class StaticRouteMatcher {
+    constructor(routes) {
+        this.exactMatchMap = new Map();
+        this.allRoutes = routes;
+        this.prefixTree = this.buildPrefixTree(routes);
+        this.precompileMatches();
+    }
+    /**
+     * Build prefix tree
+     */
+    buildPrefixTree(routes) {
+        const root = {
+            exactRoutes: new Map(),
+            children: new Map(),
+            routes: []
+        };
+        // Flatten all routes
+        const flatRoutes = this.flattenRoutes(routes);
+        for (const { path, routeChain } of flatRoutes) {
+            // Only process static routes
+            if (this.isStaticPath(path)) {
+                this.insertIntoTree(root, path, routeChain);
+            }
+        }
+        return root;
+    }
+    /**
+     * Flatten route structure
+     */
+    flattenRoutes(routes, parentPath = '', parentRoutes = []) {
+        const result = [];
+        routes.forEach(route => {
+            let fullPath;
+            if (route.path === '') {
+                fullPath = parentPath;
+            }
+            else {
+                fullPath = (0, utils_1.joinPaths)([parentPath, route.path]);
+            }
+            const routeChain = [...parentRoutes, route];
+            result.push({ path: fullPath, routeChain });
+            // Recursively process child routes
+            if (route.children) {
+                result.push(...this.flattenRoutes(route.children, fullPath, routeChain));
+            }
+        });
+        return result;
+    }
+    /**
+     * Check if path is static
+     */
+    isStaticPath(path) {
+        return !path.includes(':') && !path.includes('*') && !path.includes('(');
+    }
+    /**
+     * Insert route into prefix tree
+     */
+    insertIntoTree(node, path, routes) {
+        // Store exact match
+        node.exactRoutes.set(path, routes);
+        // Build prefix tree for prefix matching
+        const segments = path.split('/').filter(Boolean);
+        let currentNode = node;
+        for (const segment of segments) {
+            if (!currentNode.children.has(segment)) {
+                currentNode.children.set(segment, {
+                    exactRoutes: new Map(),
+                    children: new Map(),
+                    routes: []
+                });
+            }
+            currentNode = currentNode.children.get(segment);
+        }
+        // Store routes at leaf node
+        currentNode.routes = routes;
+    }
+    /**
+     * Precompile all possible match results
+     */
+    precompileMatches() {
+        for (const [path, routeChain] of this.prefixTree.exactRoutes) {
+            const matches = this.buildMatches(routeChain, path);
+            this.exactMatchMap.set(path, {
+                matches,
+                pathname: path,
+                params: {} // Static routes have no parameters
+            });
+        }
+    }
+    /**
+     * Build match results
+     */
+    buildMatches(routeChain, matchedPathname) {
+        const matches = [];
+        let currentMatchedPath = '/';
+        for (let i = 0; i < routeChain.length; i++) {
+            const route = routeChain[i];
+            if (route.path === '') {
+                // Simulate the exact behavior of matchPathname + joinPaths
+                // When remainingPathname is '/' and path is '', matchPathname returns { pathname: '/' }
+                // Then joinPaths([currentPath, '/']) adds trailing slash
+                currentMatchedPath = (0, utils_1.joinPaths)([currentMatchedPath, '/']);
+            }
+            else {
+                // For non-empty path, use the path directly
+                currentMatchedPath = (0, utils_1.joinPaths)([currentMatchedPath, route.path]);
+            }
+            matches.push({
+                route,
+                pathname: currentMatchedPath,
+                params: Object.freeze({}) // Static routes have no parameters
+            });
+        }
+        return matches;
+    }
+    /**
+     * Match pathname
+     */
+    match(pathname) {
+        // 1. Exact match (O(1))
+        const exactMatch = this.exactMatchMap.get(pathname);
+        if (exactMatch) {
+            return exactMatch;
+        }
+        // 2. Prefix match (for handling trailing slash etc.)
+        return this.findPrefixMatch(pathname);
+    }
+    /**
+     * Find prefix match
+     */
+    findPrefixMatch(pathname) {
+        // Try adding/removing trailing slash
+        const alternatives = [
+            pathname,
+            pathname === '/' ? pathname : pathname.replace(/\/$/, ''),
+            pathname.endsWith('/') ? pathname : pathname + '/'
+        ];
+        for (const alt of alternatives) {
+            const match = this.exactMatchMap.get(alt);
+            if (match) {
+                return match;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get all static route paths (for debugging)
+     */
+    getAllStaticPaths() {
+        return Array.from(this.exactMatchMap.keys()).sort();
+    }
+    /**
+     * Get matching statistics
+     */
+    getStats() {
+        return {
+            totalStaticRoutes: this.exactMatchMap.size,
+            totalRoutes: this.allRoutes.length,
+            staticRatio: (this.exactMatchMap.size / this.allRoutes.length * 100).toFixed(1) + '%'
+        };
+    }
+}
+// Global matcher cache
+const staticMatcherCache = new WeakMap();
+/**
+ * Static Route Matching Function
+ *
+ * Optimization features:
+ * 1. O(1) exact match - direct HashMap lookup
+ * 2. Precompiled results - pre-calculate all match results at startup
+ * 3. Zero regex - pure string matching
+ * 4. Memory friendly - matcher instance reuse
+ * 5. Type safe - full TypeScript support
+ *
+ * @param routes Route configuration array
+ * @param location Location to match
+ * @param basename Base path
+ * @returns Match result or null
+ */
+function matchStaticRoutes(routes, location, basename = '') {
+    // Normalize input
+    if (typeof location === 'string') {
+        location = (0, utils_1.resolvePath)(location);
+    }
+    let pathname = location.pathname || '/';
+    // Handle basename
+    if (basename) {
+        const normalizedBasename = (0, utils_1.normalizeBase)(basename);
+        const pathnameWithoutBase = (0, utils_1.stripBase)(pathname, normalizedBasename);
+        if (pathnameWithoutBase) {
+            pathname = pathnameWithoutBase;
+        }
+        else {
+            return null;
+        }
+    }
+    // Get or create matcher
+    let matcher = staticMatcherCache.get(routes);
+    if (!matcher) {
+        matcher = new StaticRouteMatcher(routes);
+        staticMatcherCache.set(routes, matcher);
+    }
+    // Execute matching
+    const result = matcher.match(pathname);
+    return result ? result.matches : null;
+}

package/lib/router.d.ts

@@ -4,6 +4,7 @@ interface IRouterOptions<RouteRecord extends IPartialRouteRecord> {
     history: History;
     routes: RouteRecord[];
     caseSensitive?: boolean;
+    staticMode?: boolean;
 }
 export declare const createRouter: <RouteRecord extends IRouteRecord>(options: IRouterOptions<RouteRecord>) => IRouter<RouteRecord>;
 export {};

package/lib/router.js

@@ -8,6 +8,7 @@ const utils_1 = require("./utils");
 const error_1 = require("./utils/error");
 const async_1 = require("./utils/async");
 const getRedirectFromRoutes_1 = require("./getRedirectFromRoutes");
+const matchStaticRoutes_1 = require("./matchStaticRoutes");
 const START = {
     matches: [],
     params: {},
@@ -20,11 +21,12 @@ const START = {
     redirected: false
 };
 class Router {
-    constructor({ history, routes }) {
+    constructor({ history, routes, staticMode }) {
         this._pending = null;
         this._cancleHandler = null;
         this._ready = false;
         this._readyDefer = (0, defer_1.createDefer)();
+        this._staticMode = false;
         this._listeners = (0, utils_1.createEvents)();
         this._beforeEachs = (0, utils_1.createEvents)();
         this._beforeResolves = (0, utils_1.createEvents)();
@@ -77,7 +79,7 @@ class Router {
         };
         this.match = (to) => {
             const { _routes: routes } = this;
-            const matches = (0, matchRoutes_1.matchRoutes)(routes, to);
+            const matches = this._staticMode ? (0, matchStaticRoutes_1.matchStaticRoutes)(routes, to) : (0, matchRoutes_1.matchRoutes)(routes, to);
             return matches || [];
         };
         this.replaceRoutes = (routes) => {
@@ -105,6 +107,7 @@ class Router {
         this._history = history;
         this._routes = (0, createRoutesFromArray_1.createRoutesFromArray)(routes);
         this._current = START;
+        this._staticMode = !!staticMode;
         this._history.doTransition = this._doTransition.bind(this);
     }
     get ready() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shuvi/router",
-  "version": "2.0.0-dev.16",
+  "version": "2.0.0-dev.18",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/shuvijs/shuvi.git",
@@ -28,7 +28,7 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@shuvi/utils": "2.0.0-dev.16",
+    "@shuvi/utils": "2.0.0-dev.18",
     "query-string": "6.13.8"
   }
 }