@uniflowed/router 0.33.0 → 0.35.0

package/native.js

@@ -35,12 +35,12 @@ export type { NativeLinkSource } from "./internal/native-links.js";
 export type NativeNavigationKind = "push" | "replace" | "prefetch";
 
 export type NativeNavigationEvent = {|
-  readonly kind: NativeNavigationKind,
-  readonly href: string,
+  readonly kind    : NativeNavigationKind,
+  readonly href    : string,
   readonly pathname: string,
-  readonly search: string,
-  readonly route: string,
-  readonly params: RouteParams,
+  readonly search  : string,
+  readonly route   : string,
+  readonly params  : RouteParams,
 |};
 
 export type NativeScreenMap = {
@@ -49,8 +49,8 @@ export type NativeScreenMap = {
 
 export type NativeScreenEntry = {|
   readonly screen: string,
-  readonly route: string,
-  readonly file: string,
+  readonly route : string,
+  readonly file  : string,
 |};
 
 export type NativeScreenManifest = {|
@@ -68,42 +68,42 @@ export type NativeScreenManifestOptions = {|
 |};
 
 export type NativeScreenPayload = {|
-  readonly screen: string,
-  readonly href: string,
+  readonly screen  : string,
+  readonly href    : string,
   readonly pathname: string,
-  readonly search: string,
-  readonly route: string,
-  readonly params: RouteParams,
+  readonly search  : string,
+  readonly route   : string,
+  readonly params  : RouteParams,
 |};
 
 export type NativeScreenNavigationState = {|
-  readonly params: RouteParams,
-  readonly href: string,
+  readonly params  : RouteParams,
+  readonly href    : string,
   readonly pathname: string,
-  readonly search: string,
-  readonly route: string,
+  readonly search  : string,
+  readonly route   : string,
 |};
 
 export type NativeNavigator = {|
-  readonly push?: (event: NativeNavigationEvent) => mixed | Promise<mixed>,
-  readonly replace?: (event: NativeNavigationEvent) => mixed | Promise<mixed>,
+  readonly push?    : (event: NativeNavigationEvent) => mixed | Promise<mixed>,
+  readonly replace? : (event: NativeNavigationEvent) => mixed | Promise<mixed>,
   readonly prefetch?: (event: NativeNavigationEvent) => mixed | Promise<mixed>,
 |};
 
 export type NativeScreenNavigator = {|
-  readonly push?: (screen: string, state: NativeScreenNavigationState) => mixed | Promise<mixed>,
+  readonly push?   : (screen: string, state: NativeScreenNavigationState) => mixed | Promise<mixed>,
   readonly replace?: (screen: string, state: NativeScreenNavigationState) => mixed | Promise<mixed>,
   readonly prefetch?: (
     screen: string,
-    state: NativeScreenNavigationState,
+    state : NativeScreenNavigationState,
   ) => mixed | Promise<mixed>,
 |};
 
 export type NativeRouter = {|
-  readonly push: (to: string) => Promise<void>,
-  readonly replace: (to: string) => Promise<void>,
+  readonly push    : (to: string) => Promise<void>,
+  readonly replace : (to: string) => Promise<void>,
   readonly prefetch: (to: string) => Promise<void>,
-  readonly resolve: (to: string, kind?: NativeNavigationKind) => NativeNavigationEvent,
+  readonly resolve : (to: string, kind?: NativeNavigationKind) => NativeNavigationEvent,
 |};
 
 export type NativeNavigationErrorCode =
@@ -131,7 +131,7 @@ export class NativeNavigationError extends Error {
 }
 
 export function createNativeRouter(
-  table: RouteTable<mixed, mixed, mixed, mixed, mixed>,
+  table    : RouteTable<mixed, mixed, mixed, mixed, mixed>,
   navigator: NativeNavigator,
 ): NativeRouter {
   const resolve = (to: string, kind?: NativeNavigationKind = "push"): NativeNavigationEvent =>
@@ -158,12 +158,12 @@ export function createNativeRouter(
 }
 
 export function createNativeScreenRouter(
-  table: RouteTable<mixed, mixed, mixed, mixed, mixed>,
-  screens: NativeScreenMap,
+  table    : RouteTable<mixed, mixed, mixed, mixed, mixed>,
+  screens  : NativeScreenMap,
   navigator: NativeScreenNavigator,
 ): NativeRouter {
   return createNativeRouter(table, {
-    push: (event) => invokeScreenNavigator(navigator, screens, event),
+    push   : (event) => invokeScreenNavigator(navigator, screens, event),
     replace: (event) => invokeScreenNavigator(navigator, screens, event),
     prefetch: (event) => {
       if (typeof navigator.prefetch !== "function") return;
@@ -173,7 +173,7 @@ export function createNativeScreenRouter(
 }
 
 export function createNativeScreenManifest(
-  table: RouteTable<mixed, mixed, mixed, mixed, mixed>,
+  table   : RouteTable<mixed, mixed, mixed, mixed, mixed>,
   options?: NativeScreenManifestOptions,
 ): NativeScreenManifest {
   const screens: { [string]: string } = {};
@@ -224,7 +224,7 @@ export function nativeScreenName(routePath: string): string {
 
 export function resolveNativeNavigation(
   table: RouteTable<mixed, mixed, mixed, mixed, mixed>,
-  to: string,
+  to   : string,
   kind?: NativeNavigationKind = "push",
 ): NativeNavigationEvent {
   const href = normalizeNativeHref(to, table);
@@ -251,13 +251,13 @@ export function resolveNativeNavigation(
     href,
     pathname,
     search,
-    route: matched.route.path,
+    route : matched.route.path,
     params: matched.params,
   };
 }
 
 export function nativeScreenPayload(
-  event: NativeNavigationEvent,
+  event  : NativeNavigationEvent,
   screens: NativeScreenMap,
 ): NativeScreenPayload {
   const screen = screens[event.route];
@@ -271,11 +271,11 @@ export function nativeScreenPayload(
   }
   return {
     screen,
-    href: event.href,
+    href    : event.href,
     pathname: event.pathname,
-    search: event.search,
-    route: event.route,
-    params: event.params,
+    search  : event.search,
+    route   : event.route,
+    params  : event.params,
   };
 }
 
@@ -283,16 +283,16 @@ export function nativeScreenNavigationState(
   payload: NativeScreenPayload,
 ): NativeScreenNavigationState {
   return {
-    params: payload.params,
-    href: payload.href,
+    params  : payload.params,
+    href    : payload.href,
     pathname: payload.pathname,
-    search: payload.search,
-    route: payload.route,
+    search  : payload.search,
+    route   : payload.route,
   };
 }
 
 function normalizeNativeHref(
-  to: string,
+  to   : string,
   table: RouteTable<mixed, mixed, mixed, mixed, mixed>,
 ): string {
   if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(to) || to.startsWith("//")) {
@@ -322,7 +322,7 @@ function normalizeNativeHref(
 }
 
 function screenNameFor(
-  route: RouteRecord<mixed, mixed, mixed, mixed, mixed>,
+  route   : RouteRecord<mixed, mixed, mixed, mixed, mixed>,
   options?: NativeScreenManifestOptions,
 ): string {
   const screen =
@@ -354,7 +354,7 @@ function titlePart(segment: string): string {
 
 async function invokeNavigator(
   navigator: NativeNavigator,
-  event: NativeNavigationEvent,
+  event    : NativeNavigationEvent,
 ): Promise<void> {
   if (event.kind === "push") {
     if (typeof navigator.push !== "function") {
@@ -382,8 +382,8 @@ function missingMethod(event: NativeNavigationEvent): NativeNavigationError {
 
 async function invokeScreenNavigator(
   navigator: NativeScreenNavigator,
-  screens: NativeScreenMap,
-  event: NativeNavigationEvent,
+  screens  : NativeScreenMap,
+  event    : NativeNavigationEvent,
 ): Promise<void> {
   const payload = nativeScreenPayload(event, screens);
   const state = nativeScreenNavigationState(payload);
@@ -408,7 +408,7 @@ async function invokeScreenNavigator(
 }
 
 async function loadNativeRoute(
-  table: RouteTable<mixed, mixed, mixed, mixed, mixed>,
+  table   : RouteTable<mixed, mixed, mixed, mixed, mixed>,
   pathname: string,
 ): Promise<void> {
   const matched = matchRoute(table.routes, pathname);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/router",
-  "version": "0.33.0",
+  "version": "0.35.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.33.0",
-    "@uniflowed/server": "0.33.0",
-    "@uniflowed/validator": "0.33.0"
+    "@uniflowed/hooks": "0.35.0",
+    "@uniflowed/server": "0.35.0",
+    "@uniflowed/validator": "0.35.0"
   }
 }

package/rsc-client.js

@@ -75,12 +75,12 @@ export { acceptHotRouteModules, refreshForHotUpdate } from "./internal/runtime.j
  * version it found; see `./internal/react-version.js`.
  */
 export async function hydrateFlight(options: {|
-  readonly App: React.ComponentType<AppProps>,
-  readonly strictMode?: boolean,
-  readonly navigation?: Navigation,
-  readonly basePath?: string,
+  readonly App           : React.ComponentType<AppProps>,
+  readonly strictMode?   : boolean,
+  readonly navigation?   : Navigation,
+  readonly basePath?     : string,
   readonly trailingSlash?: TrailingSlash,
-  readonly staleTime?: number,
+  readonly staleTime?    : number,
 |}): Promise<void> {
   requireServerComponentsReact("@uniflowed/router/rsc/client");
   installNavigation(options.navigation ?? "client");

package/rsc-ssr.js

@@ -113,13 +113,13 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
    */
   async function documentOf(
     stream: ReadableStream<Uint8Array>,
-    url: string,
+    url   : string,
     assets: RenderAssets,
     settings: {|
-      readonly onError: (error: mixed) => void,
+      readonly onError       : (error: mixed) => void,
       readonly transformHead?: (html: string) => Promise<string>,
-      readonly onStream?: (record: StreamRecord) => void,
-      readonly formState?: FormState,
+      readonly onStream?     : (record: StreamRecord) => void,
+      readonly formState?    : FormState,
     |},
   ): Promise<DocumentBody> {
     const [forHtml, forBrowser] = stream.tee();
@@ -130,11 +130,11 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
     const nonce = currentNonce();
     try {
       return await renderDocument(<App url={url} flight={readPayload(forHtml)} />, {
-        shell: shellFor(assets, nonce, settings.formState),
-        onError: settings.onError,
+        shell        : shellFor(assets, nonce, settings.formState),
+        onError      : settings.onError,
         transformHead: settings.transformHead,
-        onStream: settings.onStream,
-        payload: forBrowser,
+        onStream     : settings.onStream,
+        payload      : forBrowser,
         nonce,
         formState: settings.formState,
       });
@@ -145,8 +145,8 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
   }
 
   async function render(
-    url: string,
-    assets: RenderAssets,
+    url      : string,
+    assets   : RenderAssets,
     settings?: RenderOptions,
   ): Promise<RenderResult> {
     const report = settings?.onError ?? ((_error: mixed) => {});
@@ -249,8 +249,8 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
   }
 
   async function prerender(
-    url: string,
-    assets: RenderAssets,
+    url      : string,
+    assets   : RenderAssets,
     settings?: RenderOptions,
   ): Promise<PrerenderResult> {
     const report = settings?.onError ?? ((_error: mixed) => {});
@@ -319,7 +319,7 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
         return redirectResult(redirectDocument(cause));
       }
       const recovered = await renderFlight(url, {
-        defer: false,
+        defer  : false,
         failure: { error: cause },
         onError: onServerError,
       });
@@ -363,10 +363,10 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
    */
   async function partialDocumentOf(
     payload: Uint8Array,
-    url: string,
-    assets: RenderAssets,
+    url    : string,
+    assets : RenderAssets,
     onError: (error: mixed) => void,
-    reads: $ReadOnlyArray<string>,
+    reads  : $ReadOnlyArray<string>,
   ): Promise<PrerenderedShell | null> {
     try {
       await staticDocumentOf(payload, url, assets, onError);
@@ -405,9 +405,9 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
    * with the shell is the same markup.
    */
   async function resume(
-    url: string,
-    assets: RenderAssets,
-    shell: PrerenderedShell,
+    url      : string,
+    assets   : RenderAssets,
+    shell    : PrerenderedShell,
     settings?: RenderOptions,
   ): Promise<RenderResult> {
     const report = settings?.onError ?? ((_error: mixed) => {});
@@ -435,8 +435,8 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
           report(error);
         }
       },
-      payload: forBrowser,
-      nonce: currentNonce(),
+      payload : forBrowser,
+      nonce   : currentNonce(),
       onStream: send == null ? undefined : streamReporter(url, send),
     });
     return { status: 200, pipe: body.pipe, stream: body.stream, text: body.text };
@@ -445,8 +445,8 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
   /** A finished document for a finished payload, with the payload written into it. */
   function staticDocumentOf(
     payload: Uint8Array,
-    url: string,
-    assets: RenderAssets,
+    url    : string,
+    assets : RenderAssets,
     onError: (error: mixed) => void,
   ): Promise<string> {
     return prerenderDocument(<App url={url} flight={readPayload(streamOf(payload))} />, {
@@ -459,15 +459,15 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
   async function flight(
     url: string,
     settings?: {|
-      readonly onError?: (error: mixed) => void,
+      readonly onError?        : (error: mixed) => void,
       readonly interceptedFrom?: string,
-      readonly notFound?: boolean,
+      readonly notFound?       : boolean,
     |},
   ): Promise<FlightResponse> {
     const rendered = await renderFlight(url, {
-      onError: settings?.onError,
+      onError        : settings?.onError,
       interceptedFrom: settings?.interceptedFrom,
-      notFound: settings?.notFound,
+      notFound       : settings?.notFound,
     });
     if (rendered.kind === "redirect") {
       const { location } = rendered;
@@ -477,16 +477,16 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
       // loads the URL as a document instead.
       const onThisOrigin = location.startsWith("/") && !location.startsWith("//");
       return {
-        status: rendered.status,
+        status : rendered.status,
         headers: { location: onThisOrigin ? flightUrl(addressOf(location)) : location },
-        stream: null,
+        stream : null,
       };
     }
     return {
       status: rendered.status,
       headers: {
         "content-type": FLIGHT_CONTENT_TYPE,
-        vary: `${INTERCEPTED_FROM_HEADER}, ${NOT_FOUND_HEADER}`,
+        vary          : `${INTERCEPTED_FROM_HEADER}, ${NOT_FOUND_HEADER}`,
         // The payload carries the page's strings as they were rendered — a
         // comment body with `<img onerror>` in it included — and its URL is one
         // anybody can open as a document. `text/x-component` is not a type a
@@ -495,7 +495,7 @@ export function createDocumentRenderer(options: DocumentRendererOptions): Render
         "x-content-type-options": "nosniff",
       },
       stream: rendered.stream,
-      error: rendered.failure,
+      error : rendered.failure,
     };
   }
 

package/rsc.js

@@ -172,7 +172,7 @@ export type FlightOptions = {|
 export type FlightRender =
   | {| readonly kind: "redirect", readonly status: 307 | 308, readonly location: string |}
   | {|
-      readonly kind: "route",
+      readonly kind  : "route",
       readonly status: 200 | 400 | 401 | 403 | 404 | 500,
       /** The payload, as React writes it. Read exactly once. */
       readonly stream: ReadableStream<Uint8Array>,
@@ -207,9 +207,9 @@ const CLIENT_REFERENCE: symbol = Symbol.for("react.client.reference");
  * — and it is `virtual:uf/routes` as this graph generates it.
  */
 export function createFlightRenderer(options: {|
-  readonly routes: RouteTable["routes"],
+  readonly routes  : RouteTable["routes"],
   readonly notFound: RouteTable["notFound"],
-  readonly errors: RouteTable["errors"],
+  readonly errors  : RouteTable["errors"],
   /**
    * The build's deployment id, written into every payload's root so that a
    * page on another build can tell — including from a payload that was
@@ -222,9 +222,9 @@ export function createFlightRenderer(options: {|
   // and React's Flight renderer would only say so from inside a render.
   requireServerComponentsReact("@uniflowed/router/rsc");
   const table: RouteTable = {
-    routes: options.routes,
+    routes  : options.routes,
     notFound: options.notFound,
-    errors: options.errors,
+    errors  : options.errors,
   };
 
   return async function renderFlight(url: string, settings?: FlightOptions): Promise<FlightRender> {
@@ -285,7 +285,7 @@ export function createFlightRenderer(options: {|
         // Handed over as it is, so that the digest it returns reaches the row.
         // Our callback preserves React's console fallback when none was given.
         onError: report,
-        signal: settings?.signal,
+        signal : settings?.signal,
       }),
     );
     return { kind: "route", status: route.status, stream, failure };
@@ -294,8 +294,8 @@ export function createFlightRenderer(options: {|
 
 async function resolveFlightInterception(
   table: RouteTable,
-  url: string,
-  from: ?string,
+  url  : string,
+  from : ?string,
   defer: boolean,
 ): Promise<?ResolvedRoute> {
   const baseUrl = usableInterceptionBase(from);
@@ -305,7 +305,7 @@ async function resolveFlightInterception(
   try {
     const base = await resolveMatch(table, baseUrl, {
       defer,
-      onMatch: noteRoute,
+      onMatch  : noteRoute,
       runLoader: traceLoader,
     });
     return await resolveInterception(table, base, url);
@@ -378,10 +378,10 @@ component RoutePage(page: PageModule, params: RouteParams, searchParams: mixed,
  * browser's `AwaitedPage` already uses for the same wait.
  */
 component DeferredPage(
-  page: PageModule,
-  params: RouteParams,
+  page        : PageModule,
+  params      : RouteParams,
   searchParams: mixed,
-  loader: Promise<mixed>,
+  loader      : Promise<mixed>,
 ) {
   return <RoutePage page={page} params={params} searchParams={searchParams} data={use(loader)} />;
 }
@@ -401,9 +401,9 @@ function forTheBrowser(resolved: ResolvedRoute, file: string | null): ResolvedRo
     ...resolved,
     // Only an `Error` has React's production rule of carrying no message; see
     // `crossableRouteError`.
-    error: crossableRouteError(resolved.error),
+    error        : crossableRouteError(resolved.error),
     errorBoundary: { above: boundary.above, module: clientErrorModule(boundary.module, file) },
-    slots: resolved.slots.map(slotForTheBrowser),
+    slots        : resolved.slots.map(slotForTheBrowser),
   };
 }
 
@@ -455,8 +455,8 @@ function renderFailure(resolved: ResolvedRoute): mixed {
   }
   return match (resolved.error) {
     {kind: "thrown", error: const error} => error,
-    {kind: "badRequest", ...} => undefined,
-    {kind: "unauthorized"} => undefined,
-    {kind: "forbidden"} => undefined,
+    {kind: "badRequest", ...}            => undefined,
+    {kind: "unauthorized"}               => undefined,
+    {kind: "forbidden"}                  => undefined,
   };
 }

package/server-components.js

@@ -111,12 +111,12 @@ export { resolveFailure, resolveMatch } from "./internal/resolve.js";
 export hook useRoute(): RouteInfo {
   const route = serverRoute("useRoute");
   return {
-    path: route.path,
-    pathname: route.pathname,
-    params: route.params,
+    path        : route.path,
+    pathname    : route.pathname,
+    params      : route.params,
     searchParams: route.searchParams,
-    data: route.deferred == null ? route.data : use(route.deferred),
-    pending: false,
+    data        : route.deferred == null ? route.data : use(route.deferred),
+    pending     : false,
   };
 }