@johnhenry/sitefile 0.0.0 → 0.0.2

package/lib/src/wbn.js

@@ -1,5 +1,6 @@
 import { SitefileError } from './errors.js';
 import { cborArray, cborBytes, cborMap, cborText, cborUint } from './cbor.js';
+import { headersFor, matchRedirect, parseHeaderRules, parseRedirectRules } from './serve-rules.js';
 /**
  * Unsigned Web Bundle, format version "b2"
  * (draft-ietf-wpack-bundled-responses). Layout, as one CBOR array:
@@ -19,6 +20,10 @@ import { cborArray, cborBytes, cborMap, cborText, cborUint } from './cbor.js';
  * responses = [ [ headers (bstr holding { h':status' => h'200', h'content-type' => ... }), payload bstr ] ... ]
  *
  * primary  = text URL, present only when /index.html exists. No signatures.
+ *
+ * The tree's own `/_headers` and `/_redirects` (what HEADER and REDIRECT
+ * write) are applied the way `sitefile serve` applies them (serve-rules.ts):
+ * see {@link bundleResponses}.
  */
 const MAGIC = Buffer.from('f09f8c90f09f93a6', 'hex');
 const VERSION = Buffer.from([0x62, 0x32, 0x00, 0x00]);
@@ -89,26 +94,18 @@ const enc = new TextEncoder();
 const bstr = (s) => cborBytes(enc.encode(s));
 export function writeWebBundle(tree, baseUrl) {
     const base = validateBaseUrl(baseUrl);
-    const entries = tree.entries();
-    const responses = [];
+    const { responses, urls } = bundleResponses(tree);
     const index = [];
     // Offset of the first response = size of the responses array head.
-    let offset = headSize(entries.length);
-    for (const [p, node] of entries) {
-        const headers = cborMap([
-            [bstr(':status'), bstr('200')],
-            [bstr('content-type'), bstr(mimeTypeFor(p))],
-        ]);
-        const response = cborArray([cborBytes(headers), cborBytes(node.bytes)]);
+    const offsets = [];
+    let offset = headSize(responses.length);
+    for (const r of responses) {
+        offsets.push(offset);
+        offset += r.length;
+    }
+    for (const [path, i] of urls) {
         // b2 index entries are [offset, length]; b1's leading variants value is gone.
-        const loc = [cborUint(offset), cborUint(response.length)];
-        const urls = [base + encodePath(p)];
-        if (p === '/index.html' || p.endsWith('/index.html'))
-            urls.push(base + encodePath(p.slice(0, -'index.html'.length)));
-        for (const url of urls)
-            index.push([cborText(url), cborArray(loc)]);
-        responses.push(response);
-        offset += response.length;
+        index.push([cborText(base + encodePath(path)), cborArray([cborUint(offsets[i]), cborUint(responses[i].length)])]);
     }
     const responsesSection = cborArray(responses);
     const indexSection = cborMap(index);
@@ -133,6 +130,103 @@ export function writeWebBundle(tree, baseUrl) {
     len.writeBigUInt64BE(BigInt(total));
     return Buffer.concat([...parts, cborBytes(len)]);
 }
+/** One encoded response: `[headers bstr, payload bstr]`, header names in CBOR map (bytewise) order. */
+function encodeResponse(status, headers, body) {
+    const map = cborMap([[bstr(':status'), bstr(String(status))], ...[...headers].map(([k, v]) => [bstr(k), bstr(v)])]);
+    return cborArray([cborBytes(map), cborBytes(body)]);
+}
+const isRedirectStatus = (s) => s >= 301 && s <= 308;
+/** The rule `serve` would apply first in one pass (forced or not), when it is an exact-path 3xx redirect. */
+function exactRedirect(rules, forced, path) {
+    const i = rules.findIndex((r) => r.force === forced && matchRedirect(r, path) !== undefined);
+    return i >= 0 && !rules[i].splat && isRedirectStatus(rules[i].status) ? i : undefined;
+}
+/**
+ * The responses section and its URLs (tree paths, percent-encoded by the caller), as `sitefile
+ * serve` would answer them:
+ *
+ * - Each file is a 200 with `content-type` and the `/_headers` blocks whose pattern matches its
+ *   URL path (`headersFor`; a `content-type` there replaces the inferred one). A directory URL
+ *   (`/docs/` for `/docs/index.html`) matches with its trailing slash, so it gets its own
+ *   response when its headers differ from the file URL's.
+ * - An exact-path `/_redirects` rule with a 3xx status becomes a response with that `:status`, a
+ *   `location` of the rule's target as written, and an empty body: at its path when no file
+ *   would be served there, and over the file when forced (`301!`). Like `serve`, the first rule
+ *   matching the path decides; when that is a splat or a 200/404 rewrite, the bundle leaves the
+ *   path to `/_redirects`. Splat rules and rewrites are not baked in.
+ *
+ * `/_headers` and `/_redirects` stay in the bundle as files. Responses are deduplicated (both URLs
+ * of an index page share one when their headers agree; identical redirects share one).
+ */
+export function bundleResponses(tree) {
+    const text = (p) => {
+        const f = tree.get(p);
+        return f ? new TextDecoder().decode(f.bytes) : '';
+    };
+    const redirects = parseRedirectRules(text('/_redirects'));
+    const headerRules = parseHeaderRules(text('/_headers'));
+    const responses = [];
+    const urls = [];
+    const taken = new Set();
+    const redirectResponse = new Map();
+    const redirectTo = (rule) => {
+        const r = redirects[rule];
+        const key = `${r.status} ${r.to}`;
+        let i = redirectResponse.get(key);
+        if (i === undefined) {
+            i = responses.push(encodeResponse(r.status, [['location', r.to]], new Uint8Array(0))) - 1;
+            redirectResponse.set(key, i);
+        }
+        return i;
+    };
+    const fileResponse = (p, bytes, urlPath) => {
+        const headers = new Map([['content-type', mimeTypeFor(p)]]);
+        for (const [k, v] of Object.entries(headersFor(headerRules, urlPath)))
+            headers.set(k, v);
+        return encodeResponse(200, headers, bytes);
+    };
+    for (const [p, node] of tree.entries()) {
+        // [URL path, the path `serve` matches redirects against (no trailing slash)]
+        const targets = [[p, p]];
+        if (p === '/index.html' || p.endsWith('/index.html')) {
+            const dir = p.slice(0, -'index.html'.length);
+            targets.push([dir, dir === '/' ? '/' : dir.slice(0, -1)]);
+        }
+        let last;
+        for (const [urlPath, matchPath] of targets) {
+            taken.add(urlPath);
+            const forced = exactRedirect(redirects, true, matchPath);
+            if (forced !== undefined) {
+                urls.push([urlPath, redirectTo(forced)]);
+                continue;
+            }
+            const r = fileResponse(p, node.bytes, urlPath);
+            if (last === undefined || !Buffer.from(last.bytes).equals(r))
+                last = { bytes: r, i: responses.push(r) - 1 };
+            urls.push([urlPath, last.i]);
+        }
+    }
+    // Redirects at paths without a file: `serve` applies a forced rule first, then (when nothing
+    // is served there: no file, no `<path>.html`, no directory) the first other matching rule.
+    const servable = (p) => tree.isFile(p) && p !== '/_redirects' && p !== '/_headers';
+    for (const r of redirects) {
+        if (r.splat || !isRedirectStatus(r.status) || taken.has(r.from))
+            continue;
+        const path = r.from;
+        taken.add(path);
+        let rule = exactRedirect(redirects, true, path);
+        if (rule === undefined) {
+            const firstForced = redirects.some((x) => x.force && matchRedirect(x, path) !== undefined);
+            const served = path === '/' ? servable('/index.html') : servable(path) || servable(`${path}.html`) || tree.isDirectory(path);
+            if (firstForced || served)
+                continue;
+            rule = exactRedirect(redirects, false, path);
+        }
+        if (rule !== undefined)
+            urls.push([path, redirectTo(rule)]);
+    }
+    return { responses, urls };
+}
 function headSize(n) {
     if (n < 24)
         return 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnhenry/sitefile",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Docker-inspired static artifact builder: compose immutable file trees from local and remote sources, render templates, and export a deployable site. No container runtime, no shell, no runtime dependencies.",
   "keywords": [
     "static-site",
@@ -53,6 +53,7 @@
     "prepack": "npm run build"
   },
   "devDependencies": {
+    "@johnhenry/fileable": "^0.1.1",
     "@johnhenry/packfile": "^0.2.0",
     "@types/node": "^26.6.6",
     "typescript": "^7.0.2"