@uniflowed/router 0.9.0 → 0.11.0

package/client.js

@@ -209,7 +209,7 @@ export async function hydrate(options: {|
   // `import.meta.hot` is the gate because it is the one signal that is right in
   // all three places this module is evaluated. Vite defines it while serving
   // and replaces it with `undefined` in a build, so the branch is statically
-  // dead there; Node leaves it undefined, so `packages/vite/rsc-split.test.js`
+  // dead there; Node leaves it undefined, so `npm/vite/rsc-split.test.js`
   // imports this file without a bundler and gets the production path. The
   // import is dynamic so that the overlay is not merely shaken out of a
   // production bundle but never reachable from one.

package/internal/devtools.js

@@ -4,7 +4,7 @@
 // to the page this browser just hydrated.
 //
 // `@uniflowed/vite` installs the hook DevTools attaches through, as a classic
-// script above every module — see `packages/vite/internal/devtools.js`, which
+// script above every module — see `npm/vite/internal/devtools.js`, which
 // has the argument. That is uf saying what it intends. This is the half that
 // checks it happened, and the two are not the same claim: the preamble is
 // injected by a `transformIndexHtml` hook, into a document a project's own Vite
@@ -29,7 +29,7 @@
 // panel props, hooks and source positions — is not checked here because a
 // browser cannot tell the difference from the outside, and because uf owns it
 // end to end: `mode` is `development` and `uf transform` is called with
-// `development: true`, both asserted in `packages/vite/devtools.test.js`
+// `development: true`, both asserted in `npm/vite/devtools.test.js`
 // against the plugin rather than against a page. What is left is what only a
 // running page knows.
 //
@@ -53,7 +53,7 @@ import { reportDiagnostic } from "./diagnostics.js";
  * that file's neighbour `internal/diagnostics.js` gives about the endpoint
  * paths: `@uniflowed/vite` is loaded by Vite before any Flow transform exists
  * and this module is Flow, so the import cannot go either way.
- * `packages/vite/devtools.test.js` asserts the two spellings agree, which is
+ * `npm/vite/devtools.test.js` asserts the two spellings agree, which is
  * what makes a duplicated constant honest.
  */
 export const DEVTOOLS_HOOK: string = "__REACT_DEVTOOLS_GLOBAL_HOOK__";

package/internal/diagnostics.js

@@ -29,7 +29,7 @@
 // published package that depends on an unpublished one, because the tarball
 // would name a version the registry does not have; `@uniflowed/router` is on
 // npm and `@uniflowed/hmr` is a declaration package that is not. What the two
-// posters do share is the contract, and `packages/vite/dev-channel.test.js`
+// posters do share is the contract, and `npm/vite/dev-channel.test.js`
 // asserts that every spelling of these paths agrees — a duplicated constant
 // with a test on it is honest, and one without is how a browser ends up
 // posting to a path nothing serves.

package/internal/flight-browser.js

@@ -99,6 +99,9 @@ export function installBrowserModules(): void {
         ),
       );
     }
+    // A chunk the payload names, known only at run time and checked to be on
+    // this origin above; Flow types only a literal specifier.
+    // $FlowFixMe[unsupported-syntax]
     return import(target.href).then((namespace: ModuleNamespace) => {
       loaded.set(url, namespace);
     });

package/internal/flight-chunks.js

@@ -62,7 +62,7 @@ function elementJson(value: FlightChunk): string {
  * `application/json` and therefore a data block the browser never executes.
  * Two reasons, and neither is "in case the spec changes". A uf document's
  * invariant is that every `<script>` in it carries the nonce — that is what
- * `packages/router/streaming.test.js` pins, and an invariant with an exception
+ * `npm/router/streaming.test.js` pins, and an invariant with an exception
  * in it is one a reader has to check every new script against. And these are
  * written as text into a stream rather than rendered by React, so unlike the
  * payload rows in `./runtime.js` there is no second render on the client to

package/internal/resolve.js

@@ -199,7 +199,7 @@ export type ErrorModule = {
  * No `metadata`, and that is the type saying something true rather than an
  * omission. A fallback renders while the route is still resolving, and the
  * route's metadata was decided before the first byte — a title on a file that
- * renders after the head has gone could never be used. `packages/web/head.js`
+ * renders after the head has gone could never be used. `npm/web/head.js`
  * documents the same constraint from the other side.
  */
 export type LoadingModule = {

package/internal/runtime.js

@@ -1925,7 +1925,7 @@ function rowFailure(error: mixed): string {
  * So this returns elements rather than writing to the head. Writing would have
  * to happen in an effect, an effect does not run on a server, and the result
  * would be a page whose tags are right in a browser and missing from the
- * crawler — `packages/web/head.js` is that escape hatch and says so at the top
+ * crawler — `npm/web/head.js` is that escape hatch and says so at the top
  * of the file. Rendering is what puts a tag in a server-rendered head, so the
  * caller renders what comes back:
  *
@@ -2126,7 +2126,7 @@ function isExternal(to: string): boolean {
  * It is safe above a root layout that renders `<html>` only because the
  * envelope's carrier is a `<meta>`: React hoists one into the head of a
  * document it rendered, and to the front of a tree that is not one, where uf's
- * shell lifts it into the head it wrote itself. `packages/hooks/render.js` has
+ * shell lifts it into the head it wrote itself. `npm/hooks/render.js` has
  * the argument, and it is the reason the carrier is no longer a `<script>`.
  */
 export function routerView(root: string): React.ComponentType<AppProps> {

package/internal/stream.js

@@ -11,7 +11,7 @@
 //
 // # The head is written before the body
 //
-// `packages/web/head.js` says this from the other side, as the reason `useHead`
+// `npm/web/head.js` says this from the other side, as the reason `useHead`
 // does nothing on a server: once the body is streaming, the head has gone and
 // no component can still change it. This module is what makes that true rather
 // than merely claimed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/router",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "The file-system router for Flow React applications: matching, layouts, loaders, navigation, server rendering and hydration.",
   "type": "module",
   "license": "MIT",
@@ -8,7 +8,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ubugeeei-prod/uf.git",
-    "directory": "packages/router"
+    "directory": "npm/router"
   },
   "exports": {
     ".": {
@@ -73,8 +73,8 @@
     }
   },
   "dependencies": {
-    "@uniflowed/hooks": "0.9.0",
-    "@uniflowed/server": "0.9.0",
-    "@uniflowed/validator": "0.9.0"
+    "@uniflowed/hooks": "0.11.0",
+    "@uniflowed/server": "0.11.0",
+    "@uniflowed/validator": "0.11.0"
   }
 }

package/server.js

@@ -195,7 +195,7 @@ export type RenderOptions = {|
    *
    * uf's own injections are `head` and `head-prepend`, and Vite's client is
    * head-injected, so this is about a third-party plugin.
-   * `packages/vite/dev-head-transform.test.js` pins the table above, so the day
+   * `npm/vite/dev-head-transform.test.js` pins the table above, so the day
    * it changes is a failing test rather than a surprise.
    */
   readonly transformHead?: (html: string) => Promise<string>,