@pracht/adapter-static 0.2.1 → 1.0.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
+import { PrachtAdapter, PrachtAdapter as PrachtAdapter$1 } from "@pracht/core/adapter";
 import { HeadMetadata } from "@pracht/core";
-import { PrachtAdapter } from "@pracht/vite-plugin";
 import { IncomingMessage, ServerResponse } from "node:http";
 
 //#region src/static-entry.d.ts
@@ -41,7 +41,7 @@ declare function createStaticServerEntryModule(options?: StaticAdapterOptions):
  * was requested. Configuring `fallback` requires full hydration there, because
  * that document is built from the not-found page's serialized route state.
  */
-declare function staticAdapter(options?: StaticAdapterOptions): PrachtAdapter;
+declare function staticAdapter(options?: StaticAdapterOptions): PrachtAdapter$1;
 //#endregion
 //#region src/static-preview.d.ts
 interface StaticPreviewHandlerOptions {
@@ -61,6 +61,12 @@ interface StaticPreviewHandlerOptions {
    * export under a sub-path does.
    */
   base?: string | null;
+  /**
+   * `pracht({ trailingSlash })`. Under `"always"` or `"never"` a page asked
+   * for by its other spelling is redirected (308, query kept), the way a host
+   * configured for that URL shape does. Files are served as named.
+   */
+  trailingSlash?: "ignore" | "never" | "always" | null;
 }
 /**
  * A deliberately tiny static file server for `pracht preview` of static
@@ -72,4 +78,4 @@ interface StaticPreviewHandlerOptions {
  */
 declare function createStaticPreviewHandler(options: StaticPreviewHandlerOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
 //#endregion
-export { type StaticAdapterOptions, type StaticPreviewHandlerOptions, createStaticPreviewHandler, createStaticServerEntryModule, staticAdapter };
+export { type PrachtAdapter, type StaticAdapterOptions, type StaticPreviewHandlerOptions, createStaticPreviewHandler, createStaticServerEntryModule, staticAdapter };

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { resolveStaticFile } from "@pracht/adapter-node";
+import { decodeStaticPath, staticByteRange, staticPathCandidates } from "@pracht/core/server";
 //#region src/static-entry.ts
 const FALLBACK_FILENAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*\.html$/;
 const WINDOWS_RESERVED_FALLBACK_NAME_RE = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
@@ -105,6 +106,7 @@ function createStaticServerEntryModule(options = {}) {
 		"    staticDir: resolve(serverDir, \"../client\"),",
 		"    fallback: staticExportConfig.fallback,",
 		"    base: buildBase,",
+		"    trailingSlash: buildTrailingSlash,",
 		"  });",
 		"  const server = createServer(handler);",
 		`  const port = Number(process.env.PORT ?? ${port});`,
@@ -115,25 +117,6 @@ function createStaticServerEntryModule(options = {}) {
 		""
 	].join("\n");
 }
-/**
-* Create a pracht adapter for pure static export.
-*
-* ```ts
-* import { staticAdapter } from "@pracht/adapter-static";
-* pracht({ adapter: staticAdapter() })
-* ```
-*
-* `pracht build` prerenders every route into `dist/client/` — deploy that
-* directory to any static host. Build-time validation fails closed on
-* anything that needs a server: `render: "ssr"` / `"isg"` routes, SPA
-* loaders, request middleware, API routes, and network-exposed capabilities.
-* SSG loaders run at build time; static SPA routes are loaderless.
-*
-* The `notFound` page may use `hydration: "islands"` or `"none"` to keep the
-* client router out of `404.html`, at the cost of the page knowing which URL
-* was requested. Configuring `fallback` requires full hydration there, because
-* that document is built from the not-found page's serialized route state.
-*/
 function staticAdapter(options = {}) {
 	assertValidStaticAdapterOptions(options);
 	return {
@@ -153,19 +136,14 @@ function staticAdapter(options = {}) {
 }
 //#endregion
 //#region src/static-preview.ts
-/**
-* A deliberately tiny static file server for `pracht preview` of static
-* exports. It mirrors what a plain static host does — files, clean-URL
-* `index.html` resolution, `404.html` for misses, an optional SPA fallback —
-* and nothing else: no route matching, no loaders, no framework runtime.
-* Production deploys should use a real static host; this exists so the build
-* output can be exercised locally with one command.
-*/
 function createStaticPreviewHandler(options) {
 	const staticDir = resolve(options.staticDir);
 	const fallback = options.fallback ?? null;
 	const base = normalizePreviewBase(options.base);
-	const decodedBase = decodeStaticPreviewPathname(new URL(base, "http://localhost").pathname);
+	const trailingSlash = options.trailingSlash ?? "ignore";
+	const decodedBase = decodePathSegments(new URL(base, "http://localhost").pathname);
+	if (!decodedBase) throw new Error(`Unsafe static preview base ${JSON.stringify(base)}.`);
+	const baseSegments = decodedBase.slice(1, -1);
 	return async function handleStaticPreviewRequest(req, res) {
 		const method = req.method ?? "GET";
 		if (method !== "GET" && method !== "HEAD") {
@@ -178,31 +156,48 @@ function createStaticPreviewHandler(options) {
 		}
 		let pathname;
 		let search;
+		let publicPathname;
 		try {
 			const requestUrl = new URL(req.url ?? "/", "http://localhost");
-			pathname = decodeStaticPreviewPathname(requestUrl.pathname);
+			publicPathname = requestUrl.pathname;
+			pathname = requestUrl.pathname;
 			search = requestUrl.search;
 		} catch {
+			pathname = "";
+			search = "";
+			publicPathname = "";
+		}
+		if (!decodeStaticPath(pathname).ok || staticPathCandidates(pathname) === null) {
 			res.writeHead(400, { "content-type": "text/plain; charset=utf-8" });
 			res.end("Bad request");
 			return;
 		}
-		if (decodedBase !== "/") {
-			if (pathname === decodedBase.slice(0, -1)) {
+		if (baseSegments.length > 0) {
+			const segments = pathname.split("/").slice(1);
+			const decodedSegments = decodePathSegments(pathname)?.slice(1) ?? segments;
+			if (decodedSegments.length === baseSegments.length && baseSegments.every((segment, index) => decodedSegments[index] === segment)) {
 				res.writeHead(301, { location: `${base}${search}` });
 				res.end();
 				return;
 			}
-			if (!pathname.startsWith(decodedBase)) {
+			if (decodedSegments.length <= baseSegments.length || !baseSegments.every((segment, index) => decodedSegments[index] === segment)) {
 				res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
 				res.end("Not found");
 				return;
 			}
-			pathname = `/${pathname.slice(decodedBase.length)}`;
+			pathname = `/${segments.slice(baseSegments.length).join("/")}`;
 		}
 		const file = await resolveStaticFile(staticDir, pathname);
+		if (file?.document && trailingSlash !== "ignore") {
+			const canonical = canonicalPagePathname(publicPathname, base, trailingSlash);
+			if (canonical !== publicPathname) {
+				res.writeHead(308, { location: `${canonical.replace(/^\/{2,}/, "/")}${search}` });
+				res.end();
+				return;
+			}
+		}
 		if (file) {
-			await sendFile(res, method, file.filePath, file.contentType, file.cacheControl, 200);
+			await sendFile(res, method, file.filePath, file.contentType, file.cacheControl, 200, req);
 			return;
 		}
 		if (fallback) {
@@ -221,18 +216,22 @@ function createStaticPreviewHandler(options) {
 		res.end("Not found");
 	};
 }
-/**
-* Decode each URL segment into the filesystem spelling emitted by the static
-* exporter without allowing an escape to introduce path structure.
-*/
-function decodeStaticPreviewPathname(pathname) {
-	return pathname.split("/").map((segment) => {
-		const decoded = decodeURIComponent(segment);
-		if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || decoded.includes("\0")) throw new Error("Unsafe encoded static path segment.");
-		return decoded;
-	}).join("/");
+function canonicalPagePathname(pathname, base, policy) {
+	const trimmed = pathname.replace(/\/+$/, "");
+	if (trimmed === "" || `${trimmed}/` === base) return pathname;
+	if (policy === "never") return trimmed;
+	return trimmed.slice(trimmed.lastIndexOf("/") + 1).includes(".") ? trimmed : `${trimmed}/`;
+}
+function decodePathSegments(pathname) {
+	const segments = [];
+	for (const segment of pathname.split("/")) {
+		const decoded = decodeStaticPath(segment);
+		if (!decoded.ok) return null;
+		segments.push(decoded.path);
+	}
+	return segments;
 }
-async function sendFile(res, method, filePath, contentType, cacheControl, status) {
+async function sendFile(res, method, filePath, contentType, cacheControl, status, rangeRequest) {
 	let body;
 	try {
 		body = await readFile(filePath);
@@ -241,14 +240,40 @@ async function sendFile(res, method, filePath, contentType, cacheControl, status
 		res.end("Not found");
 		return;
 	}
-	res.writeHead(status, {
+	const headers = {
 		"content-type": contentType,
 		"cache-control": cacheControl,
 		"content-length": body.byteLength
-	});
+	};
+	if (rangeRequest) {
+		headers["accept-ranges"] = "bytes";
+		const range = method === "GET" ? staticByteRange({ get: (name) => headerValue(rangeRequest, name) }, { get: () => null }, body.byteLength) : null;
+		if (range === "unsatisfiable") {
+			res.writeHead(416, {
+				...headers,
+				"content-length": 0,
+				"content-range": `bytes */${body.byteLength}`
+			});
+			res.end();
+			return;
+		}
+		if (range) {
+			res.writeHead(206, {
+				...headers,
+				"content-length": range.end - range.start + 1,
+				"content-range": `bytes ${range.start}-${range.end}/${body.byteLength}`
+			});
+			res.end(body.subarray(range.start, range.end + 1));
+			return;
+		}
+	}
+	res.writeHead(status, headers);
 	res.end(method === "HEAD" ? void 0 : body);
 }
-/** Vite normalizes `base` to leading and trailing slashes; be defensive anyway. */
+function headerValue(req, name) {
+	const value = req.headers[name.toLowerCase()];
+	return typeof value === "string" ? value : null;
+}
 function normalizePreviewBase(raw) {
 	if (typeof raw !== "string" || raw === "" || raw === "/") return "/";
 	const withLeadingSlash = raw.startsWith("/") ? raw : `/${raw}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pracht/adapter-static",
-  "version": "0.2.1",
+  "version": "1.0.0",
   "description": "Static-export adapter for Pracht: prerender every route and deploy dist/client to any static host with zero server.",
   "keywords": [
     "pracht",
@@ -13,7 +13,7 @@
     "vite"
   ],
   "license": "MIT",
-  "homepage": "https://github.com/JoviDeCroock/pracht/tree/main/packages/adapter-static",
+  "homepage": "https://pracht.resynapse.dev/docs/adapters",
   "bugs": {
     "url": "https://github.com/JoviDeCroock/pracht/issues"
   },
@@ -39,8 +39,13 @@
     "provenance": true
   },
   "dependencies": {
-    "@pracht/adapter-node": "^0.5.1",
-    "@pracht/core": "^0.20.0"
+    "@pracht/adapter-node": "^1.0.0"
+  },
+  "peerDependencies": {
+    "@pracht/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@pracht/core": "^1.0.0"
   },
   "scripts": {
     "build": "tsdown"