@sigil-dev/grimoire 0.9.24 → 0.9.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,5 +1,6 @@
1
1
  import { randomBytes } from "node:crypto";
2
2
  import { SafeHtml } from "@sigil-dev/runtime";
3
+ import { base, withBase } from "../base";
3
4
  import { startCollecting, stopCollecting } from "../client/deps";
4
5
  import { filterPublic } from "../env/index";
5
6
  import { findClosestError, type MatchedRoute } from "../routing/router";
@@ -9,8 +10,8 @@ import { isRedirectResult } from "../sentinels/redirect.ts";
9
10
  import { clientAddressOf } from "../server/client-address";
10
11
  import { hydrateEntry } from "../server/client-entry";
11
12
  import { runWithContext } from "../server/context";
12
- import { base, withBase } from "../base";
13
13
  import { runHook } from "../server/plugins";
14
+ import { hashPublicStylesheets, publicCssMap } from "../server/public-assets";
14
15
  import type { GrimoirePlugin, LoadContext, Route } from "../types";
15
16
  import { collectHead, initHead } from "./head";
16
17
  import { optimizeImages } from "./images.ts";
@@ -112,6 +113,20 @@ function publicEnvScript(nonceAttr: string): string {
112
113
  return `\n <script${nonceAttr}>window.__grimoire_env__=${safeStateJson(env)}</script>`;
113
114
  }
114
115
 
116
+ /** `/style.css` → `/style.<hash>.css` for the stylesheets in public/. */
117
+ const hashCss = (html: string, dev?: boolean): string =>
118
+ hashPublicStylesheets(html, publicCssMap(!!dev));
119
+
120
+ /**
121
+ * The same map for the browser, so a link the client router creates after
122
+ * navigation is pointed at the hashed URL the server already put in the page.
123
+ */
124
+ function publicCssScript(nonceAttr: string, dev?: boolean): string {
125
+ const map = publicCssMap(!!dev);
126
+ if (Object.keys(map).length === 0) return "";
127
+ return `\n <script${nonceAttr}>window.__grimoire_css__=${safeStateJson(map)}</script>`;
128
+ }
129
+
115
130
  function buildHtmlSkeleton(nonceAttr: string, dev?: boolean): string {
116
131
  // a meta tag, not a script: the base has to reach the router under a CSP
117
132
  // nonce too, and the bundle reads it so one build works under any base
@@ -122,7 +137,7 @@ function buildHtmlSkeleton(nonceAttr: string, dev?: boolean): string {
122
137
  <html>
123
138
  <head>
124
139
  <meta charset="UTF-8" />
125
- <meta name="viewport" content="width=device-width, initial-scale=1.0" />${publicEnvScript(nonceAttr)}
140
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />${publicEnvScript(nonceAttr)}${publicCssScript(nonceAttr, dev)}
126
141
  <script type="module" src="/__grimoire__/${hydrateEntry()}"${nonceAttr}></script>
127
142
  ${dev ? `<script src="/__grimoire__/hmr-client.js"${nonceAttr}></script>` : ""}`;
128
143
  }
@@ -258,7 +273,10 @@ export async function renderErrorPage(
258
273
  const errorHtml = String(
259
274
  mod.default({ status, message, error, route: pathname }),
260
275
  );
261
- const bodyHtml = applyLayoutTree(errorHtml, layoutPairs, params);
276
+ const bodyHtml = hashCss(
277
+ applyLayoutTree(errorHtml, layoutPairs, params),
278
+ dev,
279
+ );
262
280
  const headHtml = collectHead();
263
281
  const hoistedCss = hoistStylesheets(bodyHtml);
264
282
  const styles = scopedStyles(bodyHtml, nonceAttr);
@@ -527,9 +545,12 @@ export async function renderRoute(
527
545
  const uid = Math.random().toString(36).slice(2);
528
546
  const csrfToken = csrfTokenFor(req);
529
547
  const loadingHtml = String(pageMod.loading());
530
- const loadingBody = injectCsrf(
531
- applyLayouts(`<div id="ab-${uid}">${loadingHtml}</div>`),
532
- csrfToken,
548
+ const loadingBody = hashCss(
549
+ injectCsrf(
550
+ applyLayouts(`<div id="ab-${uid}">${loadingHtml}</div>`),
551
+ csrfToken,
552
+ ),
553
+ dev,
533
554
  );
534
555
  // layout stylesheets are in the loading shell — hoist before first flush
535
556
  const hoistedCss = hoistStylesheets(loadingBody);
@@ -564,17 +585,20 @@ export async function renderRoute(
564
585
  extractDeferred(mergedData, deferred, deferredCounter);
565
586
 
566
587
  // 3. render real page + collect head
567
- const pageHtml = injectCsrf(
568
- String(
569
- await Promise.resolve(
570
- pageMod.default({
571
- data: renderable(mergedData),
572
- params: matched.params,
573
- form: actionFailure?.data,
574
- }),
588
+ const pageHtml = hashCss(
589
+ injectCsrf(
590
+ String(
591
+ await Promise.resolve(
592
+ pageMod.default({
593
+ data: renderable(mergedData),
594
+ params: matched.params,
595
+ form: actionFailure?.data,
596
+ }),
597
+ ),
575
598
  ),
599
+ csrfToken,
576
600
  ),
577
- csrfToken,
601
+ dev,
578
602
  );
579
603
  const headHtml = collectHead();
580
604
  const stateJson = safeStateJson({
@@ -701,7 +725,7 @@ export async function renderRoute(
701
725
  form: actionFailure?.data,
702
726
  });
703
727
 
704
- bodyHtml = optimizeImages(injectCsrf(bodyHtml, csrfToken));
728
+ bodyHtml = hashCss(optimizeImages(injectCsrf(bodyHtml, csrfToken)), dev);
705
729
 
706
730
  const hoistedCss = hoistStylesheets(bodyHtml);
707
731
  const styles = scopedStyles(bodyHtml, nonceAttr);
@@ -10,6 +10,9 @@ export interface MatchedRoute {
10
10
  notFound?: boolean;
11
11
  }
12
12
 
13
+ /** The folder a route file sits in, as written on disk: /src/routes/(app)/plan. */
14
+ const folderOf = (f: RouteFile) => f.clientPath.slice(0, f.clientPath.lastIndexOf("/"));
15
+
13
16
  export function matchRoute(
14
17
  tree: RouteTree,
15
18
  url: URL,
@@ -45,20 +48,24 @@ export function matchRoute(
45
48
  }
46
49
  }
47
50
  if (!matched) continue;
48
- // find applicable layouts by matching route pattern prefix, not URL pathname.
49
- // pathname.startsWith(l.path) would fail for parameterized layouts like /w/:workspace.
50
- const layoutMatches = (l: RouteFile) =>
51
- l.path === "/" ||
52
- route.path === l.path ||
53
- route.path.startsWith(`${l.path}/`);
51
+ // A layout wraps its own folder and the folders below it, so compare
52
+ // folders on disk, not URL patterns: (app)/+layout.tsx has the URL "/"
53
+ // once the group is stripped, yet must not wrap login/+page.tsx.
54
+ const routeDir = folderOf(route);
55
+ const layoutMatches = (l: RouteFile) => {
56
+ const dir = folderOf(l);
57
+ return routeDir === dir || routeDir.startsWith(`${dir}/`);
58
+ };
59
+ const outermostFirst = (a: RouteFile, b: RouteFile) =>
60
+ folderOf(a).length - folderOf(b).length;
54
61
 
55
62
  const layouts = tree.layouts
56
63
  .filter((l) => l.type === "layout" && layoutMatches(l))
57
- .sort((a, b) => a.path.length - b.path.length); // root first, innermost last
64
+ .sort(outermostFirst);
58
65
 
59
66
  const layoutServers = tree.layouts
60
67
  .filter((l) => l.type === "layoutServer" && layoutMatches(l))
61
- .sort((a, b) => a.path.length - b.path.length); // root first, innermost last
68
+ .sort(outermostFirst);
62
69
 
63
70
  const pageServer = tree.routes.find(
64
71
  (r) => r.type === "pageServer" && r.path === route.path,
@@ -173,13 +173,17 @@ export async function scanRoutes(
173
173
  routes.filter((r) => r.type === "pageServer"),
174
174
  "page server",
175
175
  );
176
+ // Layouts belong to a folder, not a URL: (app)/+layout.tsx and the root
177
+ // +layout.tsx both sit at "/" once the group is stripped, and both are fine.
176
178
  assertNoDuplicatePaths(
177
179
  layouts.filter((l) => l.type === "layout"),
178
180
  "layout",
181
+ folderOf,
179
182
  );
180
183
  assertNoDuplicatePaths(
181
184
  layouts.filter((l) => l.type === "layoutServer"),
182
185
  "layout server",
186
+ folderOf,
183
187
  );
184
188
  assertNoDuplicatePaths(servers, "API route");
185
189
  assertNoDuplicatePaths(errors, "error page");
@@ -188,16 +192,23 @@ export async function scanRoutes(
188
192
  return { routes, layouts, servers, errors, paramMatcherFiles };
189
193
  }
190
194
 
191
- function assertNoDuplicatePaths(files: RouteFile[], label: string): void {
195
+ const folderOf = (f: RouteFile) => f.clientPath.slice(0, f.clientPath.lastIndexOf("/"));
196
+
197
+ function assertNoDuplicatePaths(
198
+ files: RouteFile[],
199
+ label: string,
200
+ keyOf: (f: RouteFile) => string = (f) => f.path,
201
+ ): void {
192
202
  const seen = new Map<string, string>();
193
203
  for (const file of files) {
194
- const existing = seen.get(file.path);
204
+ const key = keyOf(file);
205
+ const existing = seen.get(key);
195
206
  if (existing) {
196
207
  throw new Error(
197
208
  `Duplicate ${label} at "${file.path}": "${existing}" and "${file.clientPath}"`,
198
209
  );
199
210
  }
200
- seen.set(file.path, file.clientPath);
211
+ seen.set(key, file.clientPath);
201
212
  }
202
213
  }
203
214