@uniflowed/router 0.34.0 → 0.36.0

package/internal/runtime.js

@@ -273,7 +273,7 @@ type ViewTransition = { readonly finished: Promise<mixed>, ... };
  */
 interface ViewTransitionDocument {
   readonly startViewTransition?: (update: () => mixed) => ViewTransition;
-  readonly documentElement: HTMLElement | null;
+  readonly documentElement     : HTMLElement | null;
 }
 
 /**
@@ -347,7 +347,7 @@ function withViewTransition(name: ?string, update: () => void): void {
 /** How a navigation is performed. */
 export type NavigateOptions = {|
   readonly replace?: boolean,
-  readonly scroll?: boolean,
+  readonly scroll? : boolean,
   /**
    * Whether this navigation may animate. Defaults to `true`, which is what
    * every navigation does.
@@ -364,12 +364,12 @@ export type NavigateOptions = {|
 
 /** What `useRouter()` returns. */
 export type Router = {|
-  readonly push: (to: string, options?: NavigateOptions) => Promise<void>,
-  readonly replace: (to: string) => Promise<void>,
+  readonly push    : (to: string, options?: NavigateOptions) => Promise<void>,
+  readonly replace : (to: string) => Promise<void>,
   readonly prefetch: (to: string) => Promise<void>,
-  readonly refresh: () => Promise<void>,
-  readonly back: () => void,
-  readonly forward: () => void,
+  readonly refresh : () => Promise<void>,
+  readonly back    : () => void,
+  readonly forward : () => void,
 |};
 
 /**
@@ -570,12 +570,12 @@ export async function followActionRedirect(location: string, from: string): Prom
 
 /** What `useRoute()` returns. */
 export type RouteInfo = {|
-  readonly path: string,
-  readonly pathname: string,
-  readonly params: RouteParams,
+  readonly path        : string,
+  readonly pathname    : string,
+  readonly params      : RouteParams,
   readonly searchParams: SearchParams,
-  readonly data: mixed,
-  readonly pending: boolean,
+  readonly data        : mixed,
+  readonly pending     : boolean,
 |};
 
 /**
@@ -596,10 +596,10 @@ export type Navigation = "client" | "document";
  * from its modules, which the browser composes itself.
  */
 type RouterState = {|
-  readonly route: RouteState,
-  readonly view: RouteViewState,
-  readonly router: Router,
-  readonly pending: boolean,
+  readonly route     : RouteState,
+  readonly view      : RouteViewState,
+  readonly router    : Router,
+  readonly pending   : boolean,
   readonly navigation: Navigation,
 |};
 
@@ -708,9 +708,9 @@ export function routeTable(): RouteTable {
  * modules instead. See ubugeeei-prod/uf#519.
  */
 export type AppProps = {|
-  readonly url: string,
+  readonly url     : string,
   readonly initial?: ResolvedRoute,
-  readonly flight?: Promise<FlightRoot>,
+  readonly flight? : Promise<FlightRoot>,
 |};
 
 /**
@@ -760,9 +760,9 @@ function isBrowser(): boolean {
  * that actually differs.
  */
 export component RouterProvider(
-  url: string,
+  url     : string,
   initial?: ResolvedRoute,
-  flight?: Promise<FlightRoot>,
+  flight? : Promise<FlightRoot>,
   children: React.Node,
 ) {
   if (flight != null) {
@@ -868,7 +868,7 @@ function flightNavigationKey(pathname: string, search: string, from: ?string): s
  */
 component ModuleRouter(url: string, initial: ResolvedRoute, children: React.Node) {
   const [resolved, setResolved] = useState<ResolvedRoute>(initial);
-  const [pending, setPending] = useState<boolean>(false);
+  const [pending,  setPending]  = useState<boolean>(false);
   // Read once per render rather than per navigation: it is installed by the
   // entry before the first render and never changes after it, and a `Link`
   // that asked at click time would be asking a question whose answer decided
@@ -1087,7 +1087,7 @@ component ModuleRouter(url: string, initial: ResolvedRoute, children: React.Node
   }, []);
 
   const router: Router = {
-    push: (to, options) => navigate(to, options),
+    push   : (to, options) => navigate(to, options),
     replace: (to) => navigate(to, { replace: true }),
     prefetch: async (to) => {
       // A prefetch loads the modules the *next render* will need, and under
@@ -1214,7 +1214,7 @@ component ModuleRouter(url: string, initial: ResolvedRoute, children: React.Node
 
   const value: RouterState = {
     route: routeState(resolved),
-    view: { kind: "modules", resolved },
+    view : { kind: "modules", resolved },
     router,
     pending,
     navigation,
@@ -1411,7 +1411,7 @@ component FlightRouter(flight: Promise<FlightRoot>, children: React.Node) {
   }, []);
 
   const router: Router = {
-    push: (to, options) => navigate(to, options),
+    push   : (to, options) => navigate(to, options),
     replace: (to) => navigate(to, { replace: true }),
     prefetch: async (to) => {
       // Under document navigation there is no next render in this page to
@@ -1518,7 +1518,7 @@ component FlightRouter(flight: Promise<FlightRoot>, children: React.Node) {
 
   const value: RouterState = {
     route: root.route,
-    view: { kind: "flight", tree: root.tree },
+    view : { kind: "flight", tree: root.tree },
     router,
     pending,
     navigation,
@@ -1549,8 +1549,8 @@ const prefetchedFlights: Map<
  * a payload React could not read.
  */
 function keepFlight(
-  key: string,
-  fetched: Promise<FetchedFlight>,
+  key         : string,
+  fetched     : Promise<FetchedFlight>,
   ordinaryKey?: string,
 ): Promise<FetchedFlight> {
   if (!keepsNavigations()) {
@@ -1652,11 +1652,11 @@ export hook useRouterState(): RouterState {
 export hook useRoute(): RouteInfo {
   const { route, pending } = useRouterState();
   return {
-    path: route.path,
-    pathname: route.pathname,
-    params: route.params,
+    path        : route.path,
+    pathname    : route.pathname,
+    params      : route.params,
     searchParams: route.searchParams,
-    data: useResolvedData(route),
+    data        : useResolvedData(route),
     pending,
   };
 }
@@ -2065,14 +2065,14 @@ export hook useLinkStatus(): {| readonly pending: boolean |} {
  */
 export type LinkClickEvent = {
   readonly defaultPrevented: boolean,
-  readonly button: number,
-  readonly altKey: boolean,
-  readonly ctrlKey: boolean,
-  readonly metaKey: boolean,
-  readonly shiftKey: boolean,
-  readonly currentTarget: mixed,
-  readonly preventDefault: () => mixed,
-  readonly stopPropagation: () => mixed,
+  readonly button          : number,
+  readonly altKey          : boolean,
+  readonly ctrlKey         : boolean,
+  readonly metaKey         : boolean,
+  readonly shiftKey        : boolean,
+  readonly currentTarget   : mixed,
+  readonly preventDefault  : () => mixed,
+  readonly stopPropagation : () => mixed,
   ...
 };
 
@@ -2102,20 +2102,20 @@ export type LinkClickEvent = {
  * ordinary link.
  */
 export component Link(
-  to: string,
-  prefetch?: LinkPrefetch = "intent",
-  replace?: boolean = false,
+  to         : string,
+  prefetch?  : LinkPrefetch = "intent",
+  replace?   : boolean = false,
   transition?: boolean = true,
-  children?: React.Node,
-  className?: string,
-  onClick?: (event: LinkClickEvent) => mixed,
+  children?  : React.Node,
+  className? : string,
+  onClick?   : (event: LinkClickEvent) => mixed,
   // `key` named out of the indexer: React never hands a component its key, and
   // the rest is spread onto the anchor, where a `mixed` key would not do.
   ...rest: { readonly key?: empty, readonly [string]: mixed }
 ) {
-  const { router, navigation } = useRouterState();
+  const { router, navigation }             = useRouterState();
   const [linkPending, startLinkTransition] = useTransition();
-  const prefetched = useRef(false);
+  const prefetched                         = useRef(false);
   const drives = navigation === "client";
 
   const doPrefetch = () => {

package/internal/search-params.js

@@ -68,7 +68,7 @@ export async function parseSearchParams(
  */
 export function searchParamsInput(
   description: Description,
-  query: SearchParamsAll,
+  query      : SearchParamsAll,
 ): { readonly [string]: mixed } {
   const fields = objectFields(description);
   // Built as a `Map` and turned into an object once, by `Object.fromEntries`,

package/internal/shell.js

@@ -22,9 +22,9 @@ import { type DocumentShell, bodyOfText } from "./stream.js";
 /** A redirect, as the finished document `prerender` answers with. */
 export async function redirectResult(document: RenderResult): Promise<PrerenderResult> {
   return {
-    status: document.status,
+    status : document.status,
     headers: document.headers,
-    html: await document.text(),
+    html   : await document.text(),
   };
 }
 
@@ -41,11 +41,11 @@ export function redirectDocument(error: RedirectError): RenderResult {
     `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="refresh" content="0; url=${target}"><title>Redirecting</title></head><body><a href="${target}">Redirecting…</a></body></html>\n`,
   );
   return {
-    status: error.permanent ? 308 : 307,
+    status : error.permanent ? 308 : 307,
     headers: { Location: address },
-    pipe: body.pipe,
-    stream: body.stream,
-    text: body.text,
+    pipe   : body.pipe,
+    stream : body.stream,
+    text   : body.text,
   };
 }
 
@@ -81,8 +81,8 @@ export function redirectDocument(error: RedirectError): RenderResult {
  * looks. Hoisting the rendered one leaves the metadata with a single source.
  */
 export function shellFor(
-  assets: RenderAssets,
-  nonce?: string | null,
+  assets    : RenderAssets,
+  nonce?    : string | null,
   formState?: FormState,
 ): DocumentShell {
   // A postback's form state goes first, before the client entry that reads it:

package/internal/stream.js

@@ -57,7 +57,7 @@ import { type StreamRecord, inspected } from "./inspector.js";
  */
 export type WritableLike = {
   readonly write: (chunk: string) => mixed,
-  readonly end: () => mixed,
+  readonly end  : () => mixed,
   ...
 };
 
@@ -89,14 +89,14 @@ export type DocumentBody = {|
  * point of writing it down.
  */
 type NodeDestination = {
-  readonly write: (chunk: string | Uint8Array) => boolean,
-  readonly end: () => mixed,
-  readonly destroy: (error?: mixed) => mixed,
-  readonly on: (event: string, listener: (...args: Array<mixed>) => mixed) => mixed,
-  readonly once: (event: string, listener: (...args: Array<mixed>) => mixed) => mixed,
-  readonly off: () => mixed,
+  readonly write         : (chunk: string | Uint8Array) => boolean,
+  readonly end           : () => mixed,
+  readonly destroy       : (error?: mixed) => mixed,
+  readonly on            : (event: string, listener: (...args: Array<mixed>) => mixed) => mixed,
+  readonly once          : (event: string, listener: (...args: Array<mixed>) => mixed) => mixed,
+  readonly off           : () => mixed,
   readonly removeListener: () => mixed,
-  readonly emit: () => boolean,
+  readonly emit          : () => boolean,
 };
 
 /** The controller a `ReadableStream` source is handed. */
@@ -107,7 +107,7 @@ type NodeDestination = {
  * cannot type a value whose definition depends on itself without being told.
  */
 type PipeableStream = {
-  readonly pipe: (destination: NodeDestination) => mixed,
+  readonly pipe : (destination: NodeDestination) => mixed,
   readonly abort: (reason?: mixed) => void,
   ...
 };
@@ -322,10 +322,10 @@ function queueDestination(queue: ChunkQueue): NodeDestination {
  * once, and everything that belongs in it has to be in hand by then.
  */
 async function* assembled(
-  chunks: AsyncGenerator<string, void, void>,
-  shell: DocumentShell,
+  chunks        : AsyncGenerator<string, void, void>,
+  shell         : DocumentShell,
   transformHead?: (html: string) => Promise<string>,
-  layout?: Layout,
+  layout?       : Layout,
 ): AsyncGenerator<string, void, void> {
   let held = "";
   let shape = "unknown";
@@ -725,7 +725,7 @@ export type RenderOptions = {|
  * handed, head and all, and not React's own output on the way past.
  */
 function outgoing(
-  chunks: AsyncGenerator<string, void, void>,
+  chunks   : AsyncGenerator<string, void, void>,
   onStream?: (record: StreamRecord) => void,
 ): AsyncGenerator<string, void, void> {
   return onStream == null ? chunks : inspected(chunks, onStream, () => performance.now());
@@ -772,7 +772,7 @@ export function renderDocument(node: React.Node, options: RenderOptions): Promis
         // the streaming runtime that reveals a boundary and patches a segment,
         // and the bootstrap. uf nonces the scripts it writes itself; these are
         // React's, and there is no other way to reach them.
-        nonce: options.nonce ?? undefined,
+        nonce    : options.nonce ?? undefined,
         formState: options.formState ?? null,
       });
       return;
@@ -799,9 +799,9 @@ export function renderDocument(node: React.Node, options: RenderOptions): Promis
 type ReadableStreamRenderer = (
   node: React.Node,
   settings: {|
-    readonly onError: (error: mixed) => void,
-    readonly signal: AbortSignal,
-    readonly nonce?: string,
+    readonly onError   : (error: mixed) => void,
+    readonly signal    : AbortSignal,
+    readonly nonce?    : string,
     readonly formState?: FormState | null,
   |},
 ) => Promise<ByteSource>;
@@ -823,15 +823,15 @@ type ReadableStreamRenderer = (
  * disagreed.
  */
 export function renderWithReadableStream(
-  render: ReadableStreamRenderer,
-  node: React.Node,
+  render : ReadableStreamRenderer,
+  node   : React.Node,
   options: RenderOptions,
 ): Promise<DocumentBody> {
   const controller = new AbortController();
   return render(node, {
-    onError: options.onError,
-    signal: controller.signal,
-    nonce: options.nonce ?? undefined,
+    onError  : options.onError,
+    signal   : controller.signal,
+    nonce    : options.nonce ?? undefined,
     formState: options.formState ?? null,
   }).then((stream: ByteSource) =>
     bodyOf(
@@ -960,9 +960,9 @@ export type PrerenderedShell = {|
 export async function prerenderShell(
   node: React.Node,
   options: {|
-    readonly shell: DocumentShell,
+    readonly shell  : DocumentShell,
     readonly onError: (error: mixed) => void,
-    readonly settle: () => Promise<void>,
+    readonly settle : () => Promise<void>,
   |},
 ): Promise<PrerenderedShell> {
   const controller = new AbortController();
@@ -994,15 +994,15 @@ export async function prerenderShell(
   // a document React wrote ends in its own, which `resume` writes again.
   if (text.endsWith(options.shell.close)) {
     return {
-      html: text.slice(0, text.length - options.shell.close.length),
-      close: options.shell.close,
+      html     : text.slice(0, text.length - options.shell.close.length),
+      close    : options.shell.close,
       rootDepth: layout.rootDepth,
       postponed,
     };
   }
   return {
-    html: text.replace(/<\/body>\s*<\/html>\s*$/i, ""),
-    close: "",
+    html     : text.replace(/<\/body>\s*<\/html>\s*$/i, ""),
+    close    : "",
     rootDepth: layout.rootDepth,
     postponed,
   };
@@ -1024,12 +1024,12 @@ export async function prerenderShell(
  * own level, so the payload may follow it as soon as it exists.
  */
 export function resumeDocument(
-  node: React.Node,
+  node : React.Node,
   shell: PrerenderedShell,
   options: {|
-    readonly onError: (error: mixed) => void,
-    readonly payload: ReadableStream<Uint8Array>,
-    readonly nonce?: string | null,
+    readonly onError  : (error: mixed) => void,
+    readonly payload  : ReadableStream<Uint8Array>,
+    readonly nonce?   : string | null,
     readonly onStream?: (record: StreamRecord) => void,
   |},
 ): DocumentBody {
@@ -1039,8 +1039,8 @@ export function resumeDocument(
   // for the shell to be read before it starts on the holes.
   const resuming: Promise<ByteSource> = ReactDOMServer.resume(node, shell.postponed, {
     onError: options.onError,
-    signal: controller.signal,
-    nonce: options.nonce ?? undefined,
+    signal : controller.signal,
+    nonce  : options.nonce ?? undefined,
   });
   // A resume that fails before its first byte fails the stream below, once it
   // is read; this keeps the rejection from being reported as unhandled while
@@ -1079,11 +1079,11 @@ type Layout = {|
 
 /** [`assembled`] alone when there is no payload, and [`interleaved`] with one. */
 function withPayload(
-  chunks: AsyncGenerator<string, void, void>,
-  shell: DocumentShell,
+  chunks       : AsyncGenerator<string, void, void>,
+  shell        : DocumentShell,
   transformHead: ?(html: string) => Promise<string>,
-  payload: ?ReadableStream<Uint8Array>,
-  nonce?: string | null,
+  payload      : ?ReadableStream<Uint8Array>,
+  nonce?       : string | null,
 ): AsyncGenerator<string, void, void> {
   if (payload == null) {
     return assembled(chunks, shell, transformHead ?? undefined);
@@ -1158,9 +1158,9 @@ function withPayload(
  * in the `finally`, which is where `return()` on this generator lands.
  */
 async function* interleaved(
-  chunks: AsyncGenerator<string, void, void>,
+  chunks : AsyncGenerator<string, void, void>,
   payload: ReadableStream<Uint8Array>,
-  nonce?: string | null,
+  nonce? : string | null,
   layout?: Layout,
 ): AsyncGenerator<string, void, void> {
   const encoder = createChunkEncoder(nonce);
@@ -1269,11 +1269,11 @@ type Boundary = {|
 |};
 
 const NOTHING_WRITTEN: Boundary = {
-  safe: false,
-  rawText: null,
+  safe       : false,
+  rawText    : null,
   replaceable: 0,
-  open: "",
-  depth: null,
+  open       : "",
+  depth      : null,
 };
 
 /** Elements with no closing tag, for markup whose `/>` React did not write. */

package/middleware.js

@@ -332,8 +332,8 @@ function interceptionBase(header: string | null, base: URL): URL | null {
  * only learns that the page underneath is not this request's to render.
  */
 async function guardsAdmit(
-  table: $ReadOnlyArray<MiddlewareRecord>,
-  request: Request,
+  table     : $ReadOnlyArray<MiddlewareRecord>,
+  request   : Request,
   underneath: URL,
 ): Promise<boolean> {
   const asked = new Request(underneath.href, { method: "GET", headers: request.headers });
@@ -403,18 +403,18 @@ function withPathname(url: URL, pathname: string): URL {
 function requestAt(request: Request, url: URL): Request {
   const body = request.body;
   return new Request(url.href, {
-    method: request.method,
+    method : request.method,
     headers: request.headers,
     body,
     ...(body == null ? {} : { duplex: "half" }),
-    signal: request.signal,
-    cache: request.cache,
-    credentials: request.credentials,
-    integrity: request.integrity,
-    keepalive: request.keepalive,
-    mode: request.mode,
-    redirect: request.redirect,
-    referrer: request.referrer,
+    signal        : request.signal,
+    cache         : request.cache,
+    credentials   : request.credentials,
+    integrity     : request.integrity,
+    keepalive     : request.keepalive,
+    mode          : request.mode,
+    redirect      : request.redirect,
+    referrer      : request.referrer,
     referrerPolicy: request.referrerPolicy,
   });
 }

package/native-navigation.js

@@ -22,21 +22,21 @@ import { nativeTree, stateForPath, hrefFromState, paramsForPath } from "./intern
 
 export interface NavigatorPair {
   readonly Navigator: React.ComponentType<{ ... }>;
-  readonly Screen: React.ComponentType<{ ... }>;
+  readonly Screen   : React.ComponentType<{ ... }>;
 }
 export type FileRouter = {
-  readonly push: (href: string) => void,
-  readonly replace: (href: string) => void,
-  readonly back: () => void,
+  readonly push    : (href: string) => void,
+  readonly replace : (href: string) => void,
+  readonly back    : () => void,
   readonly prefetch: (href: string) => Promise<void>,
 };
 type Scope = {
-  tree: NativeTree,
-  node: NativeNode,
+  tree   : NativeTree,
+  node   : NativeNode,
   screens: Map<NativeNode, React.ComponentType<{ ... }>>,
-  stack: NavigatorPair,
-  tabs: ?NavigatorPair,
-  router: FileRouter,
+  stack  : NavigatorPair,
+  tabs   : ?NavigatorPair,
+  router : FileRouter,
 };
 const ScopeContext: React.Context<Scope | null> = React.createContext(null);
 
@@ -51,12 +51,12 @@ function useScope(): Scope {
 
 /** The application supplies its own React Navigation navigator factories. */
 export function createNativeNavigation(options: {
-  table: RouteTable<>,
-  layouts: $ReadOnlyArray<NativeLayout>,
-  stack: NavigatorPair,
-  tabs?: NavigatorPair,
+  table       : RouteTable<>,
+  layouts     : $ReadOnlyArray<NativeLayout>,
+  stack       : NavigatorPair,
+  tabs?       : NavigatorPair,
   initialHref?: string,
-  links?: NativeLinkSource,
+  links?      : NativeLinkSource,
 }): { Root: React.ComponentType<{ ... }>, router: FileRouter, linking: { ... } } {
   const { table, layouts, stack, tabs } = options;
   const tree = nativeTree(table, layouts);
@@ -69,9 +69,9 @@ export function createNativeNavigation(options: {
     return { names, payload: { ufHref: event.href, ufParams: event.params } };
   };
   function actionFor(
-    names: $ReadOnlyArray<string>,
+    names  : $ReadOnlyArray<string>,
     payload: NavigationPayload,
-    kind: "push" | "replace",
+    kind   : "push" | "replace",
   ): { readonly [string]: mixed } {
     if (!ref.isReady()) throw new Error("Native navigation: NavigationContainer is not ready");
     let state: NavigationState = ref.getRootState();
@@ -95,7 +95,7 @@ export function createNativeNavigation(options: {
     ref.dispatch(actionFor(names, payload, kind));
   }
   const router: FileRouter = {
-    push: (href) => navigate(href, "push"),
+    push   : (href) => navigate(href, "push"),
     replace: (href) => navigate(href, "replace"),
     back: () => {
       if (ref.canGoBack()) ref.goBack();
@@ -104,9 +104,9 @@ export function createNativeNavigation(options: {
   };
   const source = options.links == null ? null : createNativeLinking(table, options.links);
   const linking = {
-    prefixes: [""],
+    prefixes     : [""],
     getInitialURL: source?.getInitialURL ?? (async () => null),
-    subscribe: source?.subscribe ?? (() => () => {}),
+    subscribe    : source?.subscribe ?? (() => () => {}),
     getStateFromPath: (href: string) => {
       const { names, payload } = resolve(
         href.startsWith("/") || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(href) ? href : `/${href}`,
@@ -199,9 +199,9 @@ export function useParams(): { readonly [string]: string | $ReadOnlyArray<string
 }
 
 export component Link(
-  href: string,
+  href    : string,
   children: React.Node,
-  replace: boolean = false,
+  replace : boolean = false,
   ...props: { ... }
 ) {
   const router = useNativeRouter();