@uniflowed/router 0.33.0 → 0.35.0

package/internal/flight.js

@@ -39,26 +39,26 @@ import type { Metadata, ResolvedRoute } from "./resolve.js";
  * message in development and replaced by React's own sentence in a build.
  */
 export type RouteState = {|
-  readonly pathname: string,
-  readonly search: string,
-  readonly path: string,
-  readonly params: RouteParams,
+  readonly pathname    : string,
+  readonly search      : string,
+  readonly path        : string,
+  readonly params      : RouteParams,
   readonly searchParams: SearchParams,
   /** What the loader returned, once it has. `undefined` while `deferred` is set. */
   readonly data: mixed,
   /** The loader still running, as a promise the browser can `use`. */
-  readonly deferred: ?Promise<mixed>,
-  readonly metadata: Metadata,
+  readonly deferred      : ?Promise<mixed>,
+  readonly metadata      : Metadata,
   readonly viewTransition: ?string,
-  readonly status: 200 | 400 | 401 | 403 | 404 | 500,
-  readonly error: ?RouteError,
-  readonly interception?: ?FlightInterception,
+  readonly status        : 200 | 400 | 401 | 403 | 404 | 500,
+  readonly error         : ?RouteError,
+  readonly interception? : ?FlightInterception,
 |};
 
 /** Row 0 of a route's payload: the route, and the tree it rendered. */
 export type FlightRoot = {|
   readonly route: RouteState,
-  readonly tree: Node,
+  readonly tree : Node,
   /**
    * The build that rendered it, when the build has an id.
    *
@@ -73,8 +73,8 @@ export type FlightRoot = {|
 /** The intercepted URL a Flight payload rendered, and the page it rendered over. */
 export type FlightInterception = {|
   readonly pathname: string,
-  readonly search: string,
-  readonly from: string,
+  readonly search  : string,
+  readonly from    : string,
 |};
 
 /** What the browser may send with a payload request. */
@@ -102,7 +102,7 @@ export type FetchedFlight =
   | {|
       readonly kind: "flight",
       /** The route the server answered for: a redirect's target, when there was one. */
-      readonly url: string,
+      readonly url : string,
       readonly root: Promise<FlightRoot>,
     |}
   | {|
@@ -112,7 +112,7 @@ export type FetchedFlight =
        * document.
        */
       readonly kind: "document",
-      readonly url: string,
+      readonly url : string,
     |};
 
 /**
@@ -152,24 +152,24 @@ export function crossableRouteError(error: ?RouteError): ?RouteError {
 export function routeState(resolved: ResolvedRoute): RouteState {
   const interception = resolved.interception;
   return {
-    pathname: resolved.pathname,
-    search: resolved.search,
-    path: resolved.path,
-    params: resolved.params,
-    searchParams: resolved.searchParams,
-    data: resolved.data,
-    deferred: resolved.deferred,
-    metadata: resolved.metadata,
+    pathname      : resolved.pathname,
+    search        : resolved.search,
+    path          : resolved.path,
+    params        : resolved.params,
+    searchParams  : resolved.searchParams,
+    data          : resolved.data,
+    deferred      : resolved.deferred,
+    metadata      : resolved.metadata,
     viewTransition: resolved.viewTransition,
-    status: resolved.status,
-    error: resolved.error,
+    status        : resolved.status,
+    error         : resolved.error,
     interception:
       interception == null
         ? null
         : {
             pathname: interception.pathname,
-            search: interception.search,
-            from: interception.base.pathname + interception.base.search,
+            search  : interception.search,
+            from    : interception.base.pathname + interception.base.search,
           },
   };
 }

package/internal/form-action.js

@@ -61,10 +61,10 @@ export const FORM_ACTION_CONTENT_TYPE = "application/x-www-form-urlencoded";
 
 /** What `$$FORM_ACTION` answers, in the shape React reads. */
 export type FormActionFields = {|
-  readonly name: string,
-  readonly method: "POST",
+  readonly name   : string,
+  readonly method : "POST",
   readonly encType: string,
-  readonly data: FormData,
+  readonly data   : FormData,
 |};
 
 /**
@@ -92,8 +92,8 @@ export type FormState = [mixed, string, string, number];
  * network call in the browser.
  */
 export function withFormAction<T extends (...args: $ReadOnlyArray<empty>) => mixed>(
-  fn: T,
-  id: string,
+  fn   : T,
+  id   : string,
   bound: $ReadOnlyArray<mixed>,
 ): T {
   const define = (name: string, value: mixed) => {
@@ -125,8 +125,8 @@ export function withFormAction<T extends (...args: $ReadOnlyArray<empty>) => mix
  * so an unencodable state costs the pre-hydration submit and nothing else.
  */
 export function formFields(
-  id: string,
-  bound: $ReadOnlyArray<mixed>,
+  id    : string,
+  bound : $ReadOnlyArray<mixed>,
   prefix: string,
 ): FormActionFields {
   const data = new FormData();
@@ -135,8 +135,8 @@ export function formFields(
     data.append(`${FORM_BOUND_FIELD}${prefix}`, encodeActionArguments(bound));
   }
   return {
-    name: `${FORM_REF_FIELD}${prefix}`,
-    method: "POST",
+    name   : `${FORM_REF_FIELD}${prefix}`,
+    method : "POST",
     encType: FORM_ACTION_CONTENT_TYPE,
     data,
   };
@@ -184,8 +184,8 @@ export function readFormPost(fields: URLSearchParams): FormPost | null {
     }
   }
   return {
-    id: fields.get(`${FORM_ID_FIELD}${prefix}`),
-    bound: fields.get(`${FORM_BOUND_FIELD}${prefix}`),
+    id      : fields.get(`${FORM_ID_FIELD}${prefix}`),
+    bound   : fields.get(`${FORM_BOUND_FIELD}${prefix}`),
     stateKey: fields.get(FORM_STATE_KEY_FIELD),
     entries,
   };

package/internal/hydrate-options.js

@@ -21,7 +21,7 @@ type HydrationOptions = {| onRecoverableError?: Recovery, formState?: FormState
  * hook starts from the action's result instead of its initial state.
  */
 export function hydrationOptions(
-  recovery: ?Recovery,
+  recovery : ?Recovery,
   formState: FormState | void,
 ): HydrationOptions | void {
   // React's default reporter dispatches a global error for a boundary it

package/internal/hydration.js

@@ -135,7 +135,7 @@ export type HydrationDifference = {|
 export type HydrationReport = {|
   /** React's own message, kept because it is the thing people search for. */
   readonly message: string,
-  readonly cause: HydrationCause,
+  readonly cause  : HydrationCause,
   /** One sentence saying what that cause means, in the reader's own page. */
   readonly explanation: string,
   /** What to do about it. Empty for `unknown`, which has no advice worth giving. */
@@ -178,7 +178,7 @@ const COMMENT_NODE = 8;
 
 type DetachedHeadStyle = {|
   readonly anchor: Comment,
-  readonly style: HTMLStyleElement,
+  readonly style : HTMLStyleElement,
 |};
 
 /**
@@ -291,9 +291,9 @@ function serialize(container: Node): string | null {
  * has ever been about it.
  */
 function parseServerMarkup(
-  markup: string,
+  markup   : string,
   container: Node,
-  document: Document,
+  document : Document,
 ): {| server: $ReadOnlyArray<Node>, client: $ReadOnlyArray<Node> |} | null {
   const asDocument = container as $FlowFixMe as { documentElement?: ?Element, ... };
   const live = asDocument.documentElement;
@@ -399,11 +399,11 @@ function firstDifference(
     }
     if (frame.kind === "unmatched") {
       return {
-        kind: frame.server == null ? "extra" : "missing",
-        path: frame.path,
+        kind     : frame.server == null ? "extra" : "missing",
+        path     : frame.path,
         attribute: null,
-        server: frame.server == null ? null : show(frame.server),
-        client: frame.client == null ? null : show(frame.client),
+        server   : frame.server == null ? null : show(frame.server),
+        client   : frame.client == null ? null : show(frame.client),
       };
     }
 
@@ -413,8 +413,8 @@ function firstDifference(
         kind: "node-type",
         path,
         attribute: null,
-        server: show(server),
-        client: show(client),
+        server   : show(server),
+        client   : show(client),
       };
     }
     if (server.nodeType === TEXT_NODE || server.nodeType === COMMENT_NODE) {
@@ -423,8 +423,8 @@ function firstDifference(
           kind: "text",
           path,
           attribute: null,
-          server: show(server),
-          client: show(client),
+          server   : show(server),
+          client   : show(client),
         };
       }
       continue;
@@ -460,11 +460,11 @@ function firstDifference(
  * document order, with a marker where one side runs out before the other.
  */
 function pushChildren(
-  stack: Array<Frame>,
+  stack : Array<Frame>,
   server: $ReadOnlyArray<Node>,
   client: $ReadOnlyArray<Node>,
-  path: string,
-  depth: number,
+  path  : string,
+  depth : number,
 ): void {
   const most = Math.max(server.length, client.length);
   for (let index = most - 1; index >= 0; index -= 1) {
@@ -473,18 +473,18 @@ function pushChildren(
     if (onServer == null || onClient == null) {
       const present = onServer ?? onClient;
       stack.push({
-        kind: "unmatched",
+        kind  : "unmatched",
         server: onServer,
         client: onClient,
-        path: present == null ? path : join(path, present, index),
+        path  : present == null ? path : join(path, present, index),
       });
       continue;
     }
     stack.push({
-      kind: "pair",
+      kind  : "pair",
       server: onServer,
       client: onClient,
-      path: join(path, onServer, index),
+      path  : join(path, onServer, index),
       depth,
     });
   }
@@ -615,15 +615,15 @@ function classify(message: string, difference: HydrationDifference | null): Hydr
   // Every kind is named, so a kind added to `DifferenceKind` stops this file
   // compiling rather than arriving in somebody's overlay as "unknown".
   return match (difference.kind) {
-    "extra" | "missing" => "browser-only",
+    "extra" | "missing"                                      => "browser-only",
     // Text on one side and whitespace on the other is a node that only one
     // render produced, not two renders that disagreed about a value.
     "text" if (server.trim() === "" || client.trim() === "") => "browser-only",
-    "text" => sameShape(server, client) ? "variable-input" : "unknown",
-    "attribute" if (oneSided) => "browser-only",
-    "attribute" => sameShape(server, client) ? "variable-input" : "unknown",
+    "text"                                                   => sameShape(server, client) ? "variable-input" : "unknown",
+    "attribute" if (oneSided)                                => "browser-only",
+    "attribute"                                              => sameShape(server, client) ? "variable-input" : "unknown",
     // The two trees hold different nodes here, which says nothing about why.
-    "node-type" | "tag" => "unknown",
+    "node-type" | "tag"                                      => "unknown",
   };
 }
 
@@ -655,10 +655,10 @@ const REMEDIES: { readonly [HydrationCause]: string } = {
  * global.
  */
 export function hydrationReport(input: {|
-  readonly message: string,
-  readonly serverMarkup: string | null,
-  readonly container: Node | null,
-  readonly document: Document,
+  readonly message       : string,
+  readonly serverMarkup  : string | null,
+  readonly container     : Node | null,
+  readonly document      : Document,
   readonly componentStack: string | null,
 |}): HydrationReport {
   const components = componentsOf(input.componentStack);
@@ -668,7 +668,7 @@ export function hydrationReport(input: {|
     message: input.message,
     cause,
     explanation: EXPLANATIONS[cause],
-    remedy: REMEDIES[cause],
+    remedy     : REMEDIES[cause],
     difference,
     components,
     note,
@@ -676,10 +676,10 @@ export function hydrationReport(input: {|
 }
 
 function compare(input: {|
-  readonly message: string,
-  readonly serverMarkup: string | null,
-  readonly container: Node | null,
-  readonly document: Document,
+  readonly message       : string,
+  readonly serverMarkup  : string | null,
+  readonly container     : Node | null,
+  readonly document      : Document,
   readonly componentStack: string | null,
 |}): {| difference: HydrationDifference | null, note: string | null |} {
   if (input.serverMarkup == null || input.container == null) {
@@ -1031,9 +1031,9 @@ function paragraph(document: Document, text: string, className: string | null):
  * all. See ubugeeei-prod/uf#583.
  */
 export function hydrationErrorHandler(
-  container: Node,
+  container   : Node,
   serverMarkup: string | null,
-  document: Document,
+  document    : Document,
 ): (error: mixed, info: { componentStack?: ?string, ... }) => void {
   return (error, info) => {
     const message = error instanceof Error ? error.message : String(error);
@@ -1074,8 +1074,8 @@ export function hydrationErrorHandler(
     const [headlineLine, ...rest] = text.split("\n");
     reportDiagnostic({
       severity: "error",
-      message: headlineLine,
-      detail: rest,
+      message : headlineLine,
+      detail  : rest,
     });
   };
 }

package/internal/inspector.js

@@ -132,10 +132,10 @@ const COMPLETE_MARKER = '$RC("';
  * never saw — one past [`LABEL_SCAN_BYTES`], or split across two chunks.
  */
 export type StreamedBoundary = {|
-  readonly id: string,
+  readonly id      : string,
   readonly fallback: ?string,
-  readonly built: $ReadOnlyArray<string>,
-  readonly more: number,
+  readonly built   : $ReadOnlyArray<string>,
+  readonly more    : number,
 |};
 
 /** One chunk of one document, as it went out. */
@@ -154,20 +154,20 @@ export type StreamedChunk = {|
 export type StreamRecord = {|
   readonly chunks: $ReadOnlyArray<StreamedChunk>,
   /** Chunks past [`CHUNK_LIMIT`], which are counted and not described. */
-  readonly more: number,
+  readonly more : number,
   readonly bytes: number,
 |};
 
 /** A recorder, over one document. */
 export type StreamRecorder = {|
-  readonly chunk: (text: string) => void,
+  readonly chunk : (text: string) => void,
   readonly finish: () => StreamRecord,
 |};
 
 /** What the reporter hands `uf dev` to print. */
 export type StreamDiagnostic = {|
   readonly message: string,
-  readonly detail: $ReadOnlyArray<string>,
+  readonly detail : $ReadOnlyArray<string>,
 |};
 
 /**
@@ -206,9 +206,9 @@ export function inspectStream(now: () => number): StreamRecorder {
         return;
       }
       chunks.push({
-        index: count,
-        at: first == null ? 0 : Math.max(0, Math.round(at - first)),
-        bytes: size,
+        index     : count,
+        at        : first == null ? 0 : Math.max(0, Math.round(at - first)),
+        bytes     : size,
         boundaries: completedIn(text, labels),
       });
     },
@@ -232,7 +232,7 @@ export function inspectStream(now: () => number): StreamRecorder {
 export async function* inspected(
   chunks: AsyncGenerator<string, void, void>,
   report: (record: StreamRecord) => void,
-  now: () => number,
+  now   : () => number,
 ): AsyncGenerator<string, void, void> {
   const recorder = inspectStream(now);
   try {
@@ -307,10 +307,10 @@ function completedIn(chunk: string, labels: Map<string, string>): $ReadOnlyArray
     }
     const built = builtBy(chunk, ids.content);
     found.push({
-      id: ids.boundary,
+      id      : ids.boundary,
       fallback: labels.get(ids.boundary) ?? null,
-      built: built.slice(0, NAMED_LIMIT),
-      more: Math.max(0, built.length - NAMED_LIMIT),
+      built   : built.slice(0, NAMED_LIMIT),
+      more    : Math.max(0, built.length - NAMED_LIMIT),
     });
   }
   return found;
@@ -319,7 +319,7 @@ function completedIn(chunk: string, labels: Map<string, string>): $ReadOnlyArray
 /** The two quoted ids of a `$RC(…)` call whose first quote has been passed. */
 function argumentPair(
   chunk: string,
-  from: number,
+  from : number,
 ): {| readonly boundary: string, readonly content: string |} | null {
   const boundaryEnd = chunk.indexOf('"', from);
   if (boundaryEnd === -1 || !chunk.startsWith(',"', boundaryEnd + 1)) {
@@ -332,7 +332,7 @@ function argumentPair(
   }
   return {
     boundary: chunk.slice(from, boundaryEnd),
-    content: chunk.slice(contentAt, contentEnd),
+    content : chunk.slice(contentAt, contentEnd),
   };
 }
 

package/internal/native-links.js

@@ -28,18 +28,18 @@ export function nativeLinkHref(table: Table, to: string): string | null {
 export type NativeLinkSource = {|
   readonly getInitialURL: () => Promise<string | null>,
   readonly addEventListener: (
-    event: "url",
+    event   : "url",
     listener: (event: {| url: string |}) => void,
   ) => {| remove: () => void |},
 |};
 
 /** Pass React Native's Linking; rejected links stay with the OS/browser. */
 export function createNativeLinking(
-  table: Table,
+  table : Table,
   source: NativeLinkSource,
 ): {|
   getInitialURL: () => Promise<string | null>,
-  subscribe: (listener: (href: string) => void) => () => void,
+  subscribe    : (listener: (href: string) => void) => () => void,
 |} {
   let last: string | null = null;
   let deliveredAt = -Infinity;

package/internal/native-tree.js

@@ -3,13 +3,13 @@ import type { RouteModule, RouteTable } from "./routing.js";
 
 export type NativeLayout = {
   readonly segment: string,
-  readonly file: string,
-  readonly module: RouteModule<>,
+  readonly file   : string,
+  readonly module : RouteModule<>,
 };
 export type NativeNode = {
-  name: string,
-  module: ?RouteModule<>,
-  layout: boolean,
+  name    : string,
+  module  : ?RouteModule<>,
+  layout  : boolean,
   children: Array<NativeNode>,
 };
 export type NativeTree = { root: NativeNode, paths: Map<string, $ReadOnlyArray<string>> };
@@ -46,22 +46,22 @@ export function nativeTree(table: RouteTable<>, layouts: $ReadOnlyArray<NativeLa
 }
 
 export type NavigationPayload = {
-  readonly ufHref: string,
+  readonly ufHref  : string,
   readonly ufParams: { readonly [string]: string | $ReadOnlyArray<string> },
 };
 export type NavigationState = {
-  readonly key?: string,
-  readonly type?: string,
+  readonly key?  : string,
+  readonly type? : string,
   readonly index?: number,
   readonly routes: $ReadOnlyArray<{
-    readonly name: string,
+    readonly name   : string,
     readonly params?: NavigationPayload,
-    readonly state?: NavigationState,
+    readonly state? : NavigationState,
   }>,
 };
 
 export function stateForPath(
-  names: $ReadOnlyArray<string>,
+  names  : $ReadOnlyArray<string>,
   payload: NavigationPayload,
 ): NavigationState {
   const [name, ...rest] = names;

package/internal/navigation-cache.js

@@ -64,7 +64,7 @@ export function installStaleTime(seconds: number): void {
   if (import.meta.hot != null) {
     Object.defineProperty(globalThis as $FlowFixMe, "__UF_NAVIGATION_CACHE__", {
       configurable: true,
-      value: inspectNavigationCache,
+      value       : inspectNavigationCache,
     });
   }
   if (staleTimeMs === 0) {
@@ -90,18 +90,18 @@ export type NavigationCache<T> = {|
   readonly store: (key: string, value: T) => void,
   /** Drop what `key` keeps, if it is still `value`. */
   readonly forget: (key: string, value: T) => void,
-  readonly clear: () => void,
+  readonly clear : () => void,
   /** How many routes are kept, fresh or not. */
-  readonly size: () => number,
+  readonly size   : () => number,
   readonly inspect: () => $ReadOnlyArray<NavigationCacheEntry>,
 |};
 
 /** Metadata only: inspecting the cache never exposes loader or Flight data. */
 export type NavigationCacheEntry = {|
-  readonly key: string,
+  readonly key     : string,
   readonly cachedAt: number,
-  readonly staleAt: number,
-  readonly fresh: boolean,
+  readonly staleAt : number,
+  readonly fresh   : boolean,
 |};
 
 function createNavigationCache<T>(): NavigationCache<T> {
@@ -148,8 +148,8 @@ function createNavigationCache<T>(): NavigationCache<T> {
       return Array.from(entries, ([key, entry]) => ({
         key,
         cachedAt: entry.at,
-        staleAt: entry.at + staleTimeMs,
-        fresh: now - entry.at < staleTimeMs,
+        staleAt : entry.at + staleTimeMs,
+        fresh   : now - entry.at < staleTimeMs,
       }));
     },
   };
@@ -164,13 +164,13 @@ export const routeNavigations: NavigationCache<Promise<ResolvedRoute>> = createN
 /** A fresh snapshot for the development console, without reading an entry. */
 export function inspectNavigationCache(): {|
   readonly staleTime: number,
-  readonly flight: $ReadOnlyArray<NavigationCacheEntry>,
-  readonly routes: $ReadOnlyArray<NavigationCacheEntry>,
+  readonly flight   : $ReadOnlyArray<NavigationCacheEntry>,
+  readonly routes   : $ReadOnlyArray<NavigationCacheEntry>,
 |} {
   return {
     staleTime: staleTimeMs / 1000,
-    flight: flightNavigations.inspect(),
-    routes: routeNavigations.inspect(),
+    flight   : flightNavigations.inspect(),
+    routes   : routeNavigations.inspect(),
   };
 }
 

package/internal/payload-rows.js

@@ -96,8 +96,8 @@ type ElementLike = interface {
 /** One row the page is waiting for. */
 type Slot = {|
   readonly promise: Promise<mixed>,
-  readonly settle: (message: PayloadRowMessage) => void,
-  arrived: boolean,
+  readonly settle : (message: PayloadRowMessage) => void,
+  arrived         : boolean,
 |};
 
 /**

package/internal/payload.js

@@ -264,8 +264,8 @@ function setKey(target: { [string]: mixed }, key: string, value: mixed): void {
   if (key === "__proto__") {
     Object.defineProperty(target, key, {
       value,
-      writable: true,
-      enumerable: true,
+      writable    : true,
+      enumerable  : true,
       configurable: true,
     });
     return;
@@ -276,9 +276,9 @@ function setKey(target: { [string]: mixed }, key: string, value: mixed): void {
 /** One entry of an explicit walk stack, with the slot to write the result into. */
 type Frame = {|
   readonly value: mixed,
-  readonly path: string,
+  readonly path : string,
   readonly depth: number,
-  readonly emit: (encoded: mixed) => void,
+  readonly emit : (encoded: mixed) => void,
 |};
 
 /**
@@ -348,7 +348,7 @@ export function encodePayload(root: mixed, label: string): EncodedPayload {
   const stack: Array<Frame> = [
     {
       value: root,
-      path: label,
+      path : label,
       depth: 0,
       emit: (encoded) => {
         model = encoded;
@@ -388,7 +388,7 @@ export function encodePayload(root: mixed, label: string): EncodedPayload {
       for (let index = value.length - 1; index >= 0; index -= 1) {
         stack.push({
           value: value[index],
-          path: `${path}[${String(index)}]`,
+          path : `${path}[${String(index)}]`,
           depth: depth + 1,
           emit: (child) => {
             encoded[index] = child;
@@ -411,7 +411,7 @@ export function encodePayload(root: mixed, label: string): EncodedPayload {
       const key = keys[index];
       stack.push({
         value: source[key],
-        path: `${path}.${key}`,
+        path : `${path}.${key}`,
         depth: depth + 1,
         emit: (child) => {
           setKey(encoded, key, child);
@@ -468,7 +468,7 @@ export function decodePayload(root: mixed, resolve: RowResolver, label: string):
   const stack: Array<Frame> = [
     {
       value: root,
-      path: label,
+      path : label,
       depth: 0,
       emit: (value) => {
         out = value;
@@ -496,7 +496,7 @@ export function decodePayload(root: mixed, resolve: RowResolver, label: string):
       for (let index = value.length - 1; index >= 0; index -= 1) {
         stack.push({
           value: value[index],
-          path: `${path}[${String(index)}]`,
+          path : `${path}[${String(index)}]`,
           depth: depth + 1,
           emit: (child) => {
             rebuilt[index] = child;
@@ -517,7 +517,7 @@ export function decodePayload(root: mixed, resolve: RowResolver, label: string):
       const key = keys[index];
       stack.push({
         value: source[key],
-        path: `${path}.${key}`,
+        path : `${path}.${key}`,
         depth: depth + 1,
         emit: (child) => {
           setKey(rebuilt, key, child);