sv-router 0.0.1 → 0.0.3

package/package.json

@@ -1,67 +1,70 @@
 {
-	"name": "sv-router",
-	"version": "0.0.1",
-	"description": "Modern Svelte routing",
-	"keywords": [
-		"svelte",
-		"router",
-		"spa"
-	],
-	"homepage": "https://github.com/colinlienard/sv-router",
-	"bugs": {
-		"url": "https://github.com/colinlienard/sv-router/issues"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/colinlienard/sv-router.git"
-	},
-	"license": "MIT",
-	"type": "module",
-	"exports": {
-		".": {
-			"sv-router/source": "./src/index.ts",
-			"import": "./dist/index.js",
-			"svelte": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		}
-	},
-	"files": [
-		"dist"
-	],
-	"scripts": {
-		"ex:basic": "pnpm --filter basic-example",
-		"build": "svelte-package -i src && rm -rf .svelte-kit",
-		"test": "vitest",
-		"check": "tsc --noEmit && pnpm -r check",
-		"lint": "eslint .",
-		"lint:fix": "eslint . --fix",
-		"format": "prettier . --check",
-		"format:fix": "prettier . --write",
-		"sherif": "sherif -r root-package-private-field",
-		"sherif:fix": "sherif  -r root-package-private-field --fix"
-	},
-	"dependencies": {
-		"esm-env": "^1.1.4"
-	},
-	"devDependencies": {
-		"@eslint/js": "^9.15.0",
-		"@sveltejs/package": "^2.3.7",
-		"eslint-config-prettier": "^9.1.0",
-		"eslint-plugin-simple-import-sort": "^12.1.1",
-		"eslint-plugin-svelte": "^2.46.0",
-		"eslint-plugin-unicorn": "^56.0.1",
-		"globals": "^15.12.0",
-		"prettier": "^3.3.3",
-		"prettier-plugin-svelte": "^3.3.2",
-		"sherif": "^1.0.1",
-		"type-testing": "^0.2.0",
-		"typescript": "^5.7.2",
-		"typescript-eslint": "^8.14.0",
-		"vite": "^5.4.10",
-		"vitest": "^2.1.5"
-	},
-	"peerDependencies": {
-		"svelte": "^5"
-	},
-	"packageManager": "pnpm@9.14.2"
-}
+  "name": "sv-router",
+  "version": "0.0.3",
+  "description": "Modern Svelte routing",
+  "keywords": [
+    "svelte",
+    "router",
+    "spa"
+  ],
+  "homepage": "https://github.com/colinlienard/sv-router",
+  "bugs": {
+    "url": "https://github.com/colinlienard/sv-router/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/colinlienard/sv-router.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.js",
+      "svelte": "./src/index.js",
+      "types": "./src/index.d.ts"
+    },
+    "./vite-plugin": {
+      "import": "./src/vite-plugin/index.js",
+      "types": "./src/vite-plugin/index.d.ts"
+    }
+  },
+  "bin": "./src/cli/index.js",
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "esm-env": "^1.2.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.10",
+    "@eslint/js": "^9.16.0",
+    "@types/node": "^22.10.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-svelte": "^2.46.1",
+    "eslint-plugin-unicorn": "^56.0.1",
+    "globals": "^15.13.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-jsdoc": "^1.3.0",
+    "prettier-plugin-svelte": "^3.3.2",
+    "type-testing": "^0.2.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.0",
+    "vite": "^6.0.3",
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "svelte": "^5"
+  },
+  "scripts": {
+    "ex:basic": "pnpm --filter basic-example",
+    "ex:file-based": "pnpm --filter file-based-example",
+    "test": "vitest",
+    "check": "tsc --noEmit && pnpm -r check",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier . --check",
+    "format:fix": "prettier . --write",
+    "changeset": "changeset"
+  }
+}

package/{dist → src}/RecursiveComponentTree.svelte

@@ -1,9 +1,9 @@
-<script lang="ts">
-	import type { Component } from 'svelte';
+<script>
+	import { paramsStore } from './create-router.svelte.js';
 	import RecursiveComponentTree from './RecursiveComponentTree.svelte';
-	import { paramsStore } from './router.svelte.ts';
 
-	let { tree }: { tree: Component[] } = $props();
+	/** @type {{ tree: import('svelte').Component[] }} */
+	let { tree } = $props();
 
 	const FirstComponent = $derived(tree[0]);
 	const restTree = $derived(tree.slice(1));

package/{dist → src}/Router.svelte

@@ -1,7 +1,7 @@
-<script lang="ts">
+<script>
 	import { on } from 'svelte/events';
+	import { componentTree, onGlobalClick, onNavigate } from './create-router.svelte.js';
 	import RecursiveComponentTree from './RecursiveComponentTree.svelte';
-	import { componentTree, onGlobalClick, onNavigate } from './router.svelte.ts';
 
 	onNavigate();
 

package/src/cli/index.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { writeRouterCode } from '../gen/write-router-code.js';
+
+writeRouterCode();

package/src/create-router.svelte.js

@@ -0,0 +1,67 @@
+import { BROWSER, DEV } from 'esm-env';
+import { matchRoute } from './helpers/match-route.js';
+import { constructPath, resolveRouteComponents } from './helpers/utils.js';
+
+/** @type {import('./index.d.ts').Routes} */
+export let routes;
+
+/** @type {import('svelte').Component[]} */
+export const componentTree = $state([]);
+
+/** @type {Record<string, string>} */
+export const paramsStore = $state({});
+
+/**
+ * @template {import('./index.d.ts').Routes} T
+ * @param {T} r
+ * @returns {import('./index.d.ts').RouterMethods<T>}
+ */
+export function createRouter(r) {
+	routes = r;
+
+	if (DEV && BROWSER) {
+		import('./helpers/validate-routes.js').then(({ validateRoutes }) => {
+			validateRoutes(routes);
+		});
+	}
+
+	return {
+		path: constructPath,
+		goto(...args) {
+			const path = constructPath(args[0], args[1]);
+			globalThis.history.pushState({}, '', path);
+			onNavigate();
+		},
+		params() {
+			const readonly = $derived(paramsStore);
+			return readonly;
+		},
+	};
+}
+
+export function onNavigate() {
+	if (!routes) {
+		throw new Error('Router not initialized: `createRouter` was not called.');
+	}
+	const { match, layouts, params } = matchRoute(globalThis.location.pathname, routes);
+	resolveRouteComponents(match ? [...layouts, match] : layouts).then((components) => {
+		Object.assign(componentTree, components);
+	});
+	Object.assign(paramsStore, params);
+}
+
+/** @param {Event} event */
+export function onGlobalClick(event) {
+	const anchor = /** @type {HTMLElement} */ (event.target).closest('a');
+	if (!anchor) return;
+
+	if (anchor.hasAttribute('target') || anchor.hasAttribute('download')) return;
+
+	const url = new URL(anchor.href);
+	const currentOrigin = globalThis.location.origin;
+	if (url.origin !== currentOrigin) return;
+
+	event.preventDefault();
+	globalThis.history.pushState({}, '', anchor.href);
+	onNavigate();
+}

package/src/gen/config.js

@@ -0,0 +1,16 @@
+/**
+ * @type {{
+ * 	routesPath: string;
+ * 	readonly genCodeDirPath: string;
+ * 	readonly routerPath: string;
+ * 	readonly tsconfigPath: string;
+ * 	readonly genCodeAlias: string;
+ * }}
+ */
+export const genConfig = {
+	routesPath: 'src/routes',
+	genCodeDirPath: '.router',
+	routerPath: '.router/router.ts',
+	tsconfigPath: '.router/tsconfig.json',
+	genCodeAlias: 'sv-router/generated',
+};

package/src/gen/generate-router-code.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** @typedef {(string | { name: string; tree: FileTree })[]} FileTree */
+
+/**
+ * @typedef {{
+ * 	[key: string]: string | GeneratedRoutes;
+ * }} GeneratedRoutes
+ */
+
+const PARAM_FILENAME_REGEX = /\[(.*)\].svelte/g;
+
+/**
+ * @param {string} routesPath
+ * @returns {string}
+ */
+export function generateRouterCode(routesPath) {
+	const fileTree = buildFileTree(path.join(process.cwd(), routesPath));
+	const routeMap = createRouteMap(fileTree);
+	return createRouterCode(routeMap, path.join('..', routesPath));
+}
+
+/**
+ * @param {string} routesPath
+ * @returns {FileTree}
+ */
+export function buildFileTree(routesPath) {
+	const entries = fs.readdirSync(routesPath);
+	/** @type {FileTree} */
+	const result = [];
+	for (const entry of entries) {
+		const stat = fs.lstatSync(path.join(routesPath, entry));
+		if (stat.isDirectory()) {
+			result.push({ name: entry, tree: buildFileTree(path.join(routesPath, entry)) });
+		} else if (entry.endsWith('.svelte')) {
+			result.push(entry);
+		}
+	}
+	return result;
+}
+
+/**
+ * @param {FileTree} fileTree
+ * @param {string} prefix
+ * @returns {GeneratedRoutes}
+ */
+export function createRouteMap(fileTree, prefix = '') {
+	/** @type {GeneratedRoutes} */
+	const result = {};
+	for (const entry of fileTree) {
+		if (typeof entry === 'string') {
+			switch (entry) {
+				case 'index.svelte': {
+					result['/'] = prefix + entry;
+					break;
+				}
+				case '*.svelte': {
+					result['*'] = prefix + entry;
+					break;
+				}
+				case '_layout.svelte': {
+					result['layout'] = prefix + entry;
+					break;
+				}
+				default: {
+					if (PARAM_FILENAME_REGEX.test(entry)) {
+						result['/' + entry.replaceAll(PARAM_FILENAME_REGEX, ':$1')] = prefix + entry;
+						break;
+					}
+					result['/' + entry.replace('.svelte', '')] = prefix + entry;
+					break;
+				}
+			}
+		} else {
+			result['/' + entry.name] = createRouteMap(entry.tree, prefix + entry.name + '/');
+		}
+	}
+	return result;
+}
+
+/**
+ * @param {GeneratedRoutes} routes
+ * @param {string} routesPath
+ * @returns {string}
+ */
+export function createRouterCode(routes, routesPath) {
+	if (!routesPath.endsWith('/')) {
+		routesPath += '/';
+	}
+
+	const jsonRoutes = JSON.stringify(routes, undefined, 2);
+	const withImports = jsonRoutes.replaceAll(
+		/"(.*)": "(.*)",?/g,
+		`"$1": () => import("${routesPath}$2"),`,
+	);
+	return [
+		'import { createRouter } from "sv-router";',
+		'\n\n',
+		`export const { path, goto, params } = createRouter(${withImports});`,
+	].join('');
+}

package/src/gen/write-router-code.js

@@ -0,0 +1,52 @@
+/* eslint-disable no-console */
+import fs from 'node:fs';
+import path from 'node:path';
+import { genConfig } from './config.js';
+import { generateRouterCode } from './generate-router-code.js';
+
+export function writeRouterCode() {
+	try {
+		if (!fs.existsSync(genConfig.genCodeDirPath)) {
+			fs.mkdirSync(genConfig.genCodeDirPath);
+		}
+
+		// Write `.router/router.ts` file
+		const routerCode = generateRouterCode(genConfig.routesPath);
+		writeFileIfDifferent(genConfig.routerPath, routerCode);
+
+		// Write `.router/tsconfig.json` file
+		const tsConfig = {
+			compilerOptions: {
+				module: 'preserve',
+				moduleResolution: 'bundler',
+				paths: {
+					[genConfig.genCodeAlias]: [path.join('..', genConfig.routerPath)],
+				},
+			},
+			include: [
+				'../src/**/*.js',
+				'../src/**/*.ts',
+				'../src/**/*.svelte',
+				'../tests/**/*.js',
+				'../tests/**/*.ts',
+				'../tests/**/*.svelte',
+				'./router.ts',
+			],
+		};
+		writeFileIfDifferent(genConfig.tsconfigPath, JSON.stringify(tsConfig, undefined, 2));
+
+		console.log('✅️ Routes generated');
+	} catch (error) {
+		console.error('Error during routes generation:', error);
+	}
+}
+
+/**
+ * @param {string} filePath
+ * @param {string} content
+ */
+function writeFileIfDifferent(filePath, content) {
+	if (!fs.existsSync(filePath) || fs.readFileSync(filePath, 'utf8') !== content) {
+		fs.writeFileSync(filePath, content);
+	}
+}

package/src/helpers/match-route.js

@@ -0,0 +1,112 @@
+/**
+ * @typedef {import('../index.d.ts').LayoutComponent} LayoutComponent
+ *
+ * @typedef {import('../index.d.ts').RouteComponent} RouteComponent
+ *
+ * @typedef {import('../index.d.ts').Routes} Routes
+ */
+
+/**
+ * @param {string} pathname
+ * @param {Routes} routes
+ * @returns {{
+ * 	match: RouteComponent | undefined;
+ * 	layouts: LayoutComponent[];
+ * 	params: Record<string, string>;
+ * 	breakFromLayouts: boolean;
+ * }}
+ */
+export function matchRoute(pathname, routes) {
+	// Remove trailing slash
+	if (pathname.length > 1 && pathname.endsWith('/')) {
+		pathname = pathname.slice(0, -1);
+	}
+	const pathParts = pathname.split('/');
+	const allRouteParts = sortRoutes(Object.keys(routes)).map((route) => route.split('/'));
+
+	/** @type {RouteComponent | undefined} */
+	let match;
+
+	/** @type {LayoutComponent[]} */
+	let layouts = [];
+
+	/** @type {Record<string, string>} */
+	let params = {};
+
+	let breakFromLayouts = false;
+
+	outer: for (const routeParts of allRouteParts) {
+		for (let [index, routePart] of sortRoutes(routeParts).entries()) {
+			breakFromLayouts = routePart.startsWith('(') && routePart.endsWith(')');
+			if (breakFromLayouts) {
+				routePart = routePart.slice(1, -1);
+			}
+
+			const pathPart = pathParts[index];
+			if (routePart.startsWith(':')) {
+				params[routePart.slice(1)] = pathPart;
+			} else if (routePart === '*') {
+				match = /** @type {RouteComponent} */ (
+					routes[/** @type {keyof Routes} */ (routeParts.join('/'))]
+				);
+				break outer;
+			} else if (routePart !== pathPart) {
+				break;
+			}
+
+			if (index !== routeParts.length - 1) {
+				continue;
+			}
+
+			if (!breakFromLayouts && 'layout' in routes && routes.layout) {
+				layouts.push(routes.layout);
+			}
+
+			const routeMatch = /** @type {RouteComponent} */ (
+				routes[/** @type {keyof Routes} */ (routeParts.join('/'))]
+			);
+
+			if (typeof routeMatch === 'function') {
+				if (routeParts.length === pathParts.length) {
+					match = routeMatch;
+				} else {
+					continue;
+				}
+			} else if (routeMatch) {
+				const nestedPathname = '/' + pathParts.slice(index + 1).join('/');
+				const result = matchRoute(nestedPathname, routeMatch);
+				if (result) {
+					match = result.match;
+					params = { ...params, ...result.params };
+					if (result.breakFromLayouts) {
+						layouts = [];
+					} else {
+						layouts.push(...result.layouts);
+					}
+				}
+			}
+			break outer;
+		}
+	}
+
+	return { match, layouts, params, breakFromLayouts };
+}
+
+/**
+ * @param {string[]} routes
+ * @returns {string[]}
+ */
+export function sortRoutes(routes) {
+	return routes.toSorted((a, b) => getRoutePriority(a) - getRoutePriority(b));
+}
+
+/**
+ * @param {string} route
+ * @returns {number}
+ */
+function getRoutePriority(route) {
+	if (route === '' || route === '/') return 1;
+	if (route === '*') return 4;
+	if (route.includes(':')) return 3;
+	return 2;
+}

package/src/helpers/utils.js

@@ -0,0 +1,46 @@
+/**
+ * @param {string} path
+ * @param {Record<string, string>} [params]
+ * @returns {string}
+ */
+export function constructPath(path, params) {
+	if (!params) return path;
+
+	let result = path;
+	for (const key in params) {
+		result = result.replace(`:${key}`, params[key]);
+	}
+	return result;
+}
+
+/**
+ * @param {import('../index.d.ts').RouteComponent[]} input
+ * @returns {Promise<import('svelte').Component[]>}
+ */
+export function resolveRouteComponents(input) {
+	return Promise.all(input.map((c) => resolveRouteComponent(c)));
+}
+
+/**
+ * @param {import('../index.d.ts').RouteComponent} input
+ * @returns {Promise<import('svelte').Component>}
+ */
+export function resolveRouteComponent(input) {
+	return new Promise((resolve) => {
+		if (isLazyImport(input)) {
+			Promise.resolve(input()).then((module) => {
+				resolve(module.default);
+			});
+		} else {
+			resolve(input);
+		}
+	});
+}
+
+/**
+ * @param {unknown} input
+ * @returns {input is import('../index.d.ts').LazyRouteComponent}
+ */
+export function isLazyImport(input) {
+	return typeof input === 'function' && !!/\(\)\s?=>\s?import\(.*\)/g.test(String(input));
+}

package/src/helpers/validate-routes.js

@@ -0,0 +1,46 @@
+/** @param {import('../index.d.ts').Routes} routes */
+export function validateRoutes(routes) {
+	const paths = getRoutePaths(routes);
+	const wildcardPaths = paths.filter((path) => path.endsWith('*'));
+	for (const wildcardPath of wildcardPaths) {
+		const parentPath = wildcardPath.slice(0, -1);
+		const dynamicPath = paths.find(
+			(p) =>
+				p !== '/' &&
+				!p.endsWith('*') &&
+				p.startsWith(parentPath === '' ? '/:' : parentPath) &&
+				p.match(/:[^/]*$/g), // Match dynamic paths without slashes after the colon
+		);
+		if (dynamicPath) {
+			console.warn(
+				`Router warning: Wildcard route \`${wildcardPath}\` should not be at the same level as dynamic route \`${dynamicPath}\`.`,
+			);
+		}
+	}
+}
+
+/**
+ * @param {import('../index.d.ts').Routes} routes
+ * @returns {string[]}
+ */
+export function getRoutePaths(routes) {
+	const paths = [];
+	for (const [key, value] of Object.entries(routes)) {
+		if (typeof value === 'object') {
+			paths.push(
+				...getRoutePaths(value).map((path) => {
+					if (path === '*') {
+						return key + '/*';
+					}
+					if (path === '/') {
+						return key;
+					}
+					return key + path;
+				}),
+			);
+		} else {
+			paths.push(key);
+		}
+	}
+	return paths;
+}

package/src/index.d.ts

@@ -0,0 +1,77 @@
+import type { Component, Snippet } from 'svelte';
+
+/**
+ * Setup a new router instance with the given routes.
+ *
+ * ```js
+ * export const { path, goto, params } = createRouter({
+ *   '/': Home,
+ *   '/about': About,
+ *   ...
+ * });
+ * ```
+ */
+export function createRouter<T extends Routes>(r: T): RouterMethods<T>;
+export const Router: Component;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+type BaseProps = {};
+
+export type LazyRouteComponent<Props extends BaseProps = BaseProps> = () => Promise<{
+	default: Component<Props>;
+}>;
+
+export type RouteComponent<Props extends BaseProps = any> =
+	| Component<Props>
+	| LazyRouteComponent<Props>;
+export type LayoutComponent = RouteComponent<{ children: Snippet }>;
+
+export type Routes = {
+	[_: `/${string}`]: RouteComponent | Routes;
+	'*'?: RouteComponent;
+	layout?: LayoutComponent;
+};
+
+export type RouterMethods<T extends Routes> = {
+	path<U extends Path<T>>(...args: ConstructPathArgs<U>): string;
+	goto<U extends Path<T>>(...args: ConstructPathArgs<U>): void;
+	params(): AllParams<T>;
+};
+
+export type Path<T extends Routes> = RemoveParenthesis<
+	RemoveLastSlash<RecursiveKeys<StripNonRoutes<T>>>
+>;
+
+export type ConstructPathArgs<T extends string> =
+	PathParams<T> extends never ? [T] : [T, PathParams<T>];
+
+export type PathParams<T extends string> =
+	ExtractParams<T> extends never ? never : Record<ExtractParams<T>, string>;
+
+export type AllParams<T extends Routes> = Partial<Record<ExtractParams<RecursiveKeys<T>>, string>>;
+
+type StripNonRoutes<T extends Routes> = {
+	[K in keyof T as K extends '*' ? never : K extends 'layout' ? never : K]: T[K] extends Routes
+		? StripNonRoutes<T[K]>
+		: T[K];
+};
+
+type RecursiveKeys<T extends Routes, Prefix extends string = ''> = {
+	[K in keyof T]: K extends string
+		? T[K] extends Routes
+			? RecursiveKeys<T[K], `${Prefix}${K}`>
+			: `${Prefix}${K}`
+		: never;
+}[keyof T];
+
+type RemoveLastSlash<T extends string> = T extends '/' ? T : T extends `${infer R}/` ? R : T;
+
+type RemoveParenthesis<T extends string> = T extends `${infer A}(${infer B})${infer C}`
+	? RemoveParenthesis<`${A}${B}${C}`>
+	: T;
+
+type ExtractParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}`
+	? Param | ExtractParams<`/${Rest}`>
+	: T extends `${string}:${infer Param}`
+		? Param
+		: never;

package/src/index.js

@@ -0,0 +1,2 @@
+export { createRouter } from './create-router.svelte.js';
+export { default as Router } from './Router.svelte';

package/src/vite-plugin/index.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vite';
+
+export type RouterOptions = {
+	/**
+	 * The path to the routes folder.
+	 *
+	 * @default 'src/routes'
+	 */
+	path?: string;
+};
+
+export const router: (options?: RouterOptions) => Plugin;

package/src/vite-plugin/index.js

@@ -0,0 +1 @@
+export { router } from './plugin.js';

package/src/vite-plugin/plugin.js

@@ -0,0 +1,42 @@
+import path from 'node:path';
+import { genConfig } from '../gen/config.js';
+import { writeRouterCode } from '../gen/write-router-code.js';
+
+/**
+ * @param {import('./index.d.ts').RouterOptions | undefined} options
+ * @returns {import('vite').Plugin}
+ */
+export function router(options) {
+	if (options?.path) {
+		genConfig.routesPath = options.path;
+	}
+
+	return {
+		name: 'sv-router',
+		config(config) {
+			if (!config.resolve) {
+				config.resolve = {};
+			}
+			if (!config.resolve.alias) {
+				config.resolve.alias = {};
+			}
+
+			const replacement = path.resolve(process.cwd(), genConfig.routerPath);
+
+			if (Array.isArray(config.resolve.alias)) {
+				config.resolve.alias.push({ find: genConfig.genCodeAlias, replacement });
+			} else {
+				/** @type {Record<string, string>} */ (config.resolve.alias)[genConfig.genCodeAlias] =
+					replacement;
+			}
+		},
+		buildStart() {
+			writeRouterCode();
+		},
+		watchChange(file) {
+			if (file.includes(genConfig.routesPath)) {
+				writeRouterCode();
+			}
+		},
+	};
+}

package/dist/RecursiveComponentTree.svelte.d.ts

@@ -1,8 +0,0 @@
-import type { Component } from 'svelte';
-import RecursiveComponentTree from './RecursiveComponentTree.svelte';
-type $$ComponentProps = {
-    tree: Component[];
-};
-declare const RecursiveComponentTree: Component<$$ComponentProps, {}, "">;
-type RecursiveComponentTree = ReturnType<typeof RecursiveComponentTree>;
-export default RecursiveComponentTree;

package/dist/helpers/construct-path.d.ts

@@ -1,3 +0,0 @@
-import type { PathParams } from '../types/types.ts';
-export type ConstructPathArgs<T extends string> = PathParams<T> extends never ? [T] : [T, PathParams<T>];
-export declare function constructPath<T extends string>(...args: ConstructPathArgs<T>): string;

package/dist/helpers/construct-path.js

@@ -1,10 +0,0 @@
-export function constructPath(...args) {
-    const [path, params] = args;
-    if (!params)
-        return path;
-    let result = path;
-    for (const key in params) {
-        result = result.replace(`:${key}`, params[key]);
-    }
-    return result;
-}

package/dist/helpers/match-route.d.ts

@@ -1,7 +0,0 @@
-import type { LayoutComponent, RouteComponent, Routes } from '../types/types.ts';
-export declare function matchRoute(pathname: string, routes: Routes): {
-    match: RouteComponent | undefined;
-    layouts: LayoutComponent[];
-    params: Record<string, string>;
-};
-export declare function sortRoutes(routes: string[]): string[];

package/dist/helpers/match-route.js

@@ -1,65 +0,0 @@
-export function matchRoute(pathname, routes) {
-    // Remove trailing slash
-    if (pathname.length > 1 && pathname.endsWith('/')) {
-        pathname = pathname.slice(0, -1);
-    }
-    const pathParts = pathname.split('/');
-    const allRouteParts = sortRoutes(Object.keys(routes)).map((route) => route.split('/'));
-    let match;
-    const layouts = [];
-    let params = {};
-    outer: for (const routeParts of allRouteParts) {
-        for (const [index, routePart] of sortRoutes(routeParts).entries()) {
-            const pathPart = pathParts[index];
-            if (routePart.startsWith(':')) {
-                params[routePart.slice(1)] = pathPart;
-            }
-            else if (routePart === '*') {
-                match = routes[routeParts.join('/')];
-                break outer;
-            }
-            else if (routePart !== pathPart) {
-                break;
-            }
-            const routeMatch = routes[routeParts.join('/')];
-            if (typeof routeMatch !== 'function' &&
-                routeMatch?.layout &&
-                !layouts.includes(routeMatch.layout)) {
-                layouts.push(routeMatch.layout);
-            }
-            if (index === routeParts.length - 1) {
-                if (typeof routeMatch === 'function') {
-                    if (routeParts.length === pathParts.length) {
-                        match = routeMatch;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                else if (routeMatch) {
-                    const nestedPathname = '/' + pathParts.slice(index + 1).join('/');
-                    const result = matchRoute(nestedPathname, routeMatch);
-                    if (result) {
-                        match = result.match;
-                        params = { ...params, ...result.params };
-                        layouts.push(...result.layouts);
-                    }
-                }
-                break outer;
-            }
-        }
-    }
-    return { match, layouts, params };
-}
-export function sortRoutes(routes) {
-    return routes.toSorted((a, b) => getRoutePriority(a) - getRoutePriority(b));
-}
-function getRoutePriority(route) {
-    if (route === '' || route === '/')
-        return 1;
-    if (route === '*')
-        return 4;
-    if (route.includes(':'))
-        return 3;
-    return 2;
-}

package/dist/helpers/match-route.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/helpers/match-route.test.js

@@ -1,133 +0,0 @@
-import { matchRoute, sortRoutes } from "./match-route.js";
-const Home = (() => 'Home');
-const Posts = (() => 'Posts');
-const StaticPost = (() => 'StaticPost');
-const DynamicPost = (() => 'DynamicPost');
-const DynamicPostComment = (() => 'DynamicPostComment');
-const UserNotFound = (() => 'UserNotFound');
-const PageNotFound = (() => 'PageNotFound');
-const Layout1 = (() => 'Layout1');
-const Layout2 = (() => 'Layout2');
-describe('matchRoute', () => {
-    describe.each([
-        {
-            mode: 'flat',
-            routes: {
-                '/': Home,
-                '/posts': Posts,
-                '/posts/static': StaticPost,
-                '/posts/:id': DynamicPost,
-                '/posts/:id/:commentId': DynamicPostComment,
-                '/users/*': UserNotFound,
-                '*': PageNotFound,
-            },
-        },
-        {
-            mode: 'flat unordered',
-            routes: {
-                '/posts/:id/:commentId': DynamicPostComment,
-                '/posts': Posts,
-                '/users/*': UserNotFound,
-                '/posts/static': StaticPost,
-                '*': PageNotFound,
-                '/posts/:id': DynamicPost,
-                '/': Home,
-            },
-        },
-        {
-            mode: 'tree',
-            routes: {
-                '/': Home,
-                '/posts': {
-                    '/': Posts,
-                    '/static': StaticPost,
-                    '/:id': {
-                        '/': DynamicPost,
-                        '/:commentId': DynamicPostComment,
-                        layout: Layout2,
-                    },
-                    layout: Layout1,
-                },
-                '/users/*': UserNotFound,
-                '*': PageNotFound,
-            },
-        },
-        {
-            mode: 'tree unordered',
-            routes: {
-                '*': PageNotFound,
-                '/posts': {
-                    '/:id': {
-                        '/:commentId': DynamicPostComment,
-                        '/': DynamicPost,
-                        layout: Layout2,
-                    },
-                    '/': Posts,
-                    '/static': StaticPost,
-                    layout: Layout1,
-                },
-                '/users/*': UserNotFound,
-                '/': Home,
-            },
-        },
-    ])('$mode paths', ({ mode, routes: r }) => {
-        const routes = r;
-        it('should match the root route', () => {
-            const { match } = matchRoute('/', routes);
-            expect(match).toEqual(Home);
-        });
-        it('should match a simple route', () => {
-            const { match } = matchRoute('/posts', routes);
-            expect(match).toEqual(Posts);
-        });
-        it('should match a simple route with a trailing slash', () => {
-            const { match } = matchRoute('/posts', routes);
-            expect(match).toEqual(Posts);
-        });
-        it('should match a nested route', () => {
-            const { match } = matchRoute('/posts/static', routes);
-            expect(match).toEqual(StaticPost);
-        });
-        it('should match a dynamic route and return a param', () => {
-            const { match, params } = matchRoute('/posts/bar', routes);
-            expect(match).toEqual(DynamicPost);
-            expect(params).toEqual({ id: 'bar' });
-        });
-        it('should match multiple dynamic nested routes and return params', () => {
-            const { match, params } = matchRoute('/posts/bar/baz', routes);
-            expect(match).toEqual(DynamicPostComment);
-            expect(params).toEqual({ id: 'bar', commentId: 'baz' });
-        });
-        if (mode === 'nested') {
-            it('should match routes with layout', () => {
-                const { layouts: layouts1 } = matchRoute('/', routes);
-                const { layouts: layouts2 } = matchRoute('/posts', routes);
-                const { layouts: layouts3 } = matchRoute('/posts/static', routes);
-                const { layouts: layouts4 } = matchRoute('/posts/bar/baz', routes);
-                expect(layouts1).toEqual([]);
-                expect(layouts2).toEqual([Layout1]);
-                expect(layouts3).toEqual([Layout1]);
-                expect(layouts4).toEqual([Layout1, Layout2]);
-            });
-        }
-        it('should match wildcard nested route', () => {
-            const { match } = matchRoute('/users/notfound', routes);
-            expect(match).toEqual(UserNotFound);
-        });
-        it('should match wildcard route', () => {
-            const { match } = matchRoute('/notfound', routes);
-            expect(match).toEqual(PageNotFound);
-        });
-        it('should not match any route', () => {
-            delete routes['*'];
-            const { match } = matchRoute('/notfound', routes);
-            expect(match).toBeUndefined();
-        });
-    });
-});
-describe('sortRoutes', () => {
-    it('should sort routes', () => {
-        const result = sortRoutes(['/:id', '*', '/foo', '', '/']);
-        expect(result).toEqual(['', '/', '/foo', '/:id', '*']);
-    });
-});

package/dist/helpers/utils.d.ts

@@ -1,5 +0,0 @@
-import type { Component } from 'svelte';
-import type { LazyRouteComponent, RouteComponent } from '../types/types.ts';
-export declare function resolveRouteComponents(input: RouteComponent<any>[]): Promise<Component[]>;
-export declare function resolveRouteComponent(input: RouteComponent): Promise<Component>;
-export declare function isLazyImport(input: unknown): input is LazyRouteComponent;

package/dist/helpers/utils.js

@@ -1,18 +0,0 @@
-export function resolveRouteComponents(input) {
-    return Promise.all(input.map((c) => resolveRouteComponent(c)));
-}
-export function resolveRouteComponent(input) {
-    return new Promise((resolve) => {
-        if (isLazyImport(input)) {
-            Promise.resolve(input()).then((module) => {
-                resolve(module.default);
-            });
-        }
-        else {
-            resolve(input);
-        }
-    });
-}
-export function isLazyImport(input) {
-    return typeof input === 'function' && !!/\(\)\s?=>\s?import\(.*\)/g.test(String(input));
-}

package/dist/helpers/validate-routes.d.ts

@@ -1,3 +0,0 @@
-import type { Routes } from '../types/types.ts';
-export declare function validateRoutes(routes: Routes): void;
-export declare function getRoutePaths(routes: Routes): string[];

package/dist/helpers/validate-routes.js

@@ -1,34 +0,0 @@
-export function validateRoutes(routes) {
-    const paths = getRoutePaths(routes);
-    const wildcardPaths = paths.filter((path) => path.endsWith('*'));
-    for (const wildcardPath of wildcardPaths) {
-        const parentPath = wildcardPath.slice(0, -1);
-        const dynamicPath = paths.find((p) => p !== '/' &&
-            !p.endsWith('*') &&
-            p.startsWith(parentPath === '' ? '/:' : parentPath) &&
-            p.match(/:[^/]*$/g));
-        if (dynamicPath) {
-            console.warn(`Router warning: Wildcard route \`${wildcardPath}\` should not be at the same level as dynamic route \`${dynamicPath}\`.`);
-        }
-    }
-}
-export function getRoutePaths(routes) {
-    const paths = [];
-    for (const [key, value] of Object.entries(routes)) {
-        if (typeof value === 'object') {
-            paths.push(...getRoutePaths(value).map((path) => {
-                if (path === '*') {
-                    return key + '/*';
-                }
-                if (path === '/') {
-                    return key;
-                }
-                return key + path;
-            }));
-        }
-        else {
-            paths.push(key);
-        }
-    }
-    return paths;
-}

package/dist/helpers/validate-routes.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/helpers/validate-routes.test.js

@@ -1,67 +0,0 @@
-import { getRoutePaths, validateRoutes } from "./validate-routes.js";
-const component = (() => ({}));
-const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(vi.fn());
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('validateRoutes', () => {
-    it('should validate routes', () => {
-        validateRoutes({
-            '/': component,
-            '/about': component,
-            '/posts': {
-                '/': component,
-                '/:id': component,
-            },
-            '*': component,
-        });
-        expect(consoleSpy).not.toHaveBeenCalled();
-    });
-    it('should raise a warning if a wildcard route is at the same level as a dynamic route', () => {
-        validateRoutes({
-            '/': component,
-            '/:id': component,
-            '*': component,
-        });
-        expect(consoleSpy).toHaveBeenCalledWith('Router warning: Wildcard route `*` should not be at the same level as dynamic route `/:id`.');
-    });
-    it.each([
-        {
-            '/': component,
-            '/posts/*': component,
-            '/posts/:id': component,
-            '/:id': component,
-            '*': component,
-        },
-        {
-            '/': component,
-            '/posts': {
-                '*': component,
-                '/:id': component,
-            },
-            '/:id': component,
-            '*': component,
-        },
-    ])('should raise multiple warnings if wildcard routes are at the same level as dynamic routes', (routes) => {
-        validateRoutes(routes);
-        expect(consoleSpy).toHaveBeenCalledTimes(2);
-        expect(consoleSpy).toHaveBeenCalledWith('Router warning: Wildcard route `*` should not be at the same level as dynamic route `/:id`.');
-        expect(consoleSpy).toHaveBeenCalledWith('Router warning: Wildcard route `/posts/*` should not be at the same level as dynamic route `/posts/:id`.');
-    });
-});
-describe('getRoutePaths', () => {
-    it('should return all paths in an array', () => {
-        const result = getRoutePaths({
-            '/': component,
-            '/about': component,
-            '/posts': {
-                '/': component,
-                '/:id': component,
-                '*': component,
-            },
-            '/foo/bar': component,
-            '*': component,
-        });
-        expect(result).toEqual(['/', '/about', '/posts', '/posts/:id', '/posts/*', '/foo/bar', '*']);
-    });
-});

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export { default as Router } from './Router.svelte';
-export { createRouter } from './router.svelte.ts';

package/dist/index.js

@@ -1,2 +0,0 @@
-export { default as Router } from './Router.svelte';
-export { createRouter } from "./router.svelte.js";

package/dist/router.svelte.d.ts

@@ -1,13 +0,0 @@
-import type { Component } from 'svelte';
-import { type ConstructPathArgs } from './helpers/construct-path.ts';
-import type { AllParams, Path, Routes } from './types/types.ts';
-export declare let routes: Routes;
-export declare const componentTree: Component<{}, {}, string>[];
-export declare const paramsStore: Record<string, string>;
-export declare function createRouter<T extends Routes>(r: T): {
-    path<U extends Path<T>>(...args: ConstructPathArgs<U>): string;
-    goto<U extends Path<T>>(...args: ConstructPathArgs<U>): void;
-    params(): AllParams<T>;
-};
-export declare function onNavigate(): void;
-export declare function onGlobalClick(event: Event): void;

package/dist/router.svelte.js

@@ -1,50 +0,0 @@
-import { BROWSER, DEV } from 'esm-env';
-import { constructPath } from "./helpers/construct-path.js";
-import { matchRoute } from "./helpers/match-route.js";
-import { resolveRouteComponents } from "./helpers/utils.js";
-export let routes;
-export const componentTree = $state([]);
-export const paramsStore = $state({});
-export function createRouter(r) {
-    routes = r;
-    if (DEV && BROWSER) {
-        import('./helpers/validate-routes.ts').then(({ validateRoutes }) => {
-            validateRoutes(routes);
-        });
-    }
-    return {
-        path(...args) {
-            return constructPath(...args);
-        },
-        goto(...args) {
-            const path = constructPath(...args);
-            globalThis.history.pushState({}, '', path);
-            onNavigate();
-        },
-        params() {
-            const readonly = $derived(paramsStore);
-            return readonly;
-        },
-    };
-}
-export function onNavigate() {
-    const { match, layouts, params } = matchRoute(globalThis.location.pathname, routes);
-    resolveRouteComponents(match ? [...layouts, match] : layouts).then((components) => {
-        Object.assign(componentTree, components);
-    });
-    Object.assign(paramsStore, params);
-}
-export function onGlobalClick(event) {
-    const anchor = event.target.closest('a');
-    if (!anchor)
-        return;
-    if (anchor.hasAttribute('target') || anchor.hasAttribute('download'))
-        return;
-    const url = new URL(anchor.href);
-    const currentOrigin = globalThis.location.origin;
-    if (url.origin !== currentOrigin)
-        return;
-    event.preventDefault();
-    globalThis.history.pushState({}, '', anchor.href);
-    onNavigate();
-}

package/dist/types/test-types.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/test-types.js

@@ -1 +0,0 @@
-export {};

package/dist/types/types.d.ts

@@ -1,26 +0,0 @@
-import type { Component, Snippet } from 'svelte';
-type BaseProps = Record<string, any>;
-export type LazyRouteComponent<Props extends BaseProps = BaseProps> = () => Promise<{
-    default: Component<Props>;
-}>;
-export type RouteComponent<Props extends BaseProps = BaseProps> = Component<Props> | LazyRouteComponent<Props>;
-export type LayoutComponent = RouteComponent<{
-    children: Snippet;
-}>;
-export type Routes = {
-    [_: `/${string}`]: RouteComponent | Routes;
-    '*'?: RouteComponent;
-    layout?: LayoutComponent;
-};
-export type Path<T extends Routes> = RemoveLastSlash<RecursiveKeys<StripNonRoutes<T>>>;
-export type PathParams<T extends string> = ExtractParams<T> extends never ? never : Record<ExtractParams<T>, string>;
-export type AllParams<T extends Routes> = Partial<Record<ExtractParams<RecursiveKeys<T>>, string>>;
-type StripNonRoutes<T extends Routes> = {
-    [K in keyof T as K extends '*' ? never : K extends 'layout' ? never : K]: T[K] extends Routes ? StripNonRoutes<T[K]> : T[K];
-};
-type RecursiveKeys<T extends Routes, Prefix extends string = ''> = {
-    [K in keyof T]: K extends string ? T[K] extends Routes ? RecursiveKeys<T[K], `${Prefix}${K}`> : `${Prefix}${K}` : never;
-}[keyof T];
-type RemoveLastSlash<T extends string> = T extends '/' ? T : T extends `${infer R}/` ? R : T;
-type ExtractParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractParams<`/${Rest}`> : T extends `${string}:${infer Param}` ? Param : never;
-export {};

package/dist/types/types.js

@@ -1 +0,0 @@
-export {};