@sigx/router 0.1.6

package/dist/index.js

@@ -0,0 +1,682 @@
+import { component, defineInjectable, defineProvide, getCurrentInstance, signal } from "sigx";
+import { jsx } from "sigx/jsx-runtime";
+function parseSegments(path) {
+	return path.replace(/^\/|\/$/g, "").split("/").filter(Boolean).map((part) => {
+		if (part.startsWith(":")) {
+			const isOptional = part.endsWith("?");
+			return {
+				isParam: true,
+				isWildcard: false,
+				value: isOptional ? part.slice(1, -1) : part.slice(1),
+				isOptional
+			};
+		}
+		if (part.startsWith("*")) return {
+			isParam: false,
+			isWildcard: true,
+			value: part.slice(1) || "pathMatch",
+			isOptional: false
+		};
+		return {
+			isParam: false,
+			isWildcard: false,
+			value: part,
+			isOptional: false
+		};
+	});
+}
+function calculateScore(segments) {
+	let score = 0;
+	for (const segment of segments) if (segment.isWildcard) score += 1;
+	else if (segment.isParam) score += segment.isOptional ? 2 : 3;
+	else score += 4;
+	return score;
+}
+function buildRegex(segments) {
+	const parts = segments.map((segment) => {
+		if (segment.isWildcard) return "(?:\\/(.*))?";
+		if (segment.isParam) return segment.isOptional ? "(?:\\/([^\\/]+))?" : "\\/([^\\/]+)";
+		return `\\/${escapeRegex(segment.value)}`;
+	});
+	return new RegExp(`^${parts.join("")}\\/?$`);
+}
+function escapeRegex(str) {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileRoute(record, parent = null) {
+	const segments = parseSegments(record.path);
+	return {
+		record,
+		segments,
+		regex: buildRegex(segments),
+		paramNames: segments.filter((s) => s.isParam || s.isWildcard).map((s) => s.value),
+		score: calculateScore(segments),
+		parent
+	};
+}
+function compileRoutes(routes, parentPath = "", parentRoute = null) {
+	const compiled = [];
+	for (const route of routes) {
+		const fullPath = joinPaths(parentPath, route.path);
+		const compiledRoute = compileRoute({
+			...route,
+			path: fullPath
+		}, parentRoute);
+		compiled.push(compiledRoute);
+		if (route.children) compiled.push(...compileRoutes(route.children, fullPath, compiledRoute));
+	}
+	compiled.sort((a, b) => b.score - a.score);
+	return compiled;
+}
+function joinPaths(parent, child) {
+	if (!parent) return child;
+	if (child.startsWith("/")) return child;
+	return (parent.endsWith("/") ? parent.slice(0, -1) : parent) + (child.startsWith("/") ? child : "/" + child);
+}
+function matchRoute(path, compiledRoutes) {
+	const [pathOnly] = path.split(/[?#]/);
+	for (const compiled of compiledRoutes) {
+		const match = compiled.regex.exec(pathOnly);
+		if (match) {
+			const params = {};
+			compiled.paramNames.forEach((name, index) => {
+				const value = match[index + 1];
+				if (value !== void 0) params[name] = decodeURIComponent(value);
+			});
+			return {
+				route: compiled,
+				params
+			};
+		}
+	}
+	return null;
+}
+function parseQuery(queryString) {
+	const query = {};
+	if (!queryString || queryString === "?") return query;
+	const qs = queryString.startsWith("?") ? queryString.slice(1) : queryString;
+	for (const pair of qs.split("&")) {
+		if (!pair) continue;
+		const [key, value] = pair.split("=");
+		const decodedKey = decodeURIComponent(key);
+		const decodedValue = value !== void 0 ? decodeURIComponent(value) : "";
+		const existing = query[decodedKey];
+		if (existing !== void 0) if (Array.isArray(existing)) existing.push(decodedValue);
+		else query[decodedKey] = [existing, decodedValue];
+		else query[decodedKey] = decodedValue;
+	}
+	return query;
+}
+function stringifyQuery(query) {
+	const parts = [];
+	for (const key in query) {
+		const value = query[key];
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
+		else parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+	}
+	return parts.length ? "?" + parts.join("&") : "";
+}
+function parseURL(url) {
+	let path = url;
+	let queryString = "";
+	let hash = "";
+	const hashIndex = path.indexOf("#");
+	if (hashIndex !== -1) {
+		hash = path.slice(hashIndex);
+		path = path.slice(0, hashIndex);
+	}
+	const queryIndex = path.indexOf("?");
+	if (queryIndex !== -1) {
+		queryString = path.slice(queryIndex);
+		path = path.slice(0, queryIndex);
+	}
+	return {
+		path: path || "/",
+		query: parseQuery(queryString),
+		hash
+	};
+}
+function buildPath(path, query, hash) {
+	let result = path;
+	if (query && Object.keys(query).length > 0) result += stringifyQuery(query);
+	if (hash) result += hash.startsWith("#") ? hash : "#" + hash;
+	return result;
+}
+function createRouteLocation(fullPath, matched, params) {
+	const { path, query, hash } = parseURL(fullPath);
+	const matchedRecords = [];
+	if (matched) {
+		let current = matched;
+		const routeChain = [];
+		while (current) {
+			routeChain.unshift(current);
+			current = current.parent;
+		}
+		for (const route of routeChain) matchedRecords.push({
+			path: route.record.path,
+			name: route.record.name,
+			component: route.record.component,
+			meta: route.record.meta || {},
+			props: route.record.props
+		});
+	}
+	return {
+		fullPath,
+		path,
+		name: matched?.record.name,
+		params,
+		query,
+		hash,
+		matched: matchedRecords,
+		meta: matched?.record.meta || {}
+	};
+}
+const useRouter = defineInjectable(() => {
+	throw new Error("useRouter() is called but no router is installed. Make sure to install the router with app.use(router).");
+});
+const useRoute = defineInjectable(() => {
+	throw new Error("useRoute() is called but no router is installed. Make sure to install the router with app.use(router).");
+});
+function createRouter(options) {
+	const { history, routes } = options;
+	options.base;
+	let compiledRoutes = compileRoutes(routes);
+	const routeRecords = [...routes];
+	const beforeGuards = [];
+	const beforeResolveGuards = [];
+	const afterHooks = [];
+	let readyPromise = null;
+	let readyResolve = null;
+	const initialLocation = history.location;
+	const initialMatch = matchRoute(initialLocation, compiledRoutes);
+	const currentRouteState = signal(createRouteLocation(initialLocation, initialMatch?.route || null, initialMatch?.params || {}));
+	function resolve(to) {
+		if (typeof to === "string") {
+			const match = matchRoute(to, compiledRoutes);
+			return createRouteLocation(to, match?.route || null, match?.params || {});
+		}
+		const { path, name, params = {}, query = {}, hash = "" } = to;
+		if (name) {
+			const route = compiledRoutes.find((r) => r.record.name === name);
+			if (!route) {
+				console.warn(`Route with name "${name}" not found`);
+				return createRouteLocation("/", null, {});
+			}
+			return createRouteLocation(buildPath(buildPathFromParams(route.record.path, params), query, hash), route, params);
+		}
+		if (path) {
+			const fullPath = buildPath(path, query, hash);
+			const match = matchRoute(path, compiledRoutes);
+			return createRouteLocation(fullPath, match?.route || null, match?.params || {});
+		}
+		return getCurrentRoute();
+	}
+	function buildPathFromParams(pattern, params) {
+		let path = pattern;
+		for (const key in params) path = path.replace(`:${key}`, encodeURIComponent(params[key]));
+		path = path.replace(/\/:[^/]+\?/g, "");
+		return path;
+	}
+	function getCurrentRoute() {
+		const state = currentRouteState;
+		return {
+			fullPath: state.fullPath,
+			path: state.path,
+			name: state.name,
+			params: state.params,
+			query: state.query,
+			hash: state.hash,
+			matched: state.matched,
+			meta: state.meta,
+			redirectedFrom: state.redirectedFrom
+		};
+	}
+	async function runGuards(to, from, guards) {
+		for (const guard of guards) {
+			const result = await guard(to, from);
+			if (result === false) return false;
+			if (typeof result === "string") return resolve(result);
+			if (result && typeof result === "object") return resolve(result);
+		}
+		return true;
+	}
+	function finalizeNavigation(to, from) {
+		currentRouteState.$set(to);
+		for (const hook of afterHooks) hook(to, from);
+	}
+	async function navigate(to, replace = false) {
+		const from = getCurrentRoute();
+		const resolved = resolve(to);
+		const matched = resolved.matched[resolved.matched.length - 1];
+		if (matched) {
+			const routeRecord = compiledRoutes.find((r) => r.record.path === matched.path)?.record;
+			if (routeRecord?.redirect) return navigate(typeof routeRecord.redirect === "function" ? routeRecord.redirect(resolved) : routeRecord.redirect, replace);
+		}
+		const beforeResult = await runGuards(resolved, from, beforeGuards);
+		if (beforeResult === false) return;
+		if (beforeResult && typeof beforeResult === "object") return navigate(beforeResult, replace);
+		for (const record of resolved.matched) {
+			const routeRecord = compiledRoutes.find((r) => r.record.path === record.path)?.record;
+			if (routeRecord?.beforeEnter) {
+				const result = await runGuards(resolved, from, Array.isArray(routeRecord.beforeEnter) ? routeRecord.beforeEnter : [routeRecord.beforeEnter]);
+				if (result === false) return;
+				if (result && typeof result === "object") return navigate(result, replace);
+			}
+		}
+		const resolveResult = await runGuards(resolved, from, beforeResolveGuards);
+		if (resolveResult === false) return;
+		if (resolveResult && typeof resolveResult === "object") return navigate(resolveResult, replace);
+		if (replace) history.replace(resolved.fullPath);
+		else history.push(resolved.fullPath);
+		finalizeNavigation(resolved, from);
+		return resolved;
+	}
+	history.listen((to, from, state) => {
+		const match = matchRoute(to, compiledRoutes);
+		finalizeNavigation(createRouteLocation(to, match?.route || null, match?.params || {}), getCurrentRoute());
+	});
+	const router = {
+		get currentRoute() {
+			return getCurrentRoute();
+		},
+		get options() {
+			return options;
+		},
+		push(to) {
+			return navigate(to, false);
+		},
+		replace(to) {
+			return navigate(to, true);
+		},
+		back() {
+			history.go(-1);
+		},
+		forward() {
+			history.go(1);
+		},
+		go(delta) {
+			history.go(delta);
+		},
+		beforeEach(guard) {
+			beforeGuards.push(guard);
+			return () => {
+				const index = beforeGuards.indexOf(guard);
+				if (index !== -1) beforeGuards.splice(index, 1);
+			};
+		},
+		beforeResolve(guard) {
+			beforeResolveGuards.push(guard);
+			return () => {
+				const index = beforeResolveGuards.indexOf(guard);
+				if (index !== -1) beforeResolveGuards.splice(index, 1);
+			};
+		},
+		afterEach(hook) {
+			afterHooks.push(hook);
+			return () => {
+				const index = afterHooks.indexOf(hook);
+				if (index !== -1) afterHooks.splice(index, 1);
+			};
+		},
+		hasRoute(name) {
+			return routeRecords.some((r) => r.name === name);
+		},
+		getRoutes() {
+			return [...routeRecords];
+		},
+		addRoute(route, parentName) {
+			if (parentName) {
+				const parent = routeRecords.find((r) => r.name === parentName);
+				if (parent) {
+					parent.children = parent.children || [];
+					parent.children.push(route);
+				}
+			} else routeRecords.push(route);
+			compiledRoutes = compileRoutes(routeRecords);
+			const routeRef = route;
+			return () => {
+				if (routeRef.name) router.removeRoute(routeRef.name);
+				else {
+					const index = routeRecords.indexOf(routeRef);
+					if (index !== -1) {
+						routeRecords.splice(index, 1);
+						compiledRoutes = compileRoutes(routeRecords);
+					}
+				}
+			};
+		},
+		removeRoute(name) {
+			const index = routeRecords.findIndex((r) => r.name === name);
+			if (index !== -1) {
+				routeRecords.splice(index, 1);
+				compiledRoutes = compileRoutes(routeRecords);
+			}
+		},
+		resolve,
+		match(patterns) {
+			const route = getCurrentRoute();
+			const routeName = route.name;
+			if (routeName && routeName in patterns) {
+				const pattern = patterns[routeName];
+				if (typeof pattern === "function") return pattern(route.params);
+				return pattern;
+			}
+			if ("_" in patterns) {
+				const fallback = patterns._;
+				if (typeof fallback === "function") return fallback(route.params);
+				return fallback;
+			}
+		},
+		install(app) {
+			app.defineProvide(useRouter, () => router);
+			app.defineProvide(useRoute, () => currentRouteState);
+			if (readyResolve) readyResolve();
+		},
+		isReady() {
+			if (!readyPromise) readyPromise = new Promise((resolve) => {
+				readyResolve = resolve;
+			});
+			return readyPromise;
+		}
+	};
+	return router;
+}
+function createWebHistory(options = {}) {
+	const base = normalizeBase(options.base);
+	const listeners = /* @__PURE__ */ new Set();
+	let currentLocation = getCurrentLocation(base);
+	let currentState = typeof window !== "undefined" ? window.history.state : null;
+	const handlePopState = (event) => {
+		const from = currentLocation;
+		currentLocation = getCurrentLocation(base);
+		currentState = event.state;
+		listeners.forEach((callback) => {
+			callback(currentLocation, from, currentState);
+		});
+	};
+	if (typeof window !== "undefined") window.addEventListener("popstate", handlePopState);
+	return {
+		get location() {
+			return currentLocation;
+		},
+		get state() {
+			return currentState;
+		},
+		get base() {
+			return base;
+		},
+		push(to, state) {
+			const from = currentLocation;
+			const fullPath = base === "/" ? to : base + to;
+			const historyState = {
+				...state,
+				path: to,
+				position: (currentState?.position ?? 0) + 1
+			};
+			if (typeof window !== "undefined") window.history.pushState(historyState, "", fullPath);
+			currentLocation = to;
+			currentState = historyState;
+			listeners.forEach((callback) => {
+				callback(to, from, historyState);
+			});
+		},
+		replace(to, state) {
+			const from = currentLocation;
+			const fullPath = base === "/" ? to : base + to;
+			const historyState = {
+				...state,
+				path: to,
+				position: currentState?.position ?? 0
+			};
+			if (typeof window !== "undefined") window.history.replaceState(historyState, "", fullPath);
+			currentLocation = to;
+			currentState = historyState;
+			listeners.forEach((callback) => {
+				callback(to, from, historyState);
+			});
+		},
+		go(delta) {
+			if (typeof window !== "undefined") window.history.go(delta);
+		},
+		listen(callback) {
+			listeners.add(callback);
+			return () => {
+				listeners.delete(callback);
+			};
+		},
+		createHref(path) {
+			return base === "/" ? path : base + path;
+		},
+		destroy() {
+			if (typeof window !== "undefined") window.removeEventListener("popstate", handlePopState);
+			listeners.clear();
+		}
+	};
+}
+function normalizeBase(base) {
+	if (!base) {
+		if (typeof document !== "undefined") {
+			const baseTag = document.querySelector("base");
+			if (baseTag) base = baseTag.getAttribute("href") || "/";
+		}
+		base = base || "/";
+	}
+	if (!base.startsWith("/")) base = "/" + base;
+	if (base !== "/" && base.endsWith("/")) base = base.slice(0, -1);
+	return base;
+}
+function getCurrentLocation(base) {
+	if (typeof window === "undefined") return "/";
+	const { pathname, search, hash } = window.location;
+	let path = pathname;
+	if (base !== "/" && pathname.startsWith(base)) path = pathname.slice(base.length) || "/";
+	return path + search + hash;
+}
+function createMemoryHistory(options = {}) {
+	const base = options.base || "";
+	const initialLocation = options.initialLocation || "/";
+	const listeners = /* @__PURE__ */ new Set();
+	const entries = [{
+		location: initialLocation,
+		state: {
+			path: initialLocation,
+			position: 0
+		}
+	}];
+	let currentIndex = 0;
+	return {
+		get location() {
+			return entries[currentIndex].location;
+		},
+		get state() {
+			return entries[currentIndex].state;
+		},
+		get base() {
+			return base;
+		},
+		push(to, state) {
+			const from = entries[currentIndex].location;
+			const historyState = {
+				...state,
+				path: to,
+				position: currentIndex + 1
+			};
+			entries.splice(currentIndex + 1);
+			entries.push({
+				location: to,
+				state: historyState
+			});
+			currentIndex = entries.length - 1;
+			listeners.forEach((callback) => {
+				callback(to, from, historyState);
+			});
+		},
+		replace(to, state) {
+			const from = entries[currentIndex].location;
+			const historyState = {
+				...state,
+				path: to,
+				position: currentIndex
+			};
+			entries[currentIndex] = {
+				location: to,
+				state: historyState
+			};
+			listeners.forEach((callback) => {
+				callback(to, from, historyState);
+			});
+		},
+		go(delta) {
+			const newIndex = currentIndex + delta;
+			if (newIndex < 0 || newIndex >= entries.length) return;
+			const from = entries[currentIndex].location;
+			currentIndex = newIndex;
+			const to = entries[currentIndex].location;
+			const state = entries[currentIndex].state;
+			listeners.forEach((callback) => {
+				callback(to, from, state);
+			});
+		},
+		listen(callback) {
+			listeners.add(callback);
+			return () => {
+				listeners.delete(callback);
+			};
+		},
+		createHref(path) {
+			return base + path;
+		},
+		destroy() {
+			listeners.clear();
+		}
+	};
+}
+function useParams() {
+	return useRoute().params;
+}
+function useQuery() {
+	return useRoute().query;
+}
+function useNavigate() {
+	const router = useRouter();
+	return router.push.bind(router);
+}
+function onBeforeRouteLeave(guard) {
+	const ctx = getCurrentInstance();
+	if (!ctx) {
+		console.warn("onBeforeRouteLeave() is called outside of component setup");
+		return;
+	}
+	const unregister = useRouter().beforeEach((to, from) => {
+		if (!from) return;
+		const currentRoute = useRoute();
+		if (from.path !== currentRoute.path) return;
+		return new Promise((resolve) => {
+			guard(to, from, (result) => {
+				if (result === false) resolve(false);
+				else if (typeof result === "string") resolve(result);
+				else if (result && typeof result === "object") resolve(result);
+				else resolve();
+			});
+		});
+	});
+	ctx.onUnmounted(() => {
+		unregister();
+	});
+}
+function onBeforeRouteUpdate(guard) {
+	const ctx = getCurrentInstance();
+	if (!ctx) {
+		console.warn("onBeforeRouteUpdate() is called outside of component setup");
+		return;
+	}
+	const router = useRouter();
+	const currentRoute = useRoute();
+	const unregister = router.beforeEach((to, from) => {
+		if (to.path !== currentRoute.path) return;
+		return new Promise((resolve) => {
+			guard(to, from, (result) => {
+				if (result === false) resolve(false);
+				else if (typeof result === "string") resolve(result);
+				else if (result && typeof result === "object") resolve(result);
+				else resolve();
+			});
+		});
+	});
+	ctx.onUnmounted(() => {
+		unregister();
+	});
+}
+var useRouterViewDepth = defineInjectable(() => 0);
+function isComponentFactory(component) {
+	return typeof component === "function" && "__setup" in component;
+}
+const RouterView = component((ctx) => {
+	const route = useRoute();
+	const depth = useRouterViewDepth();
+	defineProvide(useRouterViewDepth, () => depth + 1);
+	return () => {
+		const { name = "default", pageProps = {} } = ctx.props;
+		const matched = route.matched;
+		if (matched.length === 0 || depth >= matched.length) return null;
+		const match = matched[depth];
+		const Component = match.component;
+		if (!Component) return null;
+		if (!isComponentFactory(Component)) return null;
+		let componentProps = {};
+		if (match.props === true) componentProps = { ...route.params };
+		else if (typeof match.props === "function") componentProps = match.props(route);
+		else if (match.props && typeof match.props === "object") componentProps = { ...match.props };
+		if (pageProps && Object.keys(pageProps).length > 0) componentProps = {
+			...componentProps,
+			...pageProps
+		};
+		return /* @__PURE__ */ jsx(Component, { ...componentProps });
+	};
+}, { name: "RouterView" });
+const Link = component(({ props, slots, emit }) => {
+	const router = useRouter();
+	const currentRoute = useRoute();
+	const replace = () => props.replace ?? false;
+	const activeClass = () => props.activeClass ?? "router-link-active";
+	const exactActiveClass = () => props.exactActiveClass ?? "router-link-exact-active";
+	const ariaCurrentValue = () => props.ariaCurrentValue ?? "page";
+	const handleClick = (event) => {
+		emit("click", event);
+		if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.button !== 0) return;
+		event.preventDefault();
+		if (replace()) router.replace(props.to);
+		else router.push(props.to);
+	};
+	return () => {
+		const resolved = router.resolve(props.to);
+		const href = resolved.fullPath;
+		const isExactActive = currentRoute.path === resolved.path;
+		const isActive = currentRoute.path.startsWith(resolved.path);
+		const classes = [];
+		if (isActive && activeClass()) classes.push(activeClass());
+		if (isExactActive && exactActiveClass()) classes.push(exactActiveClass());
+		return /* @__PURE__ */ jsx("a", {
+			href,
+			onClick: handleClick,
+			class: classes.length > 0 ? classes.join(" ") : void 0,
+			"aria-current": isExactActive ? ariaCurrentValue() : void 0,
+			children: slots.default()
+		});
+	};
+}, { name: "Link" });
+const RouterLink = Link;
+function createRouterPlugin(options) {
+	const router = createRouter(options);
+	return {
+		name: "@sigx/router",
+		router,
+		install(app) {
+			router.install(app);
+		}
+	};
+}
+export { Link, RouterLink, RouterView, buildPath, createMemoryHistory, createRouter, createRouterPlugin, createWebHistory, onBeforeRouteLeave, onBeforeRouteUpdate, parseQuery, parseURL, stringifyQuery, useNavigate, useParams, useQuery, useRoute, useRouter };
+
+//# sourceMappingURL=index.js.map