@mpen/rerouter 0.1.9 → 0.3.1

package/dist/routes-PW-bNm8e.js

@@ -0,0 +1,135 @@
+import { match } from "path-to-regexp";
+//#region src/lib/routes.ts
+function toUrlPattern(pattern) {
+	if (typeof pattern !== "string") return pattern;
+	return new URLPattern({ pathname: pattern });
+}
+function decodeRouteParams(groups) {
+	const params = {};
+	for (const [key, value] of Object.entries(groups)) if (value == null) params[key] = void 0;
+	else params[key] = decodeURIComponent(String(value));
+	return params;
+}
+function stripLegacyParamPattern(pattern, startIndex) {
+	let depth = 1;
+	let endIndex = startIndex + 1;
+	while (endIndex < pattern.length && depth > 0) {
+		const char = pattern[endIndex];
+		if (char === "\\") {
+			endIndex += 2;
+			continue;
+		}
+		if (char === "(") depth++;
+		else if (char === ")") depth--;
+		endIndex++;
+	}
+	return endIndex;
+}
+/**
+* Converts legacy `path-to-regexp` syntax that is ignored by URL generation into syntax accepted
+* by the current parser.
+*
+* @param pattern - The route pattern to normalize.
+* @returns The pattern with custom regexp constraints stripped and optional group suffixes removed.
+*
+* @example
+* ```ts
+* normalizeLegacyPathToRegexpSyntax('/blog/:id(\\d+){-:title}?')
+* // '/blog/:id{-:title}'
+* ```
+*
+* @internal
+*/
+function normalizeLegacyPathToRegexpSyntax(pattern) {
+	let normalized = "";
+	for (let i = 0; i < pattern.length; i++) {
+		const char = pattern[i];
+		if (char === "\\") {
+			normalized += char;
+			if (i + 1 < pattern.length) normalized += pattern[++i];
+			continue;
+		}
+		if (char === ":" || char === "*") {
+			normalized += char;
+			while (i + 1 < pattern.length && /[$_\p{ID_Continue}]/u.test(pattern[i + 1])) normalized += pattern[++i];
+			if (pattern[i + 1] === "(") i = stripLegacyParamPattern(pattern, i + 1) - 1;
+			continue;
+		}
+		if (char === "}" && pattern[i + 1] === "?") {
+			normalized += char;
+			i++;
+			continue;
+		}
+		normalized += char;
+	}
+	return normalized;
+}
+/**
+* Normalizes routes into objects with a shared matcher implementation.
+*
+* @param routes - The route definitions to normalize.
+* @returns Routes with stable `name`, `pattern`, `component`, and `matches` fields.
+*
+* @example
+* ```tsx
+* const normalized = normalizeRoutes(routes)
+* const match = normalized[0]?.matches('/users/123')
+* ```
+*/
+function normalizeRoutes(routes) {
+	return routes.map((route) => {
+		const { name, pattern, component } = route;
+		if (typeof pattern !== "string") {
+			const urlPattern = toUrlPattern(pattern);
+			return {
+				name,
+				pattern,
+				component,
+				matches(pathname) {
+					const match = urlPattern.exec({ pathname });
+					if (!match) return null;
+					return match.pathname?.groups ?? {};
+				}
+			};
+		}
+		if (pattern === "*" || pattern === "/*") return {
+			name,
+			pattern,
+			component,
+			matches: (_pathname) => ({})
+		};
+		let matcher;
+		let urlPattern;
+		try {
+			matcher = match(pattern, { decode: decodeURIComponent });
+		} catch {
+			try {
+				urlPattern = toUrlPattern(pattern);
+			} catch {
+				matcher = match(normalizeLegacyPathToRegexpSyntax(pattern), { decode: decodeURIComponent });
+			}
+		}
+		return {
+			name,
+			pattern,
+			component,
+			matches(pathname) {
+				if (urlPattern) {
+					const match = urlPattern.exec({ pathname });
+					if (!match) return null;
+					return decodeRouteParams(match.pathname?.groups ?? {});
+				}
+				if (!matcher) return null;
+				const match = matcher(pathname);
+				if (!match) return null;
+				const params = {};
+				for (const [key, value] of Object.entries(match.params)) if (value == null) params[key] = void 0;
+				else if (Array.isArray(value)) params[key] = value.join("/");
+				else params[key] = String(value);
+				return params;
+			}
+		};
+	});
+}
+//#endregion
+export { normalizeRoutes as n, normalizeLegacyPathToRegexpSyntax as t };