@ultimat3/render 22.2.0 → 22.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultimat3/render",
-  "version": "22.2.0",
+  "version": "22.2.2",
   "description": "The route primitive and the five render modes: static, isr, ssr, stream, spa.",
   "license": "MIT",
   "type": "module",
@@ -36,11 +36,11 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ultimat3/cache": "22.2.0",
-    "@ultimat3/core": "22.2.0",
-    "@ultimat3/http": "22.2.0",
-    "@ultimat3/i18n": "22.2.0",
-    "@ultimat3/seo": "22.2.0",
+    "@ultimat3/cache": "22.2.2",
+    "@ultimat3/core": "22.2.2",
+    "@ultimat3/http": "22.2.2",
+    "@ultimat3/i18n": "22.2.2",
+    "@ultimat3/seo": "22.2.2",
     "sass": "1.104.0"
   }
 }

package/src/module-loader.ts

@@ -4,11 +4,14 @@
  * `bun test` all load a component the same way and there is no separate "bundled" behaviour.
  */
 
+// why: Bun ships no path API, and a relative app root has to be resolved against the working
+// directory before it can be compared with the absolute paths the Bun plugin hands this loader.
+import { resolve } from 'node:path';
 import { renderThrowable } from '@ultimat3/core';
 import { compileStylesheet, isGlobalStylesheet, stripCharset } from './css-modules';
 import { PrerenderFailedError } from './errors';
 import type { Surface } from './surfaces';
-import { surfaceOf } from './surfaces';
+import { surfaceUnder } from './surfaces';
 
 /**
  * Why a transform at all: `tsconfig.json` says `jsx: 'preserve'`, which makes Bun fall back to the
@@ -101,6 +104,34 @@ export function registeredStylesheets(): readonly Stylesheet[] {
   return [...stylesheets.values()];
 }
 
+/**
+ * The directory a sheet's surface is read below. Absent, the process's working directory — which
+ * is the app root in the container (`WORKDIR /app`) and under every `x` command run from one.
+ */
+let stylesheetRoot: string | undefined;
+
+const surfaceOfSheet = (path: string): Surface | null =>
+  surfaceUnder(stylesheetRoot ?? process.cwd(), path);
+
+/**
+ * Names the app root the registry classifies against; `loadApp` calls it before importing a module.
+ * Every sheet already registered is classified again, because a sheet can load before the root is
+ * named — and a classification frozen then would keep the answer the wrong root gave. The revision
+ * moves only when an answer does, so naming the same root twice mints no new stylesheet URL.
+ * A relative root is resolved against the working directory. `undefined` returns to the working
+ * directory.
+ */
+export function setStylesheetRoot(root: string | undefined): void {
+  // Resolved: `loadApp('.')` is a legal call, and `.` is a prefix of no absolute path.
+  stylesheetRoot = root === undefined ? undefined : resolve(root);
+  for (const [path, sheet] of stylesheets) {
+    const surface = surfaceOfSheet(path);
+    if (surface === sheet.surface) continue;
+    stylesheets.set(path, { ...sheet, surface });
+    revision += 1;
+  }
+}
+
 /** Test seam: the registry is process-global because the module cache it mirrors is too. */
 export function clearStylesheets(): void {
   if (stylesheets.size > 0) revision += 1;
@@ -159,7 +190,7 @@ export function loadStylesheet(path: string, source: string): string {
     if (stylesheets.get(path)?.css !== compiled.css) revision += 1;
     stylesheets.set(path, {
       file: path,
-      surface: surfaceOf(path),
+      surface: surfaceOfSheet(path),
       global: isGlobalStylesheet(path),
       css: compiled.css,
     });

package/src/server.ts

@@ -30,6 +30,7 @@ export {
   installRenderLoader,
   loadStylesheet,
   registeredStylesheets,
+  setStylesheetRoot,
   stylesFor,
   stylesheetsRevision,
   transformTsx,

package/src/surfaces.ts

@@ -91,6 +91,25 @@ export function surfaceOf(file: string): Surface | null {
   return locateSurface(file)?.surface ?? null;
 }
 
+/**
+ * The surface of an ABSOLUTE path, read from the part below the app `root`. `surfaceOf` takes the
+ * first surface-named segment, which is right for the root-relative paths the route table and the
+ * boundary check hold — and wrong for an absolute one whose root is itself called `app/`: the
+ * scaffold's container runs from `WORKDIR /app`, and every stylesheet there read as `app`, so the
+ * site bundle was empty and every site document shipped with no stylesheet at all.
+ *
+ * A file outside `root` is read as `surfaceOf` reads it. A file inside an installed package
+ * (`node_modules/…`) has no surface whatever its directories are called: it is a package sheet,
+ * which both graphs carry.
+ */
+export function surfaceUnder(root: string, file: string): Surface | null {
+  const base = normalize(root).replace(/\/+$/, '');
+  const path = normalize(file);
+  const relative = path.startsWith(`${base}/`) ? path.slice(base.length + 1) : path;
+  if (/(?:^|\/)node_modules\//.test(relative)) return null;
+  return surfaceOf(relative);
+}
+
 function normalize(file: string): string {
   return file.replace(/\\/g, '/').replace(/^\.\//, '');
 }