@uniflowed/router 0.0.0-alpha.4 → 0.0.0-alpha.41

package/internal/prepare-document.js

@@ -0,0 +1,49 @@
+// @flow
+//
+// Internal to `@uniflowed/router`: a server's document, made ready for React to
+// hydrate.
+//
+// Where a server wrote the head's metadata, an element React leaves behind, and
+// the placeholder action React writes into a form whose action is a function
+// (its server and its client spell that placeholder differently): none of these
+// comes from a route, and each would be reported as a mismatch. So each is put
+// right before `hydrateRoot` compares the markup with the tree. Both ways of
+// hydrating do it — `hydrate` in `../client.js`, for a route rendered from its
+// modules, and `hydrateFlight` in `../rsc-client.js`, for one React Server
+// Components rendered — so the code lives here rather than in either entry.
+
+export function prepareDocumentForHydration(document: Document): void {
+  const head = document.head;
+  const envelope = head.querySelector('meta[name="uf:render"]');
+  if (envelope != null && head.firstChild !== envelope) {
+    head.insertBefore(envelope, head.firstChild);
+  }
+  moveLayoutMetaAfterRouteHead(head, head.querySelector("meta[charset]"));
+  moveLayoutMetaAfterRouteHead(head, head.querySelector('meta[name="viewport"]'));
+  document.getElementById("_R_")?.remove();
+  normalizeReactFormActions(document);
+}
+
+function moveLayoutMetaAfterRouteHead(head: HTMLHeadElement, meta: Element | null): void {
+  if (meta == null) {
+    return;
+  }
+  const colorScheme = head.querySelector('meta[name="color-scheme"]');
+  if (colorScheme != null && colorScheme !== meta) {
+    head.insertBefore(meta, colorScheme);
+    return;
+  }
+  head.appendChild(meta);
+}
+
+const SERVER_FORM_PLACEHOLDER = "javascript:throw new Error('React form unexpectedly submitted.')";
+const CLIENT_FORM_PLACEHOLDER =
+  "javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')";
+
+function normalizeReactFormActions(document: Document): void {
+  for (const form of document.querySelectorAll("form")) {
+    if (form.getAttribute("action") === SERVER_FORM_PLACEHOLDER) {
+      form.setAttribute("action", CLIENT_FORM_PLACEHOLDER);
+    }
+  }
+}

package/internal/react-version.js

@@ -0,0 +1,77 @@
+// @flow
+//
+// Internal to `@uniflowed/router`: the React that React Server Components need.
+//
+// The router installs beside React 19.2.3, the React that Expo SDK 57 and React
+// Native 0.87 ship. Matching a URL, the native route table and a route rendered
+// from its modules need nothing newer (ubugeeei-prod/uf#992). React Server
+// Components do. They render through `react-server-dom-parcel`, React's own
+// Flight renderer and client, which is released with React and requires the
+// React it was released with: 19.3. So that package is an optional peer, and
+// every module that loads it asks here first.
+//
+// # Why a check at run time
+//
+// A peer range cannot say it. The router has one range for `react`, and that
+// range has to admit 19.2.3 for a native app, while an optional peer that is
+// absent is never compared with anything. The failure is also not where the
+// mistake is: React's Flight client imports against React 19.2 and fails later,
+// inside a render, in terms of React's internals. So each entry that loads
+// Flight refuses before it does anything, and names the React it found and the
+// one it needs.
+//
+// It is a call rather than a statement at module scope, because no shipped
+// module runs anything when it is imported
+// (`crates/uf_lib/tests/package_surface.rs`).
+
+import * as React from "react";
+
+/** The oldest React that React Server Components render on. */
+export const SERVER_COMPONENTS_REACT: string = "19.3.0";
+
+/**
+ * Why `entry` cannot run on React `installed`, or `null` when it can.
+ *
+ * The release numbers are compared and a prerelease tag is ignored, so a 19.3
+ * canary counts as 19.3: React names a canary after the release it leads to.
+ */
+export function serverComponentsRefusal(entry: string, installed: string): string | null {
+  const found = releaseOf(installed);
+  const needed = releaseOf(SERVER_COMPONENTS_REACT);
+  if (found != null && needed != null && !isBefore(found, needed)) {
+    return null;
+  }
+  return (
+    `@uniflowed/router: ${entry} needs React ${SERVER_COMPONENTS_REACT} or newer for React ` +
+    `Server Components, and the React it loaded is ${installed}. Install react, react-dom and ` +
+    "react-server-dom-parcel at ^19.3.0, or set `app.rsc: false` in uf.config.js to render " +
+    "routes from their modules, which the router supports from React 19.2.3."
+  );
+}
+
+/**
+ * Refuse, with [`serverComponentsRefusal`]'s sentence, unless the React this
+ * module loaded can render React Server Components.
+ */
+export function requireServerComponentsReact(entry: string): void {
+  const refusal = serverComponentsRefusal(entry, React.version);
+  if (refusal != null) {
+    throw new Error(refusal);
+  }
+}
+
+/** `[major, minor, patch]` of a version, or `null` when it does not start with one. */
+function releaseOf(version: string): [number, number, number] | null {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return match == null ? null : [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+/** Whether release `a` comes before release `b`. */
+function isBefore(a: [number, number, number], b: [number, number, number]): boolean {
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) {
+      return a[index] < b[index];
+    }
+  }
+  return false;
+}

package/internal/request.js

@@ -0,0 +1,43 @@
+// @flow
+//
+// Internal to `@uniflowed/router`: the request the server half runs inside.
+//
+// One function, and it exists because two modules need the same refusal.
+// `createMiddlewareRunner` and `createDispatcher` both used to build a request
+// context of their own — `contextFor`, then `runWithContext`, then
+// `drainDeferred` — which gave one request up to two contexts and ran what
+// `after()` deferred before the response was written, and in the middleware's
+// case before there was a response at all. See ubugeeei-prod/uf#389.
+//
+// Both now run inside whatever request the host established, which means both
+// depend on the host having established one. That dependency is checked rather
+// than assumed, for the reason `createApplicationHandler` gives about
+// `entry.runMiddleware` itself: a missing half of the contract should be a
+// failure on the first request, not an application that answers strangely.
+//
+// Server-only, like the two modules that import it. Nothing the browser loads
+// reaches this.
+
+import { insideRequest } from "@uniflowed/server/host";
+
+/**
+ * Refuse to run outside a request, naming what has to establish one.
+ *
+ * The message is addressed to whoever wired the host, because that is who can
+ * fix it. Left to fail on its own, a mis-wired host would surface as the first
+ * `cookies()` in somebody's guard throwing "called outside a request … a
+ * static prerender, a module's top level, or a client component" — three
+ * places to look, none of them this one — and an application that calls no
+ * server function at all would sail past that and lose every `after()` instead.
+ */
+export function requireRequest(entry: string): void {
+  if (insideRequest()) {
+    return;
+  }
+  throw new Error(
+    `@uniflowed/router: ${entry}() was called outside a request. A host owns the request: ` +
+      "begin it with `beginRequest` from `@uniflowed/server/host` (a bundled application " +
+      "re-exports it from `virtual:uf/server`), run the whole request inside `run`, and call " +
+      "`settle` once the response has been sent. See ubugeeei-prod/uf#389.",
+  );
+}