@torpor/build 0.4.4 → 0.4.6

package/package.json

@@ -1,36 +1,36 @@
 {
   "name": "@torpor/build",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "A framework for building sites and apps with Torpor",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     },
     "./nav": {
-      "types": "./dist/nav.d.ts",
-      "import": "./dist/nav.js"
+      "types": "./dist/nav.d.mts",
+      "import": "./dist/nav.mjs"
     },
     "./response": {
-      "types": "./dist/response.d.ts",
-      "import": "./dist/response.js"
+      "types": "./dist/response.d.mts",
+      "import": "./dist/response.mjs"
     },
     "./run": {
-      "types": "./dist/run.d.ts",
-      "import": "./dist/run.js"
+      "types": "./dist/run.d.mts",
+      "import": "./dist/run.mjs"
     },
     "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js"
+      "types": "./dist/server.d.mts",
+      "import": "./dist/server.mjs"
     },
     "./state": {
-      "types": "./dist/state.d.ts",
-      "import": "./dist/state.js"
+      "types": "./dist/state.d.mts",
+      "import": "./dist/state.mjs"
     },
     "./test": {
-      "types": "./dist/test.d.ts",
-      "import": "./dist/test.js"
+      "types": "./dist/test.d.mts",
+      "import": "./dist/test.mjs"
     },
     "./manifest": {
       "types": "./src/types/manifest.d.ts"
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "bin": {
-    "tb": "./dist/bin/index.js"
+    "tb": "./dist/bin/index.mjs"
   },
   "keywords": [],
   "author": "",
@@ -48,23 +48,25 @@
   "dependencies": {
     "cookie": "^1.0.2",
     "dotenv": "^17.2.3",
-    "vite": "^7.1.12",
+    "vite": "^7.2.2",
     "vite-tsconfig-paths": "^5.1.4",
     "@torpor/unplugin": "^0.2.1",
-    "@torpor/view": "^0.4.7"
+    "@torpor/view": "^0.4.14"
   },
   "devDependencies": {
-    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@typescript/native-preview": "7.0.0-dev.20251103.1",
-    "oxlint-tsgolint": "^0.4.0",
-    "tsdown": "^0.15.12",
+    "@trivago/prettier-plugin-sort-imports": "^6.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20251112.1",
+    "esno": "^4.8.0",
+    "oxlint-tsgolint": "^0.6.0",
+    "tsdown": "^0.16.4",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.6"
+    "vitest": "^4.0.8"
   },
   "scripts": {
+    "check": "tsgo --noEmit && pnpm dlx oxlint --type-aware",
     "build": "tsgo --noEmit && tsdown",
+    "build:fix": "esno scripts/postbuild.ts",
     "build:watch": "tsdown --watch",
-    "check": "tsgo --noEmit && pnpm dlx oxlint --type-aware",
     "test": "vitest"
   }
 }

package/scripts/postbuild.ts

@@ -0,0 +1,12 @@
+import { renameSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// HACK: tsdown only creates *.mjs files now (post v0.16), so we need to rename
+// the bin/index.mjs file to bin/index.js for it to be run by node
+
+const scriptsFolder = dirname(fileURLToPath(import.meta.url));
+const distFolder = resolve(scriptsFolder, "../dist");
+
+renameSync(join(distFolder, "bin", "index.mjs"), join(distFolder, "bin", "index.js"));
+renameSync(join(distFolder, "bin", "index.mjs.map"), join(distFolder, "bin", "index.js.map"));

package/src/nav/formSubmit.ts

@@ -12,6 +12,7 @@ export default async function formSubmit(e: SubmitEvent): Promise<void> {
 
 	// Perform a POST fetch to the form's action location
 	const form = e.target as HTMLFormElement;
+	const action = (e.submitter as HTMLButtonElement)?.formAction ?? form.action;
 	const options = {
 		body: new FormData(form),
 		method: "POST",
@@ -25,7 +26,7 @@ export default async function formSubmit(e: SubmitEvent): Promise<void> {
 		},
 	};
 	const response = await fetch(
-		form.action,
+		action,
 		// @ts-ignore -- don't know what it's complaining about here
 		options,
 	);

package/src/nav/loadData.ts

@@ -8,6 +8,7 @@ export default async function loadData(
 	handler: RouteHandler,
 	params: Record<string, string>,
 	path: string,
+	query: URLSearchParams,
 	newLayoutStack: LayoutPath[],
 	clientEndPoint: PageEndPoint | undefined,
 	serverEndPoint: PageServerEndPoint | undefined,
@@ -36,6 +37,7 @@ export default async function loadData(
 				const layoutResponse = await loadClientAndServerData(
 					stackLayout.data,
 					document.location.origin + layoutPath,
+					query,
 					params,
 					layoutEndPoint,
 					layoutServerEndPoint,
@@ -51,6 +53,7 @@ export default async function loadData(
 	let endPointResponse = await loadClientAndServerData(
 		data,
 		document.location.origin + path,
+		query,
 		params,
 		clientEndPoint,
 		serverEndPoint,
@@ -64,6 +67,7 @@ export default async function loadData(
 async function loadClientAndServerData(
 	data: Record<string, any>,
 	location: string,
+	query: URLSearchParams,
 	params: Record<string, string>,
 	clientEndPoint?: PageEndPoint,
 	serverEndPoint?: PageServerEndPoint,
@@ -75,6 +79,9 @@ async function loadClientAndServerData(
 			Object.assign(data, prefetchedData[location]);
 		} else {
 			const clientUrl = new URL(document.location.href);
+			for (let [name, value] of query) {
+				clientUrl.searchParams.append(name, value);
+			}
 			const clientParams = buildClientParams(clientUrl, params, data);
 			const clientResponse = await clientEndPoint.load(clientParams);
 			if (clientResponse) {
@@ -90,19 +97,23 @@ async function loadClientAndServerData(
 			}
 		}
 	}
-	if (serverEndPoint?.load) {
-		const serverUrl = location.replace(/\/$/, "") + "/~server";
 
-		if (prefetchedData[serverUrl]) {
-			Object.assign(data, prefetchedData[serverUrl]);
+	if (serverEndPoint?.load) {
+		const serverLocation = location.replace(/\/$/, "") + "/~server";
+		if (prefetchedData[serverLocation]) {
+			Object.assign(data, prefetchedData[serverLocation]);
 		} else {
+			const serverUrl = new URL(serverLocation);
+			for (let [name, value] of query) {
+				serverUrl.searchParams.append(name, value);
+			}
 			const serverResponse = await fetch(serverUrl);
 			if (serverResponse) {
 				if (serverResponse.ok) {
 					if (serverResponse.headers.get("Content-Type")?.includes("application/json")) {
 						const serverData = await serverResponse.json();
 						Object.assign(data, serverData);
-						prefetchedData[serverUrl] = serverData;
+						prefetchedData[serverLocation] = serverData;
 					}
 				} else {
 					return serverResponse;

package/src/nav/navigate.ts

@@ -64,6 +64,7 @@ export default async function navigate(url: URL, withHydration = false): Promise
 		handler,
 		params,
 		path,
+		query,
 		newLayoutStack,
 		clientEndPoint,
 		serverEndPoint,

package/src/site/Router.ts

@@ -23,6 +23,7 @@ export default class Router {
 					path: r.path,
 					type: r.type,
 					endPoint: r.endPoint,
+					subFolder: r.subFolder,
 				}),
 			);
 		}
@@ -31,12 +32,13 @@ export default class Router {
 	}
 
 	// TODO: Allow calling with the endpoint itself, so that you can setup an app with no scaffold
-	addPage(path: string, type: number, endPoint: () => Promise<any>): this {
+	addPage(path: string, type: number, endPoint: () => Promise<any>, subFolder?: string): this {
 		this.routes.push(
 			new Route(path, {
 				path,
 				type,
 				endPoint,
+				subFolder,
 			}),
 		);
 		this.#sortRoutes();
@@ -53,7 +55,7 @@ export default class Router {
 	}
 	*/
 
-	match(path: string, query: URLSearchParams): Match | undefined {
+	match(path: string, query: URLSearchParams): RouteMatch | undefined {
 		for (let route of this.routes) {
 			let match = path.match(route.regex);
 			if (match) {
@@ -69,17 +71,15 @@ export default class Router {
 				};
 			}
 		}
-
-		console.log(`not found: '${path}'`);
 	}
 
 	#loadHandler(handler: RouteHandler, path: string) {
-		handler.layouts = this.#findLayouts(path);
+		handler.layouts = this.#findLayouts(path, handler);
 		handler.serverEndPoint = this.#findServer(path);
-		handler.serverHook = this.#findServerHook(path);
+		handler.serverHook = this.#findServerHook(handler);
 	}
 
-	#findLayouts(path: string): LayoutHandler[] | undefined {
+	#findLayouts(path: string, handler: RouteHandler): LayoutHandler[] | undefined {
 		let layouts: LayoutHandler[] = [];
 		let parts = path
 			// Strip the trailing`~/server` (so we don't look for `~/server/_layout`
@@ -96,7 +96,7 @@ export default class Router {
 			}
 			const layoutPath = basePath + "/_layout";
 			const layoutRoute = this.routes.find((r) => r.path === layoutPath);
-			if (layoutRoute) {
+			if (layoutRoute && layoutRoute.handler.subFolder === handler.subFolder) {
 				layouts.push({
 					path: layoutPath,
 					endPoint: layoutRoute.handler.endPoint,
@@ -113,12 +113,11 @@ export default class Router {
 		return serverRoute && serverRoute.handler.endPoint;
 	}
 
-	#findServerHook(path: string): (() => Promise<any>) | undefined {
+	#findServerHook(handler: RouteHandler): (() => Promise<any>) | undefined {
 		// TODO: Should this be a collection, like layouts?
 		let serverHookPath = "/_hook/~server";
-		// HACK: Generalise this
-		if (path.startsWith("/api/")) {
-			serverHookPath = "/api" + serverHookPath;
+		if (handler.subFolder !== undefined) {
+			serverHookPath = handler.subFolder + serverHookPath;
 		}
 		const serverHookRoute = this.routes.find((r) => r.path === serverHookPath);
 		return serverHookRoute && serverHookRoute.handler.endPoint;
@@ -158,7 +157,7 @@ class Route {
 	}
 }
 
-interface Match {
+interface RouteMatch {
 	handler: RouteHandler;
 	params?: Record<string, string>;
 	query: URLSearchParams;

package/src/site/Site.ts

@@ -3,6 +3,7 @@ import fpath from "node:path";
 import { type Plugin, type UserConfig } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
 import type Adapter from "../types/Adapter";
+import type Route from "../types/Route";
 import {
 	ERROR_ROUTE,
 	HOOK_ROUTE,
@@ -27,7 +28,7 @@ import defaultAdapter from "./defaultAdapter";
  */
 export default class Site {
 	root: string;
-	routes: { path: string; file: string; type: RouteType }[] = [];
+	routes: Route[] = [];
 	// Is default plugins a bad idea?
 	// HACK: Set loose because otherwise it uses a list of allowed extensions
 	// TODO: Should probably just do this ourselves and let the user pass in
@@ -56,17 +57,32 @@ export default class Site {
 	/**
 	 * Adds a folder of routes, based on the names of the files in the folder
 	 * @param folder The folder containing the routes
+	 * @param subFolder If a subFolder is set, all routes in the folder will be
+	 * placed under the subFolder, and only hooks, layouts etc will be used if
+	 * they have the same subFolder. This can be used to create e.g. an `api`
+	 * set of routes with their own hook for authorization from various clients
 	 */
-	async addRouteFolder(folder: string): Promise<void> {
+	async addRouteFolder(folder: string, subFolder?: string): Promise<void> {
 		const routeFolder = fpath.join(this.root, folder);
 		const routeFiles = await fs.readdir(routeFolder, { recursive: true });
+		if (subFolder !== undefined && !subFolder.startsWith("/")) {
+			subFolder = "/" + subFolder;
+		}
 		for (let file of routeFiles) {
 			// The file must start with `+` or `_` and end with `.js` or `.ts`
 			if (/^(\+|_).+(\.js|\.ts)$/.test(fpath.basename(file))) {
 				let routePath = this.#routePath(file);
+				if (subFolder !== undefined) {
+					routePath = subFolder + routePath;
+				}
 				let type = this.#routeType(file);
 				file = fpath.relative(this.root, fpath.resolve(routeFolder, file));
-				this.routes.push({ path: routePath, file, type });
+				this.routes.push({
+					path: routePath,
+					file,
+					type,
+					subFolder: subFolder,
+				});
 			}
 		}
 		this.#sortRoutes();
@@ -91,10 +107,19 @@ export default class Site {
 			| "_hook"
 			| "_hook.server"
 			| "_error",
+		subFolder?: string,
 	): void {
 		let routePath = this.#routePath(fpath.join(path, type ?? fpath.basename(file)));
 		let routeType = type ? this.#routeTypeFromString(type) : this.#routeType(file);
-		this.routes.push({ path: routePath, file, type: routeType });
+		if (subFolder !== undefined && !subFolder.startsWith("/")) {
+			subFolder = "/" + subFolder;
+		}
+		this.routes.push({
+			path: routePath,
+			file,
+			type: routeType,
+			subFolder: subFolder,
+		});
 		this.#sortRoutes();
 	}
 

package/src/site/clientEntry.ts

@@ -72,7 +72,7 @@ async function maybePrefetch(e: MouseEvent | TouchEvent) {
 			// Just dummy this up
 			let newStack: LayoutPath[] = [];
 
-			await loadData(handler, params, path, newStack, clientEndPoint, serverEndPoint, true);
+			await loadData(handler, params, path, query, newStack, clientEndPoint, serverEndPoint, true);
 		}
 	}
 }

package/src/site/manifest.ts

@@ -30,16 +30,19 @@ export default {
   routes: [
     ${site.routes
 			.map((r) => {
+				let endPoint: string;
 				if (serverRequest || !/server\.(ts|js)$/.test(r.file)) {
-					return `{ path: "${r.path}", type: ${r.type}, endPoint: ${serverRequest || !/server\.(ts|js)$/.test(r.file) ? `() => import(/* @vite-ignore */ "${path.join(site.root, r.file)}")` : "undefined"} }`;
+					endPoint = `() => import(/* @vite-ignore */ "${path.join(site.root, r.file)}")`;
 				} else {
 					// On the client, for a server route, we need to check
 					// whether there's a load function and set a dummy endPoint
 					// if so. The correct endpoint will be hit in clientEntry
 					// HACK: Should do this better than checking for `load:` in source...
 					const haveLoad = readFileSync(path.join(site.root, r.file)).includes("load:");
-					return `{ path: "${r.path}", type: ${r.type}, endPoint: ${haveLoad ? "() => load" : "undefined"} }`;
+					endPoint = haveLoad ? "() => load" : "undefined";
 				}
+				const sub = r.subFolder ? `"${r.subFolder}"` : "undefined";
+				return `{ path: "${r.path}", type: ${r.type}, endPoint: ${endPoint}, subFolder: ${sub} }`;
 			})
 			.join(",\n    ")}
   ],

package/src/test/runTest.ts

@@ -48,6 +48,7 @@ export default async function runTest(
 			path: r.path,
 			type: r.type,
 			endPoint: () => import(/* @vite-ignore */ path.join(site.root, r.file)),
+			subFolder: r.subFolder,
 		})),
 	);
 
@@ -201,17 +202,21 @@ async function loadView(
 	}
 	let $props: Record<string, any> = { data };
 
+	let styles = "";
+
 	// If there are layouts, work our way upwards, pushing each component into
 	// the default slot of its parent
 	// TODO: Also handle layout server data
 	// TODO: There's probably a nicer way to do this with reducers or something
-	// TODO: Re-use parent layouts
 	let component = clientEndPoint.component as ServerComponent;
 	let slots: Record<string, ServerSlotRender> | undefined = undefined;
 	if (handler.layouts) {
 		let slotFunctions: ServerSlotRender[] = [];
-		slotFunctions[handler.layouts.length] = (_, context) =>
-			(clientEndPoint.component as ServerComponent)($props, context);
+		slotFunctions[handler.layouts.length] = (_, $context) => {
+			let { body, head } = (clientEndPoint.component as ServerComponent)($props, $context);
+			styles += head;
+			return body;
+		};
 		for (let i = handler.layouts.length - 1; i >= 0; i--) {
 			const layoutEndPoint: PageEndPoint | undefined = (await handler.layouts[i].endPoint())
 				?.default;
@@ -220,10 +225,13 @@ async function loadView(
 					component = layoutEndPoint.component as ServerComponent;
 					slots = { _: slotFunctions[i + 1] };
 				} else {
-					slotFunctions[i] = (_, context) =>
-						(layoutEndPoint.component as ServerComponent)($props, context, {
+					slotFunctions[i] = (_, $context) => {
+						let { body, head } = (layoutEndPoint.component as ServerComponent)($props, $context, {
 							_: slotFunctions[i + 1],
 						});
+						styles += head;
+						return body;
+					};
 				}
 			}
 		}
@@ -232,7 +240,8 @@ async function loadView(
 	let html;
 	try {
 		let { body, head } = component($props, undefined, slots);
-		html = template.replace("%COMPONENT_BODY%", body).replace("%COMPONENT_HEAD", head);
+		styles += head;
+		html = template.replace("%COMPONENT_BODY%", body).replace("%COMPONENT_HEAD", styles);
 	} catch (error) {
 		// TODO: Show a proper Error component
 		html = '<span style="color: red">Script syntax error</span><p>' + error + "</p>";

package/src/types/ManifestRoute.ts

@@ -2,4 +2,5 @@ export default interface ManifestRoute {
 	path: string;
 	type: number;
 	endPoint: () => Promise<any>;
+	subFolder: string | undefined;
 }

package/src/types/Route.ts

@@ -0,0 +1,11 @@
+import { type RouteType } from "./RouteType";
+
+/**
+ * A route that is added to the Site.
+ */
+export default interface Route {
+	path: string;
+	file: string;
+	type: RouteType;
+	subFolder?: string;
+}

package/src/types/RouteHandler.ts

@@ -1,9 +1,13 @@
 import type RouteLayoutHandler from "./RouteLayoutHandler";
 
+/**
+ * A handler for a route in the Router.
+ */
 export default interface RouteHandler {
 	path: string;
 	type: number;
 	endPoint: () => Promise<any>;
+	subFolder?: string;
 
 	loaded?: boolean;
 	layouts?: RouteLayoutHandler[];

package/test/api/_hook.server.ts

@@ -0,0 +1,3 @@
+import type { ServerHook } from "@torpor/build";
+
+export default {} satisfies ServerHook as ServerHook;

package/test/api/posts/+page.server.ts

@@ -0,0 +1,3 @@
+import { type PageServerEndPoint } from "@torpor/build";
+
+export default {} satisfies PageServerEndPoint as PageServerEndPoint;

package/test/api/posts/[id]/+page.server.ts

@@ -0,0 +1,3 @@
+import { type PageServerEndPoint } from "@torpor/build";
+
+export default {} satisfies PageServerEndPoint as PageServerEndPoint;

package/test/router.test.ts

@@ -0,0 +1,78 @@
+import { assert, expect, test } from "vitest";
+import Router from "../src/site/Router";
+import { HOOK_SERVER_ROUTE, LAYOUT_ROUTE, PAGE_ROUTE } from "../src/types/RouteType";
+
+test("router method sorting", () => {
+	let r = new Router();
+	r.addPage("/posts/[id]", PAGE_ROUTE, async () => {});
+	r.addPage("/posts/drafts/[id]", PAGE_ROUTE, async () => {});
+	expect(r.routes.map((r) => r.path).join(",")).toBe("/posts/drafts/[id],/posts/[id]");
+});
+
+test("router matching", () => {
+	let r = new Router();
+	r.addPage("/posts", PAGE_ROUTE, async () => {});
+	const match = r.match("/posts", new URLSearchParams());
+	assert(match, "no match");
+	expect(match.params).toBeUndefined();
+	assert(match.handler, "no handler");
+});
+
+test("router matching with param", () => {
+	let r = new Router();
+	r.addPage("/posts/[id]", PAGE_ROUTE, async () => {});
+	r.addPage("/posts/drafts/[id]", PAGE_ROUTE, async () => {});
+	const match = r.match("/posts/5", new URLSearchParams());
+	assert(match, "no match");
+	assert(match.params, "no params");
+	expect(match.params["id"]).toBe("5");
+});
+
+test("router matching not found", () => {
+	let r = new Router();
+	r.addPage("/posts/[id]", PAGE_ROUTE, async () => {});
+	r.addPage("/posts/drafts/[id]", PAGE_ROUTE, async () => {});
+	const match = r.match("/postss/5", new URLSearchParams());
+	expect(match).toBeUndefined();
+});
+
+test("router matching layouts", () => {
+	let r = new Router();
+	r.addPage("/_layout", LAYOUT_ROUTE, async () => {});
+	r.addPage("/posts/_layout", LAYOUT_ROUTE, async () => {});
+	r.addPage("/posts/[id]", PAGE_ROUTE, async () => {});
+	r.addPage("/posts/drafts/[id]", PAGE_ROUTE, async () => {});
+	const match = r.match("/posts/5", new URLSearchParams());
+	assert(match, "no match");
+	assert(match.handler.layouts, "no layouts");
+	expect(match.handler.layouts.length).toBe(2);
+});
+
+test("router matching hook", () => {
+	let r = new Router();
+	r.addPage("/_hook/~server", HOOK_SERVER_ROUTE, async () => {});
+	r.addPage("/posts/[id]", PAGE_ROUTE, async () => {});
+	const match = r.match("/posts/5", new URLSearchParams());
+	assert(match, "no match");
+	assert(match.handler.serverHook, "no hook");
+});
+
+test("router matching base folder", async () => {
+	let r = new Router();
+	r.addPage("/_hook/~server", HOOK_SERVER_ROUTE, async () => {});
+	r.addPage("/_layout", LAYOUT_ROUTE, async () => {});
+	r.addPage("/posts/_layout", LAYOUT_ROUTE, async () => {});
+	r.addPage("/posts/[id]", PAGE_ROUTE, async () => {});
+	r.addPage("/api/posts/[id]", PAGE_ROUTE, async () => {}, "/api");
+	r.addPage("/api/_hook/~server", HOOK_SERVER_ROUTE, async () => "api hook", "/api");
+	const match = r.match("/api/posts/5", new URLSearchParams());
+	assert(match, "no match");
+	assert(match.params, "no params");
+	expect(match.params["id"]).toBe("5");
+
+	expect(match.handler.path).toBe("/api/posts/[id]");
+	assert(match.handler.serverHook, "no hook");
+	expect(await match.handler.serverHook()).toBe("api hook");
+
+	expect(match.handler.layouts).toBeUndefined();
+});

package/test/routes/+page.server.ts

@@ -0,0 +1,3 @@
+import { type PageServerEndPoint } from "@torpor/build";
+
+export default {} satisfies PageServerEndPoint as PageServerEndPoint;

package/test/routes/+page.ts

@@ -0,0 +1,3 @@
+import { type PageEndPoint } from "@torpor/build";
+
+export default {} satisfies PageEndPoint as PageEndPoint;

package/test/routes/_error.ts

@@ -0,0 +1,3 @@
+import { type PageEndPoint } from "@torpor/build";
+
+export default {} satisfies PageEndPoint as PageEndPoint;

package/test/routes/_hook.server.ts

@@ -0,0 +1,3 @@
+import type { ServerHook } from "@torpor/build";
+
+export default {} satisfies ServerHook as ServerHook;

package/test/routes/_layout.server.ts

@@ -0,0 +1,3 @@
+import type { PageServerEndPoint } from "@torpor/build";
+
+export default {} satisfies PageServerEndPoint as PageServerEndPoint;

package/test/routes/_layout.ts

@@ -0,0 +1,3 @@
+import { type PageEndPoint } from "@torpor/build";
+
+export default {} satisfies PageEndPoint as PageEndPoint;

package/test/routes/posts/+page.ts

@@ -0,0 +1,3 @@
+import { type PageEndPoint } from "@torpor/build";
+
+export default {} satisfies PageEndPoint as PageEndPoint;

package/test/routes/posts/[id]/+page.ts

@@ -0,0 +1,3 @@
+import { type PageEndPoint } from "@torpor/build";
+
+export default {} satisfies PageEndPoint as PageEndPoint;

package/test/site.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "vitest";
+import Site from "../src/site/Site";
+
+test("site routes", async () => {
+	let site = new Site();
+	await site.addRouteFolder("./test/routes");
+	expect(site.routes.map((r) => r.path).join("\n")).toBe(
+		`
+/
+/_error
+/_hook/~server
+/_layout
+/_layout/~server
+/~server
+/posts
+/posts/[id]
+`.trim(),
+	);
+});
+
+test("site routes with base folder", async () => {
+	let site = new Site();
+	await site.addRouteFolder("./test/routes");
+	await site.addRouteFolder("./test/api", "api");
+	expect(site.routes.map((r) => r.path).join("\n")).toBe(
+		`
+/
+/_error
+/_hook/~server
+/_layout
+/_layout/~server
+/~server
+/api/_hook/~server
+/api/posts/~server
+/api/posts/[id]/~server
+/posts
+/posts/[id]
+`.trim(),
+	);
+});