@uniflowed/router 0.15.0 → 0.17.0

package/internal/base-path.js

@@ -36,13 +36,35 @@ export type RoutingSettings = {|
 let installedBase: string = "";
 let installedSlash: TrailingSlash = "ignore";
 
+/**
+ * The string `@uniflowed/web`'s vitals beacon reads. Duplicated there on
+ * purpose: that package does not depend on this one, and the symbol is not
+ * part of the public API. The two have to move together. ubugeeei-prod/uf#1701
+ */
+const ROUTING_BASE: symbol = Symbol.for("@uniflowed/router.basePath");
+
+function publishBase(base: string): void {
+  // `globalThis[symbol]` is a computed property on a namespace, which Flow
+  // rejects. `Object.defineProperty` is the write the rest of the repo uses.
+  Object.defineProperty(globalThis, ROUTING_BASE, {
+    value: base,
+    writable: true,
+    configurable: true,
+  });
+}
+
 /**
  * Say where this application is served and how its paths are spelled. Called
  * once, by the entry that starts it.
+ *
+ * This is what publishes the base `vitalsBeacon` reads. The module does not
+ * publish when it loads: nothing installed is the root, and a shipped module
+ * cannot run a call at import time. ubugeeei-prod/uf#1701
  */
 export function installRouting(settings: RoutingSettings): void {
   installedBase = normalizeBase(settings.basePath ?? "");
   installedSlash = settings.trailingSlash ?? "ignore";
+  publishBase(installedBase);
 }
 
 /**
@@ -143,10 +165,18 @@ export function spellPath(path: string, policy: TrailingSlash, underBase: boolea
   return policy === "always" ? `${trimmed}/` : trimmed;
 }
 
-/** Whether a path's last segment has an extension. */
+/**
+ * Whether a path's last segment is a file: it has an extension, or it is
+ * Apple's association file.
+ *
+ * That file has no dot, and it is served only without a trailing slash.
+ * `trailingSlash: "always"` must not add one. The server's copy is
+ * `@uniflowed/server`'s `internal/routing.js`; `routing.test.js` holds the
+ * two to one answer. ubugeeei-prod/uf#1704
+ */
 function looksLikeAFile(path: string): boolean {
   const last = path.slice(path.lastIndexOf("/") + 1);
-  return last.includes(".");
+  return last.includes(".") || last.toLowerCase() === "apple-app-site-association";
 }
 
 function splitPath(to: string): {| readonly path: string, readonly rest: string |} {

package/internal/diagnostics.js

@@ -48,6 +48,8 @@
 // a URL, so it cannot be pointed at somebody else's server. Nothing leaves the
 // machine.
 
+import { basePath } from "./base-path.js";
+
 /**
  * The path `uf dev` serves the diagnostic channel on.
  *
@@ -145,7 +147,7 @@ export function reportDiagnostic(diagnostic: BrowserDiagnostic, endpoint?: strin
   // about development tooling. Losing the report is the right outcome when
   // there is nothing listening; reporting the loss as an application error is
   // not.
-  post(endpoint ?? DIAGNOSTIC_ENDPOINT, {
+  post(endpoint ?? `${basePath()}${DIAGNOSTIC_ENDPOINT}`, {
     method: "POST",
     body,
     keepalive: true,

package/internal/head.js

@@ -10,6 +10,7 @@
 
 import * as React from "react";
 
+import { addressOf } from "./base-path.js";
 import type { JsonLd, Metadata, Robots } from "./resolve.js";
 
 /**
@@ -22,18 +23,26 @@ import type { JsonLd, Metadata, Robots } from "./resolve.js";
  * Three things it deliberately does not do. It does not resolve against the
  * *page's* URL: `Head` renders inside the route and does not know it, and a
  * `metadataBase` is a site-wide fact rather than a per-page one. It does not
- * invent a base: with none declared the value is emitted exactly as written,
- * which is what every page that predates this field already gets. And it does
- * not throw — a `metadataBase` that is not a URL is a mistake in one field,
- * and turning it into a blank page would be a worse answer than an unresolved
- * `og:image`.
+ * invent a `metadataBase`: with none declared, a root-relative value is the
+ * address the router writes — the installed base in front of an application
+ * path — and every other value is emitted as written. The routing base is not
+ * a host, and a page that predates `metadataBase` still gets no origin invented
+ * for it. And it does not throw — a `metadataBase` that is not a URL is a
+ * mistake in one field, and turning it into a blank page would be a worse
+ * answer than an unresolved `og:image`.
  */
 function absoluteUrl(value: string, base: void | string): string {
-  if (base == null) return value;
+  // `addressOf` leaves an absolute URL, a protocol-relative URL, `mailto:`,
+  // a query and a fragment as written, and it does not add a slash to a file.
+  // A path-absolute URL replaces `metadataBase`'s path, so the base has to be
+  // in the path before `URL` sees it or `og:image` drops `app.router.basePath`.
+  // ubugeeei-prod/uf#1705
+  const addressed = addressOf(value);
+  if (base == null) return addressed;
   try {
-    return new URL(value, base).href;
+    return new URL(addressed, base).href;
   } catch {
-    return value;
+    return addressed;
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/router",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "The file-system router for Flow React applications: matching, layouts, loaders, navigation, server rendering and hydration.",
   "type": "module",
   "license": "MIT",
@@ -73,8 +73,8 @@
     }
   },
   "dependencies": {
-    "@uniflowed/hooks": "0.15.0",
-    "@uniflowed/server": "0.15.0",
-    "@uniflowed/validator": "0.15.0"
+    "@uniflowed/hooks": "0.17.0",
+    "@uniflowed/server": "0.17.0",
+    "@uniflowed/validator": "0.17.0"
   }
 }

package/rsc-client.js

@@ -47,7 +47,7 @@ import { readFormState } from "./internal/form-action.js";
 
 // What `virtual:uf/client` calls in development when a server component
 // changed; see "Hot updates" in `./internal/runtime.js`.
-export { refreshForHotUpdate } from "./internal/runtime.js";
+export { acceptHotRouteModules, refreshForHotUpdate } from "./internal/runtime.js";
 
 /**
  * Hydrate a document React Server Components rendered.