@pyreon/router 0.2.1 → 0.3.1

package/lib/analysis/index.js.html

@@ -5386,7 +5386,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"a1485d5b-1","name":"loader.ts"},{"uid":"a1485d5b-3","name":"match.ts"},{"uid":"a1485d5b-5","name":"scroll.ts"},{"uid":"a1485d5b-7","name":"types.ts"},{"uid":"a1485d5b-9","name":"router.ts"},{"uid":"a1485d5b-11","name":"components.tsx"},{"uid":"a1485d5b-13","name":"index.ts"}]}]}],"isRoot":true},"nodeParts":{"a1485d5b-1":{"renderedLength":2855,"gzipLength":1243,"brotliLength":0,"metaUid":"a1485d5b-0"},"a1485d5b-3":{"renderedLength":6655,"gzipLength":2084,"brotliLength":0,"metaUid":"a1485d5b-2"},"a1485d5b-5":{"renderedLength":1367,"gzipLength":576,"brotliLength":0,"metaUid":"a1485d5b-4"},"a1485d5b-7":{"renderedLength":385,"gzipLength":246,"brotliLength":0,"metaUid":"a1485d5b-6"},"a1485d5b-9":{"renderedLength":8965,"gzipLength":2657,"brotliLength":0,"metaUid":"a1485d5b-8"},"a1485d5b-11":{"renderedLength":6631,"gzipLength":2488,"brotliLength":0,"metaUid":"a1485d5b-10"},"a1485d5b-13":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"a1485d5b-12"}},"nodeMetas":{"a1485d5b-0":{"id":"/src/loader.ts","moduleParts":{"index.js":"a1485d5b-1"},"imported":[{"uid":"a1485d5b-14"}],"importedBy":[{"uid":"a1485d5b-12"},{"uid":"a1485d5b-10"}]},"a1485d5b-2":{"id":"/src/match.ts","moduleParts":{"index.js":"a1485d5b-3"},"imported":[],"importedBy":[{"uid":"a1485d5b-12"},{"uid":"a1485d5b-8"}]},"a1485d5b-4":{"id":"/src/scroll.ts","moduleParts":{"index.js":"a1485d5b-5"},"imported":[],"importedBy":[{"uid":"a1485d5b-8"}]},"a1485d5b-6":{"id":"/src/types.ts","moduleParts":{"index.js":"a1485d5b-7"},"imported":[],"importedBy":[{"uid":"a1485d5b-12"},{"uid":"a1485d5b-8"}]},"a1485d5b-8":{"id":"/src/router.ts","moduleParts":{"index.js":"a1485d5b-9"},"imported":[{"uid":"a1485d5b-14"},{"uid":"a1485d5b-15"},{"uid":"a1485d5b-2"},{"uid":"a1485d5b-4"},{"uid":"a1485d5b-6"}],"importedBy":[{"uid":"a1485d5b-12"},{"uid":"a1485d5b-10"}]},"a1485d5b-10":{"id":"/src/components.tsx","moduleParts":{"index.js":"a1485d5b-11"},"imported":[{"uid":"a1485d5b-14"},{"uid":"a1485d5b-0"},{"uid":"a1485d5b-8"}],"importedBy":[{"uid":"a1485d5b-12"}]},"a1485d5b-12":{"id":"/src/index.ts","moduleParts":{"index.js":"a1485d5b-13"},"imported":[{"uid":"a1485d5b-10"},{"uid":"a1485d5b-0"},{"uid":"a1485d5b-2"},{"uid":"a1485d5b-8"},{"uid":"a1485d5b-6"}],"importedBy":[],"isEntry":true},"a1485d5b-14":{"id":"@pyreon/core","moduleParts":{},"imported":[],"importedBy":[{"uid":"a1485d5b-10"},{"uid":"a1485d5b-0"},{"uid":"a1485d5b-8"}]},"a1485d5b-15":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"a1485d5b-8"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"ffb5fd41-1","name":"loader.ts"},{"uid":"ffb5fd41-3","name":"match.ts"},{"uid":"ffb5fd41-5","name":"scroll.ts"},{"uid":"ffb5fd41-7","name":"types.ts"},{"uid":"ffb5fd41-9","name":"router.ts"},{"uid":"ffb5fd41-11","name":"components.tsx"},{"uid":"ffb5fd41-13","name":"index.ts"}]}]}],"isRoot":true},"nodeParts":{"ffb5fd41-1":{"renderedLength":2855,"gzipLength":1243,"brotliLength":0,"metaUid":"ffb5fd41-0"},"ffb5fd41-3":{"renderedLength":10804,"gzipLength":3328,"brotliLength":0,"metaUid":"ffb5fd41-2"},"ffb5fd41-5":{"renderedLength":1367,"gzipLength":576,"brotliLength":0,"metaUid":"ffb5fd41-4"},"ffb5fd41-7":{"renderedLength":385,"gzipLength":246,"brotliLength":0,"metaUid":"ffb5fd41-6"},"ffb5fd41-9":{"renderedLength":8965,"gzipLength":2657,"brotliLength":0,"metaUid":"ffb5fd41-8"},"ffb5fd41-11":{"renderedLength":6631,"gzipLength":2488,"brotliLength":0,"metaUid":"ffb5fd41-10"},"ffb5fd41-13":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"ffb5fd41-12"}},"nodeMetas":{"ffb5fd41-0":{"id":"/src/loader.ts","moduleParts":{"index.js":"ffb5fd41-1"},"imported":[{"uid":"ffb5fd41-14"}],"importedBy":[{"uid":"ffb5fd41-12"},{"uid":"ffb5fd41-10"}]},"ffb5fd41-2":{"id":"/src/match.ts","moduleParts":{"index.js":"ffb5fd41-3"},"imported":[],"importedBy":[{"uid":"ffb5fd41-12"},{"uid":"ffb5fd41-8"}]},"ffb5fd41-4":{"id":"/src/scroll.ts","moduleParts":{"index.js":"ffb5fd41-5"},"imported":[],"importedBy":[{"uid":"ffb5fd41-8"}]},"ffb5fd41-6":{"id":"/src/types.ts","moduleParts":{"index.js":"ffb5fd41-7"},"imported":[],"importedBy":[{"uid":"ffb5fd41-12"},{"uid":"ffb5fd41-8"}]},"ffb5fd41-8":{"id":"/src/router.ts","moduleParts":{"index.js":"ffb5fd41-9"},"imported":[{"uid":"ffb5fd41-14"},{"uid":"ffb5fd41-15"},{"uid":"ffb5fd41-2"},{"uid":"ffb5fd41-4"},{"uid":"ffb5fd41-6"}],"importedBy":[{"uid":"ffb5fd41-12"},{"uid":"ffb5fd41-10"}]},"ffb5fd41-10":{"id":"/src/components.tsx","moduleParts":{"index.js":"ffb5fd41-11"},"imported":[{"uid":"ffb5fd41-14"},{"uid":"ffb5fd41-0"},{"uid":"ffb5fd41-8"}],"importedBy":[{"uid":"ffb5fd41-12"}]},"ffb5fd41-12":{"id":"/src/index.ts","moduleParts":{"index.js":"ffb5fd41-13"},"imported":[{"uid":"ffb5fd41-10"},{"uid":"ffb5fd41-0"},{"uid":"ffb5fd41-2"},{"uid":"ffb5fd41-8"},{"uid":"ffb5fd41-6"}],"importedBy":[],"isEntry":true},"ffb5fd41-14":{"id":"@pyreon/core","moduleParts":{},"imported":[],"importedBy":[{"uid":"ffb5fd41-10"},{"uid":"ffb5fd41-0"},{"uid":"ffb5fd41-8"}]},"ffb5fd41-15":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"ffb5fd41-8"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/lib/index.js

@@ -135,69 +135,213 @@ function stringifyQuery(query) {
 	for (const [k, v] of Object.entries(query)) parts.push(v ? `${encodeURIComponent(k)}=${encodeURIComponent(v)}` : encodeURIComponent(k));
 	return parts.length ? `?${parts.join("&")}` : "";
 }
+/** WeakMap cache: compile each RouteRecord[] once */
+const _compiledCache = /* @__PURE__ */ new WeakMap();
+function compileSegment(raw) {
+	if (raw.endsWith("*") && raw.startsWith(":")) return {
+		raw,
+		isParam: true,
+		isSplat: true,
+		paramName: raw.slice(1, -1)
+	};
+	if (raw.startsWith(":")) return {
+		raw,
+		isParam: true,
+		isSplat: false,
+		paramName: raw.slice(1)
+	};
+	return {
+		raw,
+		isParam: false,
+		isSplat: false,
+		paramName: ""
+	};
+}
+function compileRoute(route) {
+	const pattern = route.path;
+	if (pattern === "(.*)" || pattern === "*") return {
+		route,
+		isWildcard: true,
+		segments: [],
+		segmentCount: 0,
+		isStatic: false,
+		staticPath: null,
+		children: null,
+		firstSegment: null
+	};
+	const segments = pattern.split("/").filter(Boolean).map(compileSegment);
+	const isStatic = segments.every((s) => !s.isParam);
+	const staticPath = isStatic ? `/${segments.map((s) => s.raw).join("/")}` : null;
+	const first = segments.length > 0 ? segments[0] : void 0;
+	const firstSegment = first && !first.isParam ? first.raw : null;
+	return {
+		route,
+		isWildcard: false,
+		segments,
+		segmentCount: segments.length,
+		isStatic,
+		staticPath,
+		children: null,
+		firstSegment
+	};
+}
+function compileRoutes(routes) {
+	const cached = _compiledCache.get(routes);
+	if (cached) return cached;
+	const compiled = routes.map((r) => {
+		const c = compileRoute(r);
+		if (r.children && r.children.length > 0) c.children = compileRoutes(r.children);
+		return c;
+	});
+	_compiledCache.set(routes, compiled);
+	return compiled;
+}
+/** Extract first static segment from a segment list, or null if dynamic/empty */
+function getFirstSegment(segments) {
+	const first = segments[0];
+	if (first && !first.isParam) return first.raw;
+	return null;
+}
+/** Build a FlattenedRoute from segments + metadata */
+function makeFlatEntry(segments, chain, meta, isWildcard) {
+	const isStatic = !isWildcard && segments.every((s) => !s.isParam);
+	return {
+		segments,
+		segmentCount: segments.length,
+		matchedChain: chain,
+		isStatic,
+		staticPath: isStatic ? `/${segments.map((s) => s.raw).join("/")}` : null,
+		meta,
+		firstSegment: getFirstSegment(segments),
+		hasSplat: segments.some((s) => s.isSplat),
+		isWildcard
+	};
+}
 /**
-* Match a single route pattern against a path segment.
-* Returns extracted params or null if no match.
-*
-* Supports:
-*   - Exact segments: "/about"
-*   - Param segments: "/user/:id"
-*   - Wildcard: "(.*)" matches everything
+* Flatten nested routes into leaf entries with pre-joined segments.
+* This eliminates recursion during matching for the common case.
 */
-function matchPath(pattern, path) {
-	if (pattern === "(.*)" || pattern === "*") return {};
-	const patternParts = pattern.split("/").filter(Boolean);
-	const pathParts = path.split("/").filter(Boolean);
+function flattenRoutes(compiled) {
+	const result = [];
+	flattenWalk(result, compiled, [], [], {});
+	return result;
+}
+function flattenWalk(result, routes, parentSegments, parentChain, parentMeta) {
+	for (const c of routes) flattenOne(result, c, parentSegments, [...parentChain, c.route], c.route.meta ? {
+		...parentMeta,
+		...c.route.meta
+	} : { ...parentMeta });
+}
+function flattenOne(result, c, parentSegments, chain, meta) {
+	if (c.isWildcard) {
+		result.push(makeFlatEntry(parentSegments, chain, meta, true));
+		if (c.children && c.children.length > 0) flattenWalk(result, c.children, parentSegments, chain, meta);
+		return;
+	}
+	const joined = [...parentSegments, ...c.segments];
+	if (c.children && c.children.length > 0) flattenWalk(result, c.children, joined, chain, meta);
+	result.push(makeFlatEntry(joined, chain, meta, false));
+}
+const _indexCache = /* @__PURE__ */ new WeakMap();
+/** Classify a single flattened route into the appropriate index bucket */
+function indexFlatRoute(f, staticMap, segmentMap, dynamicFirst, wildcards) {
+	if (f.isStatic && f.staticPath && !staticMap.has(f.staticPath)) staticMap.set(f.staticPath, f);
+	if (f.isWildcard) {
+		wildcards.push(f);
+		return;
+	}
+	if (f.segmentCount === 0) return;
+	if (f.firstSegment) {
+		let bucket = segmentMap.get(f.firstSegment);
+		if (!bucket) {
+			bucket = [];
+			segmentMap.set(f.firstSegment, bucket);
+		}
+		bucket.push(f);
+	} else dynamicFirst.push(f);
+}
+function buildRouteIndex(routes, compiled) {
+	const cached = _indexCache.get(routes);
+	if (cached) return cached;
+	const flattened = flattenRoutes(compiled);
+	const staticMap = /* @__PURE__ */ new Map();
+	const segmentMap = /* @__PURE__ */ new Map();
+	const dynamicFirst = [];
+	const wildcards = [];
+	for (const f of flattened) indexFlatRoute(f, staticMap, segmentMap, dynamicFirst, wildcards);
+	const index = {
+		staticMap,
+		segmentMap,
+		dynamicFirst,
+		wildcards
+	};
+	_indexCache.set(routes, index);
+	return index;
+}
+/** Split path into segments without allocating a filtered array */
+function splitPath(path) {
+	if (path === "/") return [];
+	const start = path.charCodeAt(0) === 47 ? 1 : 0;
+	const end = path.length;
+	if (start >= end) return [];
+	const parts = [];
+	let segStart = start;
+	for (let i = start; i <= end; i++) if (i === end || path.charCodeAt(i) === 47) {
+		if (i > segStart) parts.push(path.substring(segStart, i));
+		segStart = i + 1;
+	}
+	return parts;
+}
+/** Decode only if the segment contains a `%` character */
+function decodeSafe(s) {
+	return s.indexOf("%") >= 0 ? decodeURIComponent(s) : s;
+}
+/** Collect remaining path segments as a decoded splat value */
+function captureSplat(pathParts, from, pathLen) {
+	const remaining = [];
+	for (let j = from; j < pathLen; j++) {
+		const p = pathParts[j];
+		if (p !== void 0) remaining.push(decodeSafe(p));
+	}
+	return remaining.join("/");
+}
+/** Try to match a flattened route against path parts */
+function matchFlattened(f, pathParts, pathLen) {
+	if (f.segmentCount !== pathLen) {
+		if (!f.hasSplat || pathLen < f.segmentCount) return null;
+	}
 	const params = {};
-	for (let i = 0; i < patternParts.length; i++) {
-		const pp = patternParts[i];
+	const segments = f.segments;
+	const count = f.segmentCount;
+	for (let i = 0; i < count; i++) {
+		const seg = segments[i];
 		const pt = pathParts[i];
-		if (pp.endsWith("*") && pp.startsWith(":")) {
-			const paramName = pp.slice(1, -1);
-			params[paramName] = pathParts.slice(i).map(decodeURIComponent).join("/");
+		if (!seg || pt === void 0) return null;
+		if (seg.isSplat) {
+			params[seg.paramName] = captureSplat(pathParts, i, pathLen);
 			return params;
 		}
-		if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pt);
-		else if (pp !== pt) return null;
+		if (seg.isParam) params[seg.paramName] = decodeSafe(pt);
+		else if (seg.raw !== pt) return null;
 	}
-	if (patternParts.length !== pathParts.length) return null;
 	return params;
 }
-/**
-* Check if a path starts with a route's prefix (for nested route matching).
-* Returns the remaining path suffix, or null if no match.
-*/
-function matchPrefix(pattern, path) {
-	if (pattern === "(.*)" || pattern === "*") return {
-		params: {},
-		rest: path
-	};
-	const patternParts = pattern.split("/").filter(Boolean);
-	const pathParts = path.split("/").filter(Boolean);
-	if (pathParts.length < patternParts.length) return null;
-	const params = {};
-	for (let i = 0; i < patternParts.length; i++) {
-		const pp = patternParts[i];
-		const pt = pathParts[i];
-		if (pp.endsWith("*") && pp.startsWith(":")) {
-			const paramName = pp.slice(1, -1);
-			params[paramName] = pathParts.slice(i).map(decodeURIComponent).join("/");
-			return {
-				params,
-				rest: "/"
-			};
-		}
-		if (pp.startsWith(":")) params[pp.slice(1)] = decodeURIComponent(pt);
-		else if (pp !== pt) return null;
+/** Search a list of flattened candidates for a match */
+function searchCandidates(candidates, pathParts, pathLen) {
+	for (let i = 0; i < candidates.length; i++) {
+		const f = candidates[i];
+		if (!f) continue;
+		const params = matchFlattened(f, pathParts, pathLen);
+		if (params) return {
+			params,
+			matched: f.matchedChain
+		};
 	}
-	return {
-		params,
-		rest: `/${pathParts.slice(patternParts.length).join("/")}`
-	};
+	return null;
 }
 /**
 * Resolve a raw path (including query string and hash) against the route tree.
-* Handles nested routes recursively.
+* Uses flattened index for O(1) static lookup and first-segment dispatch.
 */
 function resolveRoute(rawPath, routes) {
 	const qIdx = rawPath.indexOf("?");
@@ -207,14 +351,50 @@ function resolveRoute(rawPath, routes) {
 	const cleanPath = hIdx >= 0 ? pathAndHash.slice(0, hIdx) : pathAndHash;
 	const hash = hIdx >= 0 ? pathAndHash.slice(hIdx + 1) : "";
 	const query = parseQuery(queryPart);
-	const match = matchRoutes(cleanPath, routes, []);
-	if (match) return {
+	const index = buildRouteIndex(routes, compileRoutes(routes));
+	const staticMatch = index.staticMap.get(cleanPath);
+	if (staticMatch) return {
+		path: cleanPath,
+		params: {},
+		query,
+		hash,
+		matched: staticMatch.matchedChain,
+		meta: staticMatch.meta
+	};
+	const pathParts = splitPath(cleanPath);
+	const pathLen = pathParts.length;
+	if (pathLen > 0) {
+		const first = pathParts[0];
+		const bucket = index.segmentMap.get(first);
+		if (bucket) {
+			const match = searchCandidates(bucket, pathParts, pathLen);
+			if (match) return {
+				path: cleanPath,
+				params: match.params,
+				query,
+				hash,
+				matched: match.matched,
+				meta: mergeMeta(match.matched)
+			};
+		}
+	}
+	const dynMatch = searchCandidates(index.dynamicFirst, pathParts, pathLen);
+	if (dynMatch) return {
 		path: cleanPath,
-		params: match.params,
+		params: dynMatch.params,
 		query,
 		hash,
-		matched: match.matched,
-		meta: mergeMeta(match.matched)
+		matched: dynMatch.matched,
+		meta: mergeMeta(dynMatch.matched)
+	};
+	const w = index.wildcards[0];
+	if (w) return {
+		path: cleanPath,
+		params: {},
+		query,
+		hash,
+		matched: w.matchedChain,
+		meta: w.meta
 	};
 	return {
 		path: cleanPath,
@@ -225,44 +405,6 @@ function resolveRoute(rawPath, routes) {
 		meta: {}
 	};
 }
-function matchRoutes(path, routes, parentMatched, parentParams = {}) {
-	for (const route of routes) {
-		const result = matchSingleRoute(path, route, parentMatched, parentParams);
-		if (result) return result;
-	}
-	return null;
-}
-function matchSingleRoute(path, route, parentMatched, parentParams) {
-	if (!route.children || route.children.length === 0) {
-		const params = matchPath(route.path, path);
-		if (params === null) return null;
-		return {
-			params: {
-				...parentParams,
-				...params
-			},
-			matched: [...parentMatched, route]
-		};
-	}
-	const prefix = matchPrefix(route.path, path);
-	if (prefix === null) return null;
-	const allParams = {
-		...parentParams,
-		...prefix.params
-	};
-	const matched = [...parentMatched, route];
-	const childMatch = matchRoutes(prefix.rest, route.children, matched, allParams);
-	if (childMatch) return childMatch;
-	const exactParams = matchPath(route.path, path);
-	if (exactParams === null) return null;
-	return {
-		params: {
-			...parentParams,
-			...exactParams
-		},
-		matched
-	};
-}
 /** Merge meta from matched routes (leaf takes precedence) */
 function mergeMeta(matched) {
 	const meta = {};