@uniflowed/router 0.34.0 → 0.35.0

package/action.js

@@ -294,7 +294,7 @@ export function registerServerAction<T>(fn: T, id: string): T {
  */
 export function callServerReference(
   reference: string,
-  args: $ReadOnlyArray<mixed>,
+  args     : $ReadOnlyArray<mixed>,
 ): Promise<ActionValue | void> {
   const hash = reference.indexOf("#");
   const id = hash === -1 ? reference : reference.slice(0, hash);
@@ -311,7 +311,7 @@ function callServerActionFor(id: string, name: string): ServerActionFunction {
 
 /** Call action `id`, named `name` in an error, with `args`. */
 async function sendServerAction(
-  id: string,
+  id  : string,
   name: string,
   args: $ReadOnlyArray<mixed>,
 ): Promise<ActionValue | void> {
@@ -392,10 +392,10 @@ async function sendServerAction(
  * the router's runtime is client-rendering code that has no place there.
  */
 async function followOutcome(
-  name: string,
-  outcome: string,
+  name    : string,
+  outcome : string,
   response: Response,
-  from: string,
+  from    : string,
 ): Promise<ActionValue | void> {
   switch (outcome) {
     case "redirect": {

package/client.js

@@ -152,20 +152,20 @@ export type ApplicationRoot = { readonly unmount: () => void, ... };
  * that stops a server action from navigating a router that is gone.
  */
 export async function hydrate(options: {|
-  readonly App: React.ComponentType<AppProps>,
-  readonly routes: RouteTable["routes"],
-  readonly notFound: RouteTable["notFound"],
-  readonly errors: RouteTable["errors"],
-  readonly strictMode?: boolean,
-  readonly navigation?: Navigation,
-  readonly basePath?: string,
+  readonly App           : React.ComponentType<AppProps>,
+  readonly routes        : RouteTable["routes"],
+  readonly notFound      : RouteTable["notFound"],
+  readonly errors        : RouteTable["errors"],
+  readonly strictMode?   : boolean,
+  readonly navigation?   : Navigation,
+  readonly basePath?     : string,
   readonly trailingSlash?: TrailingSlash,
-  readonly staleTime?: number,
+  readonly staleTime?    : number,
 |}): Promise<ApplicationRoot | null> {
   const table: RouteTable = {
-    routes: options.routes,
+    routes  : options.routes,
     notFound: options.notFound,
-    errors: options.errors,
+    errors  : options.errors,
   };
   installRoutes(table);
   // Beside the table, and before anything renders. `"client"` when the entry
@@ -294,20 +294,20 @@ export async function hydrate(options: {|
  * was mounted — for the reason `hydrate` gives.
  */
 export async function render(options: {|
-  readonly App: React.ComponentType<AppProps>,
-  readonly routes: RouteTable["routes"],
-  readonly notFound: RouteTable["notFound"],
-  readonly errors: RouteTable["errors"],
-  readonly strictMode?: boolean,
-  readonly navigation?: Navigation,
-  readonly basePath?: string,
+  readonly App           : React.ComponentType<AppProps>,
+  readonly routes        : RouteTable["routes"],
+  readonly notFound      : RouteTable["notFound"],
+  readonly errors        : RouteTable["errors"],
+  readonly strictMode?   : boolean,
+  readonly navigation?   : Navigation,
+  readonly basePath?     : string,
   readonly trailingSlash?: TrailingSlash,
-  readonly staleTime?: number,
+  readonly staleTime?    : number,
 |}): Promise<ApplicationRoot | null> {
   const table: RouteTable = {
-    routes: options.routes,
+    routes  : options.routes,
     notFound: options.notFound,
-    errors: options.errors,
+    errors  : options.errors,
   };
   installRoutes(table);
   installNavigation(options.navigation ?? "client");

package/handler.js

@@ -91,10 +91,10 @@ export type HandlerModule = { readonly [method: string]: mixed };
 
 /** One entry of the generated handler table. */
 export type HandlerRecord = {|
-  readonly path: string,
+  readonly path  : string,
   readonly params: $ReadOnlyArray<{| readonly name: string, readonly catchAll: boolean |}>,
-  readonly file: string,
-  readonly load: () => Promise<HandlerModule>,
+  readonly file  : string,
+  readonly load  : () => Promise<HandlerModule>,
 |};
 
 /**
@@ -179,9 +179,9 @@ export function createDispatcher(options: {| readonly handlers: $ReadOnlyArray<H
     // body went out anyway.
     if (method === "HEAD" && typeof module.HEAD !== "function") {
       return new Response(null, {
-        status: response.status,
+        status    : response.status,
         statusText: response.statusText,
-        headers: response.headers,
+        headers   : response.headers,
       });
     }
     return response;
@@ -225,7 +225,7 @@ function methodNotAllowed(module: HandlerModule): Response {
   // Filtered through `METHODS` rather than listed in insertion order, so the
   // header reads in the conventional order however the module was written.
   return new Response(null, {
-    status: 405,
+    status : 405,
     headers: { allow: HANDLER_METHODS.filter((method) => own.has(method)).join(", ") },
   });
 }

package/http-client.js

@@ -9,28 +9,28 @@ import {
 } from "./internal/action-wire.js";
 
 export type RouteClientOptions = {|
-  readonly origin: string,
-  readonly getToken?: () => Promise<string>,
-  readonly fetch?: (url: string, options: RequestOptions) => Promise<Response>,
+  readonly origin                   : string,
+  readonly getToken?                : () => Promise<string>,
+  readonly fetch?                   : (url: string, options: RequestOptions) => Promise<Response>,
   readonly allowInsecureDevelopment?: boolean,
 |};
 
 export type RouteRequest = {|
-  readonly method?: string,
+  readonly method? : string,
   readonly headers?: { readonly [string]: string },
-  readonly body?: string,
-  readonly signal?: AbortSignal,
+  readonly body?   : string,
+  readonly signal? : AbortSignal,
 |};
 
 type RequestOptions = {|
   ...RouteRequest,
   readonly credentials: "omit",
-  readonly redirect: "error",
+  readonly redirect   : "error",
 |};
 
 /** Fetch transport shared by generated typed route clients and native actions. */
 export function createRouteClient(options: RouteClientOptions): (
-  path: string,
+  path    : string,
   request?: RouteRequest,
 ) => Promise<Response> {
   const origin = new URL(options.origin);
@@ -93,9 +93,9 @@ export function createNativeActionClient(options: {|
     const response = await send(path, {
       method: "POST",
       headers: {
-        [ACTION_HEADER]: id,
+        [ACTION_HEADER]   : id,
         "uf-native-action": "bearer-v1",
-        "content-type": ACTION_CONTENT_TYPE,
+        "content-type"    : ACTION_CONTENT_TYPE,
       },
       body: encodeActionArguments(args),
     });

package/index.js

@@ -118,9 +118,9 @@ export type PageProps<
   TData = void,
   TSearchParams = { readonly [string]: string },
 > = {|
-  readonly params: TParams,
+  readonly params      : TParams,
   readonly searchParams: TSearchParams,
-  readonly data: TData,
+  readonly data        : TData,
 |};
 
 /**
@@ -153,6 +153,6 @@ export type ErrorProps = {|
 export type LayoutProps<
   TParams extends { readonly [string]: string | $ReadOnlyArray<string> } = {},
 > = {|
-  readonly params: TParams,
+  readonly params  : TParams,
   readonly children: React.Node,
 |};

package/instrumentation.js

@@ -1,16 +1,16 @@
 // @flow
 
 export type NavigationTiming = {|
-  readonly kind: "document" | "router",
+  readonly kind    : "document" | "router",
   readonly pathname: string,
   readonly duration: number,
-  readonly status: "complete" | "error",
+  readonly status  : "complete" | "error",
 |};
 
 export type ClientInstrumentation = {|
   readonly register?: () => void | Promise<void>,
   readonly onError?: (
-    error: mixed,
+    error  : mixed,
     context: {| readonly source: "error" | "unhandledrejection" | "navigation" | "startup" |},
   ) => void | Promise<void>,
   readonly onNavigation?: (timing: NavigationTiming) => void | Promise<void>,
@@ -43,10 +43,10 @@ export async function installClientInstrumentation(hooks: ClientInstrumentation)
     performanceObserver = new PerformanceObserver((list) => {
       for (const entry of list.getEntries()) {
         const timing: NavigationTiming = {
-          kind: "document",
+          kind    : "document",
           pathname: new URL(entry.name).pathname,
           duration: entry.duration,
-          status: "complete",
+          status  : "complete",
         };
         notify(() => hooks.onNavigation?.(timing));
       }

package/internal/action-endpoint.js

@@ -204,7 +204,7 @@ export function createActionDispatcher(options: {|
   const table = options.actions;
 
   return async function callAction(
-    request: Request,
+    request  : Request,
     settings?: ActionDispatchOptions,
   ): Promise<Response | null> {
     // The host's half of the contract, checked rather than assumed, exactly as
@@ -331,8 +331,8 @@ export function createActionDispatcher(options: {|
  * reason.
  */
 async function nativeFormPost(
-  table: $ReadOnlyArray<ActionRecord>,
-  request: Request,
+  table   : $ReadOnlyArray<ActionRecord>,
+  request : Request,
   postback: ?(formState: FormState) => Promise<Response>,
 ): Promise<Response | null> {
   if (request.method.toUpperCase() !== "POST") {
@@ -404,7 +404,7 @@ async function nativeFormPost(
       const status = routingStatus(error);
       if (status != null) {
         return new Response(`${status.text}\n`, {
-          status: status.code,
+          status : status.code,
           headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" },
         });
       }
@@ -439,7 +439,7 @@ async function nativeFormPost(
  * forms that could drift from the first.
  */
 function formArguments(post: FormPost): {|
-  readonly args: Array<ActionArgument>,
+  readonly args : Array<ActionArgument>,
   readonly bound: number,
 |} {
   let bound: Array<ActionArgument> = [];
@@ -512,7 +512,7 @@ function routingOutcome(error: mixed): Response | null {
   if (error instanceof RedirectError) {
     const headers: { [string]: string } = {
       "cache-control": "no-store",
-      location: addressOf(error.to),
+      location       : addressOf(error.to),
     };
     headers[ACTION_OUTCOME_HEADER] = "redirect";
     return new Response(null, { status: 204, headers });
@@ -554,7 +554,7 @@ function withOneLeadingSlash(path: string): string {
 /** A `303 See Other`, which a browser follows with a `GET`. */
 function seeOther(location: string): Response {
   return new Response(null, {
-    status: 303,
+    status : 303,
     headers: { location, "cache-control": "no-store" },
   });
 }

package/internal/action-wire.js

@@ -303,8 +303,8 @@ export function valueBudget(): ValueBudget {
  * is on the call. Without one, the value has a budget of its own.
  */
 export function checkActionValue(
-  root: mixed,
-  label: string,
+  root   : mixed,
+  label  : string,
   budget?: ValueBudget = valueBudget(),
 ): void {
   const stack: Array<Pending> = [{ value: root, path: label, depth: 0 }];
@@ -545,7 +545,7 @@ export function decodeActionArguments(text: string): Array<ActionArgument> {
  */
 function decodeForm(
   candidate: mixed,
-  args: $ReadOnlyArray<ActionArgument>,
+  args     : $ReadOnlyArray<ActionArgument>,
 ): {| readonly index: number, readonly form: FormData |} {
   if (typeof FormData === "undefined") {
     throw new ActionValueError("the body", "carries a form, and this runtime has no FormData");

package/internal/base-path.js

@@ -29,7 +29,7 @@ export type TrailingSlash = "never" | "always" | "ignore";
 
 /** What an entry installs. */
 export type RoutingSettings = {|
-  readonly basePath?: string,
+  readonly basePath?     : string,
   readonly trailingSlash?: TrailingSlash,
 |};
 
@@ -47,8 +47,8 @@ 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,
+    value       : base,
+    writable    : true,
     configurable: true,
   });
 }

package/internal/boundaries.js

@@ -236,7 +236,7 @@ export type BoundaryFinding = {|
  */
 export function boundaryFindings(
   boundaries: Map<string, RouteBoundary>,
-  document: Document,
+  document  : Document,
 ): $ReadOnlyArray<BoundaryFinding> {
   const findings: Array<BoundaryFinding> = [];
   for (const boundary of boundaries.values()) {
@@ -259,8 +259,8 @@ export function boundaryFindings(
     }
     findings.push({
       boundary,
-      owns: owned.slice(0, NAMED_LIMIT),
-      more: Math.max(0, owned.length - NAMED_LIMIT),
+      owns    : owned.slice(0, NAMED_LIMIT),
+      more    : Math.max(0, owned.length - NAMED_LIMIT),
       rendered: true,
     });
   }
@@ -303,13 +303,13 @@ export function describeElement(element: Element): string {
  * on it without opening this file.
  */
 export function formatBoundaries(
-  path: string,
+  path    : string,
   findings: $ReadOnlyArray<BoundaryFinding>,
 ): {| readonly message: string, readonly detail: $ReadOnlyArray<string> |} {
   const count = findings.length;
   return {
     message: `${count} ${count === 1 ? "boundary renders" : "boundaries render"} ${path}`,
-    detail: findings.map(describeFinding),
+    detail : findings.map(describeFinding),
   };
 }
 
@@ -373,9 +373,9 @@ function signature(boundaries: Map<string, RouteBoundary>): string {
  * answer and the automatic one are the same sentence about the same page.
  */
 export function reportBoundaries(
-  path: string,
+  path      : string,
   boundaries: Map<string, RouteBoundary>,
-  document: Document,
+  document  : Document,
 ): $ReadOnlyArray<BoundaryFinding> {
   const findings = boundaryFindings(boundaries, document);
   const { message, detail } = formatBoundaries(path, findings);
@@ -463,7 +463,7 @@ function installOnDemand(): void {
       }
       return reportBoundaries(live.path, live.boundaries, document);
     },
-    writable: true,
+    writable    : true,
     configurable: true,
   });
 }

package/internal/boundary-data.js

@@ -40,17 +40,17 @@ export const ROOT_ERROR_ID: string = "error:root";
  * is how many layouts are outside the boundary.
  */
 export type RouteBoundary = {|
-  readonly id: string,
-  readonly kind: BoundaryKind,
-  readonly above: number,
+  readonly id    : string,
+  readonly kind  : BoundaryKind,
+  readonly above : number,
   readonly source: ?string,
 |};
 
 /** The part of a resolved route the boundary map reads. */
 type BoundedRoute = {
   readonly errorBoundary: { readonly above: number, ... },
-  readonly loading: $ReadOnlyArray<{ readonly above: number, ... }>,
-  readonly error: mixed,
+  readonly loading      : $ReadOnlyArray<{ readonly above: number, ... }>,
+  readonly error        : mixed,
   ...
 };
 
@@ -62,21 +62,21 @@ type BoundedRoute = {
  * summaries walk the values.
  */
 export function routeBoundaries(
-  resolved: BoundedRoute,
+  resolved   : BoundedRoute,
   errorSource: ?string,
 ): Map<string, RouteBoundary> {
   const found: Map<string, RouteBoundary> = new Map();
   found.set(ROOT_ERROR_ID, {
-    id: ROOT_ERROR_ID,
-    kind: "error",
-    above: 0,
+    id    : ROOT_ERROR_ID,
+    kind  : "error",
+    above : 0,
     source: SYNTHESISED_SOURCE,
   });
   if (resolved.error == null) {
     found.set(ROUTE_ERROR_ID, {
-      id: ROUTE_ERROR_ID,
-      kind: "error",
-      above: resolved.errorBoundary.above,
+      id    : ROUTE_ERROR_ID,
+      kind  : "error",
+      above : resolved.errorBoundary.above,
       source: errorSource,
     });
   }

package/internal/compose.js

@@ -315,8 +315,8 @@ export function loadingComponent(module: LoadingModule): React.ComponentType<{||
 export function insideTemplates(
   element: React.Node,
   resolved: {
-    readonly pathname: string,
-    readonly params: RouteParams,
+    readonly pathname : string,
+    readonly params   : RouteParams,
     readonly templates: $ReadOnlyArray<ResolvedTemplate>,
     ...
   },
@@ -429,8 +429,8 @@ component SlotView(slot: ResolvedSlot, pathname: string, searchParams: SearchPar
   // uf-lint-disable-next-line react-compiler/static-components
   let element: React.Node = <Page params={slot.params} searchParams={query} data={undefined} />;
   const templateContext = {
-    pathname: at,
-    params: slot.params,
+    pathname : at,
+    params   : slot.params,
     templates: slot.templates,
   };
   for (let depth = slot.layouts.length; depth >= 0; depth -= 1) {

package/internal/devtools.js

@@ -74,7 +74,7 @@ type HookWindow = {
  */
 export function devtoolsProblem(win: HookWindow): {|
   readonly message: string,
-  readonly detail: $ReadOnlyArray<string>,
+  readonly detail : $ReadOnlyArray<string>,
 |} | null {
   const hook = win[DEVTOOLS_HOOK];
   if (hook == null || typeof hook !== "object") {

package/internal/diagnostics.js

@@ -92,18 +92,18 @@ export type DiagnosticSeverity = "error" | "warn" | "info";
  */
 export type BrowserDiagnostic = {
   readonly severity: DiagnosticSeverity,
-  readonly message: string,
-  readonly detail?: $ReadOnlyArray<string>,
-  readonly url?: string,
-  readonly file?: string,
-  readonly line?: number,
-  readonly column?: number,
+  readonly message : string,
+  readonly detail? : $ReadOnlyArray<string>,
+  readonly url?    : string,
+  readonly file?   : string,
+  readonly line?   : number,
+  readonly column? : number,
 };
 
 /** The part of the browser this module needs. */
 type ReportingWindow = {
   readonly location?: { readonly href?: string, ... },
-  readonly fetch?: (input: string, init: { ... }) => Promise<mixed>,
+  readonly fetch?   : (input: string, init: { ... }) => Promise<mixed>,
   ...
 };
 
@@ -151,7 +151,7 @@ export function reportDiagnostic(diagnostic: BrowserDiagnostic, endpoint?: strin
     method: "POST",
     body,
     keepalive: true,
-    headers: { "content-type": "application/json" },
+    headers  : { "content-type": "application/json" },
   }).then(noop, noop);
 }
 

package/internal/error-view.js

@@ -34,9 +34,9 @@ component DefaultRouteError(error: RouteError, reset: () => void) {
   const title = errorTitle(error);
   const detail = match (error) {
     {kind: "badRequest", ...} => "This page cannot answer the query in its address.",
-    {kind: "unauthorized"} => "This page needs you to be signed in.",
-    {kind: "forbidden"} => "You do not have access to this page.",
-    {kind: "thrown", ...} => "This page could not be rendered.",
+    {kind: "unauthorized"}    => "This page needs you to be signed in.",
+    {kind: "forbidden"}       => "You do not have access to this page.",
+    {kind: "thrown", ...}     => "This page could not be rendered.",
   };
   return (
     <main>
@@ -140,7 +140,7 @@ export component ErrorRoutePage(module: ?ErrorModule, error: RouteError) {
 }
 
 type RouteErrorBoundaryProps = {|
-  readonly module: ?ErrorModule,
+  readonly module  : ?ErrorModule,
   readonly resetKey: string,
   readonly children: React.Node,
 |};
@@ -209,8 +209,8 @@ export class RouteErrorBoundary extends React.Component<
     }
     const recover = () => {
       this.setState((state) => ({
-        error: null,
-        notFound: false,
+        error     : null,
+        notFound  : false,
         generation: state.generation + 1,
       }));
     };

package/internal/flight-browser.js

@@ -134,8 +134,8 @@ export function installBrowserModules(): void {
   // `parcelRequire` is exactly the global nothing declares. `Object`'s throws
   // where this answers `false`, so the throw is kept.
   const defined = Reflect.defineProperty(globalThis, "parcelRequire", {
-    value: parcelRequire,
-    writable: true,
+    value       : parcelRequire,
+    writable    : true,
     configurable: true,
   });
   if (!defined) {
@@ -170,7 +170,7 @@ type ElementLike = interface {
  */
 export function documentPayload(
   document: DocumentLike,
-  observe: ?(callback: () => void) => (() => void) | null,
+  observe : ?(callback: () => void) => (() => void) | null,
 ): ReadableStream<Uint8Array> {
   const seen: WeakSet<ElementLike> = new WeakSet();
   let stop: (() => void) | null = null;
@@ -219,7 +219,7 @@ export function documentPayload(
 /** Read the payload a document carries into its root value. */
 export function readDocumentPayload(
   document: DocumentLike,
-  observe: ?(callback: () => void) => (() => void) | null,
+  observe : ?(callback: () => void) => (() => void) | null,
 ): Promise<FlightRoot> {
   requireServerComponentsReact(ENTRY);
   return createFromReadableStream(documentPayload(document, observe));
@@ -241,7 +241,7 @@ export function readDocumentPayload(
  * refusal — is a document, whatever its status.
  */
 export async function fetchFlight(
-  url: string,
+  url     : string,
   options?: FlightFetchOptions,
 ): Promise<FetchedFlight> {
   // Outside the `try` below, which answers every failure to fetch with a
@@ -294,7 +294,7 @@ export async function fetchFlight(
   }
   return {
     kind: "flight",
-    url: `${document}${landed.search}`,
+    url : `${document}${landed.search}`,
     root: createFromFetch(Promise.resolve(payload)),
   };
 }

package/internal/flight-rows.js

@@ -41,9 +41,9 @@ const ERROR_TAG = "E".charCodeAt(0);
 /** One row's place in the payload. */
 type Row = {|
   readonly start: number,
-  readonly end: number,
-  readonly tag: number,
-  readonly body: number,
+  readonly end  : number,
+  readonly tag  : number,
+  readonly body : number,
 |};
 
 /**
@@ -96,7 +96,7 @@ function rowsOf(bytes: Uint8Array): Array<Row> {
  */
 export function withoutErrorRows(
   payload: Uint8Array,
-  left: (digest: string) => boolean,
+  left   : (digest: string) => boolean,
 ): {| readonly payload: Uint8Array, readonly removed: number |} {
   const decoder = new TextDecoder();
   const kept: Array<Uint8Array> = [];

package/internal/flight-ssr.js

@@ -69,8 +69,8 @@ export function installServerModules(load: ClientModuleLoader): void {
   // `parcelRequire` is exactly the global nothing declares. `Object`'s throws
   // where this answers `false`, so the throw is kept.
   const defined = Reflect.defineProperty(globalThis, "parcelRequire", {
-    value: parcelRequire,
-    writable: true,
+    value       : parcelRequire,
+    writable    : true,
     configurable: true,
   });
   if (!defined) {
@@ -88,7 +88,7 @@ export function installServerModules(load: ClientModuleLoader): void {
  * "Connection closed", so the HTML renderer leaves each as a hole.
  */
 export function readPayload(
-  stream: ReadableStream<Uint8Array>,
+  stream  : ReadableStream<Uint8Array>,
   options?: {| readonly partial?: boolean |},
 ): Promise<FlightRoot> {
   requireServerComponentsReact(ENTRY);