@ngrok/app-server 0.3.0 → 0.3.2

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.
Files changed (48) hide show
  1. package/README.md +68 -7
  2. package/dist/cli.js +2 -2
  3. package/dist/client-browser.d.ts +12 -0
  4. package/dist/client-browser.js +3 -0
  5. package/dist/client.d.ts +14 -134
  6. package/dist/client.js +17 -316
  7. package/dist/client.js.map +1 -1
  8. package/dist/{create-server-iE1-s6Bi.js → create-server-D0De6R7Q.js} +25 -15
  9. package/dist/create-server-D0De6R7Q.js.map +1 -0
  10. package/dist/{entry-DmJEqVfd.d.ts → create-server-kzZWd_Lo.d.ts} +16 -63
  11. package/dist/entry-DuGgSKeB.d.ts +58 -0
  12. package/dist/{entry-DZ3qo7qF.js → entry-UDsxuqBC.js} +2 -2
  13. package/dist/{entry-DZ3qo7qF.js.map → entry-UDsxuqBC.js.map} +1 -1
  14. package/dist/index.d.ts +4 -3
  15. package/dist/index.js +3 -3
  16. package/dist/{load-entry-AfYS_zS9.js → load-entry-Bodyd2Ok.js} +4 -4
  17. package/dist/{load-entry-AfYS_zS9.js.map → load-entry-Bodyd2Ok.js.map} +1 -1
  18. package/dist/{node-BFH82eeL.js → node-C1qudLs_.js} +2 -2
  19. package/dist/{node-BFH82eeL.js.map → node-C1qudLs_.js.map} +1 -1
  20. package/dist/node.d.ts +1 -1
  21. package/dist/node.js +1 -1
  22. package/dist/react-router.d.ts +1 -1
  23. package/dist/react-router.js +1 -1
  24. package/dist/request-context-BtQ87VYb.js.map +1 -1
  25. package/dist/{script-hashes-hqUk6kG7.js → script-hashes-C6hQ5XnP.js} +22 -4
  26. package/dist/script-hashes-C6hQ5XnP.js.map +1 -0
  27. package/dist/{serve-CDNgThjk.js → serve-caOkS3o5.js} +2 -2
  28. package/dist/{serve-CDNgThjk.js.map → serve-caOkS3o5.js.map} +1 -1
  29. package/dist/stale-build-navigation-PnMLtTF8.js +339 -0
  30. package/dist/stale-build-navigation-PnMLtTF8.js.map +1 -0
  31. package/dist/stale-build-navigation-ypV7Ow4o.d.ts +141 -0
  32. package/dist/{start-TLIprD74.js → start-DREqYrZh.js} +4 -4
  33. package/dist/{start-TLIprD74.js.map → start-DREqYrZh.js.map} +1 -1
  34. package/dist/tanstack-start.d.ts +2 -2
  35. package/dist/testing.d.ts +56 -0
  36. package/dist/testing.js +114 -0
  37. package/dist/testing.js.map +1 -0
  38. package/dist/{trailing-slash-DX7NB88H.d.ts → trailing-slash-BrymAEGv.d.ts} +2 -2
  39. package/dist/{types-DLYxYS6M.d.ts → types-CEvzAmcn.d.ts} +2 -2
  40. package/dist/vercel.d.ts +2 -2
  41. package/dist/vercel.js +2 -2
  42. package/dist/{vite-iioAoxSt.js → vite-tTxVimP6.js} +2 -15
  43. package/dist/vite-tTxVimP6.js.map +1 -0
  44. package/dist/vite.js +1 -1
  45. package/package.json +6 -1
  46. package/dist/create-server-iE1-s6Bi.js.map +0 -1
  47. package/dist/script-hashes-hqUk6kG7.js.map +0 -1
  48. package/dist/vite-iioAoxSt.js.map +0 -1
package/README.md CHANGED
@@ -162,7 +162,7 @@ After the build and after the prerender pass, `appServer` writes a gzip copy (`.
162
162
 
163
163
  The build exports `appServer`, and the CLI calls it. So the copy of this package in the build runs the server, and the CLI's copy runs nothing. The CLI refuses a build from a version of this package with another entry protocol.
164
164
 
165
- A React Router app with no Vite plugin also works: `app-server serve build/server/index.js` reads a plain React Router build and runs it with the CLI's copy, the node host, and the default plugins. In that build, a route that calls `shutdownSignal()`, `eventStream()`, or `requestContext()` must import the CLI's copy, so do not bundle `@ngrok/app-server` into it.
165
+ A React Router app with no Vite plugin also works: `app-server serve build/server/index.js` reads a plain React Router build and runs it with the CLI's copy, the node host, and the default plugins. In that build, a route that calls `shutdownSignal()`, `eventStream()`, `requestContext()`, or `cspNonce()` must import the CLI's copy, so do not bundle `@ngrok/app-server` into it.
166
166
 
167
167
  ## Commands
168
168
 
@@ -381,21 +381,51 @@ createServer({
381
381
  });
382
382
  ```
383
383
 
384
- Give the nonce to the framework's render. `requestContext()?.cspNonce` has it. In React Router, do it in `app/entry.server.tsx`:
384
+ Give the nonce to the framework's render with `cspNonce()` from `@ngrok/app-server/client`. On the server, it gives the nonce of the request. In the browser, it reads the nonce from the document, so the hydration matches. It gives `undefined` when the page has no nonce. A bundler that resolves the `browser` export condition, such as Vite for the client build, gets a `cspNonce()` with no server code.
385
+
386
+ In React Router, give it to the render in `app/entry.server.tsx`:
385
387
 
386
388
  ```tsx
387
- const nonce = requestContext()?.cspNonce;
389
+ import { cspNonce } from "@ngrok/app-server/client";
390
+
391
+ const nonce = cspNonce();
388
392
  const { pipe } = renderToPipeableStream(
389
393
  <ServerRouter context={routerContext} url={request.url} nonce={nonce} />,
390
394
  { nonce /* , … */ },
391
395
  );
392
396
  ```
393
397
 
394
- In TanStack Start, give it to the router:
398
+ `<HydratedRouter>` takes no nonce, so in the browser `<Links>`, `<ScrollRestoration>`, and `<Scripts>` render no nonce, and React warns that the hydration does not match. Give them the nonce in the root `Layout`. Give it also to each inline script of the app, such as a theme script:
399
+
400
+ ```tsx
401
+ // app/root.tsx
402
+ import { cspNonce } from "@ngrok/app-server/client";
403
+
404
+ export function Layout({ children }: { children: React.ReactNode }) {
405
+ const nonce = cspNonce();
406
+ return (
407
+ <html lang="en">
408
+ <head>
409
+ <Meta />
410
+ <Links nonce={nonce} />
411
+ </head>
412
+ <body>
413
+ {children}
414
+ <ScrollRestoration nonce={nonce} />
415
+ <Scripts nonce={nonce} />
416
+ </body>
417
+ </html>
418
+ );
419
+ }
420
+ ```
421
+
422
+ In TanStack Start, give it to the router. `getRouter` runs on the server and in the browser:
395
423
 
396
424
  ```ts
425
+ import { cspNonce } from "@ngrok/app-server/client";
426
+
397
427
  export function getRouter() {
398
- return createRouter({ routeTree, ssr: { nonce: requestContext()?.cspNonce } });
428
+ return createRouter({ routeTree, ssr: { nonce: cspNonce() } });
399
429
  }
400
430
  ```
401
431
 
@@ -611,12 +641,16 @@ createServer({ plugins: defaultPlugins({ prerendered: { markdownTwins: true } })
611
641
  - In development, React Router gives only the twins in its `prerender` config, as the build does. TanStack Start finds its prerendered pages only during the build, so in development each twin route that answers markdown counts.
612
642
  - A plugin after `prerendered` does not see a twin, in development or in production, because a twin is a prerendered file. Put an auth check for a twin in `beforeStatic` or in the twin's route.
613
643
 
614
- The default twin is the path with no trailing slash plus `.md`, and `/index.md` for `/`. A different mapping goes in `twinOf`. Its path follows the same rules as a request path:
644
+ The default twin is the path with no trailing slash plus `.md`, and `/index.md` for `/`. A request that `rewrite` changes gets no twin. `rewrite` sends that request to another file or to the framework, so it gets the same answer as a browser. For example, when `rewrite` sends `/?q=h100` to the framework, `/?q=h100` gets no twin, and `/gpu/h100` gets `/gpu/h100.md`.
645
+
646
+ A different mapping goes in `twinOf`. Its path follows the same rules as a request path, and it can give a twin to a request that `rewrite` changes:
615
647
 
616
648
  ```ts
617
649
  prerendered({ markdownTwins: { twinOf: (path) => (path === "/" ? "/llms.md" : `${path}.md`) } });
618
650
  ```
619
651
 
652
+ `twinOf` also gets the request's Hono context, the same as `rewrite`. If it gives `undefined`, the request gets no twin, and the answer gets no `Vary: Accept` and no `Link`.
653
+
620
654
  The framework makes the twins. In React Router, one splat resource route can answer every twin. Prerender each twin URL, and point `twinOf` at the route. `markdownFor` stands for the app's own lookup:
621
655
 
622
656
  ```ts
@@ -642,7 +676,7 @@ createServer({ plugins: defaultPlugins({ prerendered: { markdownTwins: { twinOf
642
676
 
643
677
  The same route answers the twins in development.
644
678
 
645
- For other negotiation, `rewrite` maps a request path to the file to serve. It does not run for a request that gets the twin. When its answer depends on a request header, add a `Vary` for that header in a plugin.
679
+ For other negotiation, `rewrite` maps a request path to the file to serve. A request that gets the twin gets the twin's file. When its answer depends on a request header, add a `Vary` for that header in a plugin.
646
680
 
647
681
  ### A rendered page
648
682
 
@@ -794,6 +828,33 @@ export async function loader({ request }: Route.LoaderArgs) {
794
828
 
795
829
  For other long work, stop on `shutdownSignal()`.
796
830
 
831
+ ## Testing
832
+
833
+ `@ngrok/app-server/testing` runs an app in a test, with no build and no listener.
834
+
835
+ `createTestServer({ app, files, framework })` starts the app in production mode over a client build of `files`. It records the hashes of the inline scripts of each HTML file, as the build does. `framework` answers each request that no stage answers. The default is a 404. Give each test server a new app, because an app runs the `setup` of its plugins one time. `close()` cancels each body that the test did not read, runs each plugin's `onShutdown`, and removes the files.
836
+
837
+ ```ts
838
+ import { createTestServer } from "@ngrok/app-server/testing";
839
+
840
+ const server = await createTestServer({
841
+ app: createServer({ plugins: defaultPlugins({ contentSecurityPolicy: { policy } }) }),
842
+ files: { "providers/index.html": "<!doctype html><script>…</script>" },
843
+ framework: async () => new Response("rendered", { headers: { "Content-Type": "text/html" } }),
844
+ });
845
+ const response = await server.request("/providers");
846
+ response.headers.get("Content-Security-Policy"); // => "script-src 'self' 'sha256-…'"
847
+ await server.close();
848
+ ```
849
+
850
+ `withRequestContext(values, work)` runs `work` as in a server request, so `requestContext()` and `cspNonce()` give `values`. Use it to test a render with no mock. With no `logger`, the log lines go nowhere.
851
+
852
+ ```tsx
853
+ import { withRequestContext } from "@ngrok/app-server/testing";
854
+
855
+ const html = await withRequestContext({ cspNonce: "test-nonce" }, () => renderToString(<App />));
856
+ ```
857
+
797
858
  ## Adapters
798
859
 
799
860
  A framework adapter or a host adapter is two small objects. A third-party adapter uses the same contract.
package/dist/cli.js CHANGED
@@ -42,12 +42,12 @@ try {
42
42
  if (args?.help === true) process.stdout.write(`${USAGE}\n`);
43
43
  else if (args?.command === "start") {
44
44
  process.env.NODE_ENV ??= "development";
45
- const { start } = await import("./start-TLIprD74.js");
45
+ const { start } = await import("./start-DREqYrZh.js");
46
46
  await start();
47
47
  } else if (args?.command === "serve") {
48
48
  process.env.NODE_ENV ??= "production";
49
49
  if (typeof process.setSourceMapsEnabled === "function") process.setSourceMapsEnabled(true);
50
- const { serve } = await import("./serve-CDNgThjk.js");
50
+ const { serve } = await import("./serve-caOkS3o5.js");
51
51
  await serve({ buildPath: args.buildPath });
52
52
  } else if (args != null) fail(args.command == null ? "Give a command." : `Unknown command: ${args.command}.`);
53
53
 
@@ -0,0 +1,12 @@
1
+ import { a as staleBuildReactRouter, o as staleBuildTanStack } from "./stale-build-navigation-ypV7Ow4o.js";
2
+ /**
3
+ * The CSP nonce of the document's first element with a nonce, or `undefined`
4
+ * when it has none. The browser build of `@ngrok/app-server/client` exports it
5
+ * as `cspNonce()`, so the browser bundle holds no server code.
6
+ *
7
+ * @example
8
+ * documentNonce(); // => "d2hhdCBhIG5vbmNl"
9
+ */
10
+ declare function documentNonce(): string | undefined;
11
+ export { documentNonce as cspNonce, staleBuildReactRouter, staleBuildTanStack };
12
+ //# sourceMappingURL=client-browser.d.ts.map
@@ -0,0 +1,3 @@
1
+ import { n as staleBuildTanStack, r as documentNonce, t as staleBuildReactRouter } from "./stale-build-navigation-PnMLtTF8.js";
2
+
3
+ export { documentNonce as cspNonce, staleBuildReactRouter, staleBuildTanStack };
package/dist/client.d.ts CHANGED
@@ -1,141 +1,21 @@
1
- /** Options for {@link staleBuildReactRouter} and {@link staleBuildTanStack}. */
2
- type StaleBuildOptions = {
3
- /**
4
- * The header that `buildId()` sets on data responses.
5
- * @default "X-Build-Id"
6
- */
7
- header?: string;
8
- /**
9
- * The build that this document runs. Set it only when the server does not
10
- * send it.
11
- * @default the `build` metric of the document's `Server-Timing`, which `buildId()` sends
12
- */
13
- build?: string;
14
- /**
15
- * Runs once, when the tab first sees a response from another build. Use
16
- * it to count stale tabs in the app's RUM tool.
17
- */
18
- onNewBuild?: (served: string) => void;
19
- };
20
- /** The context that React Router gives `unstable_fetch` with each request. */
21
- type RouterFetchContext = {
22
- /** `"navigation"` for the data request of a navigation that the router started. */
23
- type: string;
24
- /** `"PUSH"`, `"REPLACE"`, or `"POP"` for a navigation. */
25
- navigationType?: string | null;
26
- /** The fetcher that sends the request, also in a navigation that revalidates it. */
27
- fetcherKey?: string | null;
28
- };
29
- /** The location in a TanStack Router event. */
30
- type EventLocation = {
31
- pathname: string;
32
- searchStr: string;
33
- };
34
- /** The part of a TanStack Router that {@link staleBuildTanStack} reads. */
35
- type NavigationEvents = {
36
- history: {
37
- flush: () => void;
38
- };
39
- clearCache: () => void;
40
- subscribe: (type: "onBeforeNavigate" | "onResolved", listener: (event: {
41
- fromLocation?: EventLocation;
42
- toLocation: EventLocation;
43
- }) => void) => () => void;
44
- };
45
- /** The `navigate` call of a React Router instrumentation. */
46
- type NavigateInfo = {
47
- to: string | number;
48
- formMethod?: string;
49
- };
50
- /** The router instrumentations that {@link staleBuildReactRouter} adds. */
51
- type RouterInstrumentations = {
52
- navigate: (handler: () => Promise<unknown>, info: NavigateInfo) => Promise<void>;
53
- };
54
- /** The hooks that {@link staleBuildReactRouter} gives to React Router. */
55
- type StaleBuildReactRouter = {
56
- /** Give it to `HydratedRouter` as `unstable_fetch`. */
57
- fetch: (request: Request, context: RouterFetchContext) => Promise<Response>;
58
- /** Give it to `HydratedRouter` in `instrumentations`. */
59
- instrumentation: {
60
- router: (router: {
61
- instrument: (instrumentations: RouterInstrumentations) => void;
62
- }) => void;
63
- };
64
- /** Export it from `app/root.tsx` in `clientMiddleware`. */
65
- middleware: <Result>(args: {
66
- request: Request;
67
- }, next: () => Promise<Result>) => Promise<Result>;
68
- };
1
+ import { a as staleBuildReactRouter, i as StaleBuildReactRouter, n as RouterFetchContext, o as staleBuildTanStack, r as StaleBuildOptions, t as NavigationEvents } from "./stale-build-navigation-ypV7Ow4o.js";
69
2
  /**
70
- * Moves an open React Router tab to a new build at a navigation, so the old
71
- * client code never renders data from the new server, and the page that the
72
- * visitor reads never reloads. Create it in a module that the client entry
73
- * and `app/root.tsx` both import. It reads no browser state until React
74
- * Router calls it, so the server can import it.
3
+ * The CSP nonce of the document, for the framework's render. It gives the
4
+ * same value on the server and in the browser, so the hydration matches.
75
5
  *
76
- * - When the data request of a navigation gets a response from a new build,
77
- * the browser loads the target URL as a document.
78
- * - When the tab already knows of a new build, a `navigate` call, such as a
79
- * link click, loads its target as a document before the router renders it
80
- * or sends a data request. The root middleware does this also for a route
81
- * with no loader.
82
- * - A revalidation, a fetcher, an action, and the loaders after an action
83
- * get their response. They only mark the tab, so the page that the visitor
84
- * reads never reloads.
85
- * - The router's blockers run first, and a canceled navigation never loads
86
- * its target.
6
+ * - On the server, the nonce of the request that runs, from `requestContext()`.
7
+ * - In the browser, the nonce of the document's first element with a nonce.
8
+ * Why: React Router's `<HydratedRouter>` takes no nonce, so the app reads it
9
+ * from the document.
87
10
  *
88
- * It sends no request of its own and adds no wait. It needs `buildId()` in
89
- * the server's pipeline, and it does nothing on a document with no build.
11
+ * It gives `undefined` when the page has no nonce: with no
12
+ * `contentSecurityPolicy` plugin, during a prerender, and on a prerendered page.
13
+ * A bundler that resolves the `browser` condition, such as Vite for the
14
+ * client, gets a build with no server code.
90
15
  *
91
16
  * @example
92
- * // app/stale-build.ts
93
- * export const staleBuild = staleBuildReactRouter();
94
- *
95
- * // app/root.tsx
96
- * export const clientMiddleware = [staleBuild.middleware];
97
- *
98
- * // app/entry.client.tsx
99
- * startTransition(() => {
100
- * hydrateRoot(
101
- * document,
102
- * <HydratedRouter
103
- * unstable_fetch={staleBuild.fetch}
104
- * instrumentations={[staleBuild.instrumentation]}
105
- * />,
106
- * );
107
- * });
108
- */
109
- export declare function staleBuildReactRouter(options?: StaleBuildOptions): StaleBuildReactRouter;
110
- /**
111
- * Moves an open TanStack Router tab to a new build at a navigation, so the
112
- * old client code never renders data from the new server, and the page that
113
- * the visitor reads never reloads. Call it with the router on the client.
114
- *
115
- * - A navigation runs from `onBeforeNavigate` to `onResolved`. The router
116
- * moves history and runs its blockers before it.
117
- * - When a GET response from a new build comes back while a navigation
118
- * runs, such as from a server function in a loader, the browser loads the
119
- * page as a document.
120
- * - When the tab already knows of a new build, a navigation to a new path or
121
- * query clears the router cache and loads the page as a document.
122
- * - A request outside a navigation gets its response, and only marks the tab.
123
- *
124
- * It sends no request of its own and adds no wait. It needs `buildId()` in
125
- * the server's pipeline, and it does nothing on a document with no build.
126
- * It returns a function that stops it and gives back `fetch`. If the app
127
- * wrapped `fetch` after it, the wrapper stays, and each request passes on.
128
- *
129
- * @example
130
- * // src/router.tsx
131
- * export function getRouter() {
132
- * const router = createRouter({ routeTree });
133
- * if (!router.isServer) {
134
- * staleBuildTanStack(router);
135
- * }
136
- * return router;
137
- * }
17
+ * <Scripts nonce={cspNonce()} />
138
18
  */
139
- export declare function staleBuildTanStack(router: NavigationEvents, options?: StaleBuildOptions): () => void;
140
- export type { NavigationEvents, RouterFetchContext, StaleBuildOptions, StaleBuildReactRouter };
19
+ export declare function cspNonce(): string | undefined;
20
+ export { type NavigationEvents, type RouterFetchContext, type StaleBuildOptions, type StaleBuildReactRouter, staleBuildReactRouter, staleBuildTanStack };
141
21
  //# sourceMappingURL=client.d.ts.map
package/dist/client.js CHANGED
@@ -1,326 +1,27 @@
1
- import { a as serverTimingMetrics, i as isBuildMetric, n as BUILD_ID_METRIC, t as BUILD_ID_HEADER } from "./build-id-C6sYO9Yp.js";
1
+ import { t as requestContext } from "./request-context-BtQ87VYb.js";
2
+ import { n as staleBuildTanStack, r as documentNonce, t as staleBuildReactRouter } from "./stale-build-navigation-PnMLtTF8.js";
2
3
 
3
- // src/client/stale-build-navigation.ts
4
- /** Whether `url` is on the origin of this page. */
5
- function isOwn(url) {
6
- return new URL(url, location.href).origin === location.origin;
7
- }
8
- /** The build in the `Server-Timing` of the first of `entries` that has one, from this origin only. */
9
- function timingBuild(entries) {
10
- return entries.filter((entry) => "serverTiming" in entry && isOwn(entry.name)).filter((entry) => entry.entryType !== "resource" || entry.redirectStart === 0).flatMap((entry) => entry.serverTiming).find((metric) => metric.name === BUILD_ID_METRIC)?.description;
11
- }
12
- /** The build in a `Server-Timing` header, as `buildId()` writes it. */
13
- function headerBuild(header) {
14
- const { quoted, token } = serverTimingMetrics(header).find((metric) => isBuildMetric(metric))?.match(/;\s*desc\s*=\s*(?:"(?<quoted>(?:[^"\\]|\\.)*)"|(?<token>[^;\s]*))/iu)?.groups ?? {};
15
- return quoted?.replaceAll(/\\(?<char>.)/gu, "$<char>") ?? token;
16
- }
17
- /** The page of `url`: the router renders a new route for a new path or query, not for a new fragment. */
18
- function pageOf(url) {
19
- const { origin, pathname, search } = new URL(url, location.href);
20
- return `${origin}${pathname}${search}`;
21
- }
22
- /** The page of a TanStack Router location, as {@link pageOf} reads a URL. */
23
- function eventPage({ pathname, searchStr }) {
24
- return `${pathname}${searchStr}`;
25
- }
26
- /** The URL of a `fetch` call. */
27
- function urlOf(input) {
28
- return input instanceof Request ? input.url : String(input);
29
- }
30
- /** The method of a `fetch` call. */
31
- function methodOf(input, init) {
32
- return (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
33
- }
34
- /** The page that a React Router data request loads: `/a.data` loads `/a`, and `/a/_.data` loads `/a/`. */
35
- function targetOf(request) {
36
- const url = new URL(request.url);
37
- url.pathname = url.pathname.replace(/\/_\.data$/u, "/").replace(/\.data$/u, "");
38
- url.searchParams.delete("_routes");
39
- return url.href;
40
- }
41
- /**
42
- * Reloads a document that the back/forward cache shows again. Why: Back can
43
- * show the document that {@link loadDocument} left, with its router still in a
44
- * navigation that never ends. Why one function: the browser adds it once.
45
- */
46
- function reloadIfRestored(event) {
47
- if (event.persisted) location.reload();
48
- }
49
- /**
50
- * Loads `target` as a document, so the old code never gets the new build's
51
- * data. It returns a promise that never settles, because the page unloads.
52
- */
53
- async function loadDocument(target, { response, navigationType } = {}) {
54
- response?.body?.cancel().catch(() => void 0);
55
- const isSamePage = pageOf(target) === pageOf(location.href);
56
- const removesFragment = new URL(target, location.href).hash === "" && location.hash !== "";
57
- addEventListener("pageshow", reloadIfRestored, { once: true });
58
- if (navigationType === "POP" || isSamePage && !removesFragment) location.reload();
59
- else if (navigationType === "REPLACE") location.replace(target);
60
- else location.assign(target);
61
- return new Promise(() => {});
62
- }
63
- /**
64
- * Runs `clear` when `signal` aborts. Why: the router aborts a navigation when a
65
- * newer one starts, such as after the visitor stays on the page at a leave prompt.
66
- */
67
- function onAbort(signal, clear) {
68
- signal.addEventListener("abort", clear, { once: true });
69
- }
70
- /** Reads the build of each response, and tells when the server runs a new build. */
71
- function watchBuild({ header = BUILD_ID_HEADER, build, onNewBuild }) {
72
- if (typeof document === "undefined") return null;
73
- const current = build ?? timingBuild(performance.getEntriesByType("navigation"));
74
- if (current == null) return null;
75
- let stale = false;
76
- const see = (served) => {
77
- if (served == null || served === current || stale) return;
78
- stale = true;
79
- try {
80
- onNewBuild?.(served);
81
- } catch (error) {
82
- reportError(error);
83
- }
84
- };
85
- const observer = typeof PerformanceObserver === "function" ? new PerformanceObserver((list) => {
86
- for (const entry of list.getEntries()) see(timingBuild([entry]));
87
- }) : void 0;
88
- observer?.observe({
89
- type: "resource",
90
- buffered: true
91
- });
92
- return {
93
- isStale: () => stale,
94
- /** Whether `response` comes from a new build of this origin. `url` is the URL of the request. */
95
- isNew: (response, url) => {
96
- const served = isOwn(response.url === "" ? url : response.url) ? response.headers.get(header) ?? headerBuild(response.headers.get("Server-Timing")) : null;
97
- see(served);
98
- return served != null && served !== current;
99
- },
100
- stop: () => observer?.disconnect()
101
- };
102
- }
103
- /** The fragment of a `navigate` target, such as `#usage`, or `""`. */
104
- function hashOf(to) {
105
- return typeof to === "string" && to.includes("#") ? to.slice(to.indexOf("#")) : "";
106
- }
107
- /**
108
- * Moves an open React Router tab to a new build at a navigation, so the old
109
- * client code never renders data from the new server, and the page that the
110
- * visitor reads never reloads. Create it in a module that the client entry
111
- * and `app/root.tsx` both import. It reads no browser state until React
112
- * Router calls it, so the server can import it.
113
- *
114
- * - When the data request of a navigation gets a response from a new build,
115
- * the browser loads the target URL as a document.
116
- * - When the tab already knows of a new build, a `navigate` call, such as a
117
- * link click, loads its target as a document before the router renders it
118
- * or sends a data request. The root middleware does this also for a route
119
- * with no loader.
120
- * - A revalidation, a fetcher, an action, and the loaders after an action
121
- * get their response. They only mark the tab, so the page that the visitor
122
- * reads never reloads.
123
- * - The router's blockers run first, and a canceled navigation never loads
124
- * its target.
125
- *
126
- * It sends no request of its own and adds no wait. It needs `buildId()` in
127
- * the server's pipeline, and it does nothing on a document with no build.
128
- *
129
- * @example
130
- * // app/stale-build.ts
131
- * export const staleBuild = staleBuildReactRouter();
132
- *
133
- * // app/root.tsx
134
- * export const clientMiddleware = [staleBuild.middleware];
135
- *
136
- * // app/entry.client.tsx
137
- * startTransition(() => {
138
- * hydrateRoot(
139
- * document,
140
- * <HydratedRouter
141
- * unstable_fetch={staleBuild.fetch}
142
- * instrumentations={[staleBuild.instrumentation]}
143
- * />,
144
- * );
145
- * });
146
- */
147
- function staleBuildReactRouter(options = {}) {
148
- let watched;
149
- const watch = () => {
150
- watched ??= { watch: watchBuild(options) };
151
- return watched.watch;
152
- };
153
- /**
154
- * The path of the last action of a navigation, until its loaders run. The
155
- * router revalidates the page with one or more loader requests after it.
156
- * `loading` is true while they run.
157
- */
158
- let action;
159
- /** The target that the tab loads as a document now. */
160
- let leaving;
161
- /**
162
- * The last `navigate` call. `claimed` is true when its first middleware call
163
- * already ran, or when it is not a page load. `page` is the target page of
164
- * that first call.
165
- */
166
- let navigating;
167
- const load = async (request, target, { response, navigationType } = {}) => {
168
- if (leaving === target) {
169
- response?.body?.cancel().catch(() => void 0);
170
- return new Promise(() => {});
171
- }
172
- leaving = target;
173
- onAbort(request.signal, () => {
174
- if (leaving === target) leaving = void 0;
175
- });
176
- return loadDocument(target, {
177
- response,
178
- navigationType
179
- });
180
- };
181
- return {
182
- fetch: async (request, context) => {
183
- const navigationType = context.type === "navigation" && context.fetcherKey == null ? context.navigationType : void 0;
184
- const send = async () => {
185
- const response = await globalThis.fetch(request);
186
- return {
187
- response,
188
- isNew: watch()?.isNew(response, request.url) === true
189
- };
190
- };
191
- if (watch() == null || navigationType == null) return (await send()).response;
192
- const page = targetOf(request);
193
- const target = page + (navigationType !== "POP" && navigating?.page === pageOf(page) ? navigating.hash : "");
194
- const path = new URL(target).pathname;
195
- const isAfterAction = request.method === "GET" && action?.path === path;
196
- const isNavigation = () => request.method === "GET" && !isAfterAction && !request.signal.aborted;
197
- if (isNavigation() && watch()?.isStale() === true) return load(request, target, { navigationType });
198
- const { response, isNew } = await send();
199
- if (!isNew || !isNavigation()) return response;
200
- return load(request, target, {
201
- response,
202
- navigationType
203
- });
204
- },
205
- instrumentation: { router: ({ instrument }) => {
206
- watch();
207
- instrument({ navigate: async (handler, { to, formMethod }) => {
208
- const current = {
209
- hash: hashOf(to),
210
- claimed: typeof to === "number" || (formMethod ?? "GET").toUpperCase() !== "GET"
211
- };
212
- navigating = current;
213
- await handler();
214
- if (navigating === current && current.claimed) navigating = void 0;
215
- } });
216
- } },
217
- middleware: async (args, next) => {
218
- const { request, unstable_initiator: initiator, unstable_navigationType: navigationType } = args;
219
- const current = navigating;
220
- if (initiator === "navigation") {
221
- const path = new URL(request.url).pathname;
222
- const mark = action;
223
- if (navigationType === "POP") action = void 0;
224
- else if (request.method !== "GET") {
225
- const started = {
226
- path,
227
- loading: false
228
- };
229
- action = started;
230
- onAbort(request.signal, () => {
231
- if (action === started) action = void 0;
232
- });
233
- return next();
234
- } else if (mark?.path === path) {
235
- mark.loading = true;
236
- try {
237
- return await next();
238
- } finally {
239
- if (action === mark) action = void 0;
240
- }
241
- } else if (mark?.loading === false) action = void 0;
242
- }
243
- if (initiator !== "navigation" || navigationType == null || navigationType === "POP" || current == null || current.claimed) return next();
244
- current.claimed = true;
245
- current.page = pageOf(request.url);
246
- if (request.signal.aborted || watch()?.isStale() !== true || pageOf(request.url) === pageOf(location.href)) return next();
247
- return load(request, request.url + current.hash, { navigationType });
248
- }
249
- };
250
- }
4
+ // src/client/csp-nonce.ts
251
5
  /**
252
- * Moves an open TanStack Router tab to a new build at a navigation, so the
253
- * old client code never renders data from the new server, and the page that
254
- * the visitor reads never reloads. Call it with the router on the client.
6
+ * The CSP nonce of the document, for the framework's render. It gives the
7
+ * same value on the server and in the browser, so the hydration matches.
255
8
  *
256
- * - A navigation runs from `onBeforeNavigate` to `onResolved`. The router
257
- * moves history and runs its blockers before it.
258
- * - When a GET response from a new build comes back while a navigation
259
- * runs, such as from a server function in a loader, the browser loads the
260
- * page as a document.
261
- * - When the tab already knows of a new build, a navigation to a new path or
262
- * query clears the router cache and loads the page as a document.
263
- * - A request outside a navigation gets its response, and only marks the tab.
9
+ * - On the server, the nonce of the request that runs, from `requestContext()`.
10
+ * - In the browser, the nonce of the document's first element with a nonce.
11
+ * Why: React Router's `<HydratedRouter>` takes no nonce, so the app reads it
12
+ * from the document.
264
13
  *
265
- * It sends no request of its own and adds no wait. It needs `buildId()` in
266
- * the server's pipeline, and it does nothing on a document with no build.
267
- * It returns a function that stops it and gives back `fetch`. If the app
268
- * wrapped `fetch` after it, the wrapper stays, and each request passes on.
14
+ * It gives `undefined` when the page has no nonce: with no
15
+ * `contentSecurityPolicy` plugin, during a prerender, and on a prerendered page.
16
+ * A bundler that resolves the `browser` condition, such as Vite for the
17
+ * client, gets a build with no server code.
269
18
  *
270
19
  * @example
271
- * // src/router.tsx
272
- * export function getRouter() {
273
- * const router = createRouter({ routeTree });
274
- * if (!router.isServer) {
275
- * staleBuildTanStack(router);
276
- * }
277
- * return router;
278
- * }
20
+ * <Scripts nonce={cspNonce()} />
279
21
  */
280
- function staleBuildTanStack(router, options = {}) {
281
- const watch = watchBuild(options);
282
- if (watch == null) return () => {};
283
- /** The navigation that runs now. `leaving` is true when it already loads its page as a document. */
284
- let navigation;
285
- const reload = async (current, response) => {
286
- if (current.leaving) {
287
- response?.body?.cancel().catch(() => void 0);
288
- return new Promise(() => {});
289
- }
290
- current.leaving = true;
291
- router.history.flush();
292
- return loadDocument(location.href, { response });
293
- };
294
- const unsubscribe = [router.subscribe("onBeforeNavigate", ({ fromLocation, toLocation }) => {
295
- navigation = void 0;
296
- if (fromLocation == null || eventPage(fromLocation) === eventPage(toLocation)) return;
297
- navigation = { leaving: false };
298
- if (watch.isStale()) {
299
- router.clearCache();
300
- reload(navigation);
301
- }
302
- }), router.subscribe("onResolved", () => {
303
- navigation = void 0;
304
- })];
305
- const send = globalThis.fetch;
306
- let isStopped = false;
307
- const patched = async (input, init) => {
308
- if (isStopped) return send.call(globalThis, input, init);
309
- const isGet = methodOf(input, init) === "GET";
310
- if (isGet && navigation != null && watch.isStale()) return reload(navigation);
311
- const response = await send.call(globalThis, input, init);
312
- if (!watch.isNew(response, urlOf(input)) || !isGet || navigation == null) return response;
313
- return reload(navigation, response);
314
- };
315
- globalThis.fetch = patched;
316
- return () => {
317
- for (const stop of unsubscribe) stop();
318
- watch.stop();
319
- isStopped = true;
320
- navigation = void 0;
321
- if (globalThis.fetch === patched) globalThis.fetch = send;
322
- };
22
+ function cspNonce() {
23
+ return typeof document === "undefined" ? requestContext()?.cspNonce : documentNonce();
323
24
  }
324
25
 
325
- export { staleBuildReactRouter, staleBuildTanStack };
26
+ export { cspNonce, staleBuildReactRouter, staleBuildTanStack };
326
27
  //# sourceMappingURL=client.js.map