@fastify/react 1.1.2 → 1.1.4

package/README.md

@@ -2,4 +2,4 @@
 
 **`@fastify/react`** is the official [**`@fastify/vite`**](https://github.com/fastify/fastify-vite) renderer for React.
 
-See the [documentation suite](https://fastify.github.io/fastify-vite/react/) to learn more.
+See the [documentation suite](https://fastify.github.io/fastify-vite/react/) to learn more.

package/client.js

@@ -8,18 +8,16 @@ export function useRouteContext() {
   const routeContext = useContext(RouteContext)
   if (routeContext.state) {
     routeContext.snapshot = isServer
-      ? routeContext.state ?? {}
+      ? (routeContext.state ?? {})
       : useSnapshot(routeContext.state ?? {})
   }
   return routeContext
 }
 
-export async function hydrateRoutes (fromInput) {
+export async function hydrateRoutes(fromInput) {
   let from = fromInput
   if (Array.isArray(from)) {
-    from = Object.fromEntries(
-      from.map((route) => [route.path, route]),
-    )
+    from = Object.fromEntries(from.map((route) => [route.path, route]))
   }
   return window.routes.map((route) => {
     route.loader = memoImport(from[route.id])
@@ -28,7 +26,7 @@ export async function hydrateRoutes (fromInput) {
   })
 }
 
-function memoImport (func) {
+function memoImport(func) {
   // Otherwise we get a ReferenceError, but since this function
   // is only ran once for each route, there's no overhead
   const kFuncExecuted = Symbol('kFuncExecuted')

package/index.js

@@ -1,16 +1,7 @@
-export {
-  prepareServer,
-} from './server.js'
+export { prepareServer } from './server.js'
 
-export {
-  prepareClient,
-  createErrorHandler,
-  createRoute,
-} from './routing.js'
+export { prepareClient, createErrorHandler, createRoute } from './routing.js'
 
-export {
-  createRenderFunction,
-  createHtmlFunction,
-} from './rendering.js'
+export { createRenderFunction, createHtmlFunction } from './rendering.js'
 
 export const clientModule = '$app/index.js'

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@fastify/react",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "The official @fastify/vite renderer for React",
   "keywords": [
     "fastify",
-    "vite",
-    "react"
+    "react",
+    "vite"
   ],
   "homepage": "https://fastify.github.io/fastify-vite/react/",
   "bugs": {
@@ -16,22 +16,29 @@
     "type": "git",
     "url": "git+https://github.com/fastify/fastify-vite.git"
   },
-  "type": "module",
-  "main": "index.js",
-  "exports": {
-    ".": "./index.js",
-    "./plugin": "./plugin/index.js",
-    "./client": "./client.js",
-    "./server": "./server.js"
-  },
   "files": [
+    "client.js",
+    "context.js",
+    "index.js",
+    "rendering.js",
+    "routing.js",
+    "server.js",
+    "templating.js",
     "plugin/index.js",
     "plugin/parsers.js",
     "plugin/parsers.test.js",
     "plugin/preload.js",
     "plugin/stores.js",
     "plugin/virtual.js",
-    "virtual/layouts/default.jsx",
+    "virtual-ts/context.ts",
+    "virtual-ts/core.tsx",
+    "virtual-ts/create.tsx",
+    "virtual-ts/index.ts",
+    "virtual-ts/layouts.ts",
+    "virtual-ts/mount.ts",
+    "virtual-ts/resource.ts",
+    "virtual-ts/root.tsx",
+    "virtual-ts/routes.ts",
     "virtual/context.js",
     "virtual/core.jsx",
     "virtual/create.jsx",
@@ -42,23 +49,19 @@
     "virtual/root.jsx",
     "virtual/routes.js",
     "virtual-ts/layouts/default.tsx",
-    "virtual-ts/context.ts",
-    "virtual-ts/core.tsx",
-    "virtual-ts/create.tsx",
-    "virtual-ts/index.ts",
-    "virtual-ts/layouts.ts",
-    "virtual-ts/mount.ts",
-    "virtual-ts/resource.ts",
-    "virtual-ts/root.tsx",
-    "virtual-ts/routes.ts",
-    "client.js",
-    "context.js",
-    "index.js",
-    "rendering.js",
-    "routing.js",
-    "server.js",
-    "templating.js"
+    "virtual/layouts/default.jsx"
   ],
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./plugin": "./plugin/index.js",
+    "./client": "./client.js",
+    "./server": "./server.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "@unhead/react": "^2.0.8",
     "acorn": "^8.14.1",
@@ -74,15 +77,7 @@
     "react-router": "^7.5.1",
     "valtio": "latest",
     "youch": "^3.3.4",
-    "@fastify/vite": "^8.2.1"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "^1.9.2"
-  },
-  "publishConfig": {
-    "access": "public"
+    "@fastify/vite": "^8.2.3"
   },
-  "scripts": {
-    "lint": "biome check --apply-unsafe ."
-  }
+  "scripts": {}
 }

package/plugin/index.js

@@ -6,51 +6,54 @@ import {
   resolveId,
   loadSource,
   loadVirtualModule,
-  createPlaceholderExports
+  createPlaceholderExports,
 } from './virtual.js'
 import { closeBundle } from './preload.js'
 import { parseStateKeys } from './parsers.js'
 import { generateStores } from './stores.js'
 
-export default function viteFastifyReactPlugin ({ ts } = {}) {
+export default function viteFastifyReactPlugin({ ts } = {}) {
   const context = {
     root: null,
   }
-  return [viteFastify({
-    clientModule: ts ? '$app/index.ts' : '$app/index.js'
-  }), {
-    // https://vite.dev/guide/api-plugin#conventions
-    name: 'vite-plugin-react-fastify',
-    config,
-    configResolved: configResolved.bind(context),
-    resolveId: resolveId.bind(context),
-    async load (id) {
-      if (id.includes('?server') && !this.environment.config.build?.ssr) {
-        const source = loadSource(id)
-        return createPlaceholderExports(source)
-      }
-      if (id.includes('?client') && this.environment.config.build?.ssr) {
-        const source = loadSource(id)
-        return createPlaceholderExports(source)
-      }
-      if (prefix.test(id)) {
-        const [, virtual] = id.split(prefix)
-        if (virtual) {
-          return loadVirtualModule(virtual)
+  return [
+    viteFastify({
+      clientModule: ts ? '$app/index.ts' : '$app/index.js',
+    }),
+    {
+      // https://vite.dev/guide/api-plugin#conventions
+      name: 'vite-plugin-react-fastify',
+      config,
+      configResolved: configResolved.bind(context),
+      resolveId: resolveId.bind(context),
+      async load(id) {
+        if (id.includes('?server') && !this.environment.config.build?.ssr) {
+          const source = loadSource(id)
+          return createPlaceholderExports(source)
         }
-      }
-    },
-    transformIndexHtml: {
-      order: 'post',
-      handler: transformIndexHtml.bind(context)
-    },
-    closeBundle () {
-      closeBundle.call(this, context.resolvedBundle)
+        if (id.includes('?client') && this.environment.config.build?.ssr) {
+          const source = loadSource(id)
+          return createPlaceholderExports(source)
+        }
+        if (prefix.test(id)) {
+          const [, virtual] = id.split(prefix)
+          if (virtual) {
+            return loadVirtualModule(virtual)
+          }
+        }
+      },
+      transformIndexHtml: {
+        order: 'post',
+        handler: transformIndexHtml.bind(context),
+      },
+      closeBundle() {
+        closeBundle.call(this, context.resolvedBundle)
+      },
     },
-  }]
+  ]
 }
 
-function transformIndexHtml (html, { bundle }) {
+function transformIndexHtml(html, { bundle }) {
   if (!bundle) {
     return
   }
@@ -58,12 +61,12 @@ function transformIndexHtml (html, { bundle }) {
   this.resolvedBundle = bundle
 }
 
-function configResolved (config) {
+function configResolved(config) {
   this.resolvedConfig = config
   this.root = config.root
 }
 
-function config (config, { command }) {
+function config(config, { command }) {
   if (command === 'build') {
     if (!config.build) {
       config.build = {}
@@ -75,22 +78,17 @@ function config (config, { command }) {
   }
 }
 
-function onwarn (warning, rollupWarn) {
+function onwarn(warning, rollupWarn) {
   if (
     !(
       warning.code == 'MISSING_EXPORT' &&
       warning.message?.includes?.('"scrollBehavior" is not exported')
-    )
-    &&
+    ) &&
     !(
       warning.code == 'PLUGIN_WARNING' &&
       warning.message?.includes?.('dynamic import will not move module into another chunk')
-    )
-    &&
-    !(
-      warning.code == 'UNUSED_EXTERNAL_IMPORT' &&
-      warning.exporter === 'vue'
-    )
+    ) &&
+    !(warning.code == 'UNUSED_EXTERNAL_IMPORT' && warning.exporter === 'vue')
   ) {
     rollupWarn(warning)
   }

package/plugin/parsers.js

@@ -1,7 +1,7 @@
 import * as acorn from 'acorn'
 import * as walk from 'acorn-walk'
 
-export function parseStateKeys (code) {
+export function parseStateKeys(code) {
   const ast = acorn.parse(code, { sourceType: 'module', ecmaVersion: 2020 })
 
   let objectKeys = []
@@ -25,7 +25,7 @@ export function parseStateKeys (code) {
           }
         }
       }
-    }
+    },
   })
 
   return objectKeys

package/plugin/parsers.test.js

@@ -23,6 +23,6 @@ test('parseStateKeys', (t) => {
 
     }
   }
-  `;
+  `
   assert.equal(['user', 'todoList'], parseStateKeys(b))
 })

package/plugin/preload.js

@@ -18,19 +18,18 @@ export async function closeBundle(resolvedBundle) {
   }
   const indexHtml = readFileSync(join(distDir, 'index.html'), 'utf8')
   const pages = Object.fromEntries(
-    Object.entries(resolvedBundle ?? {})
-      .filter(([id, meta]) => {
-        if (meta.facadeModuleId?.includes('/pages/')) {
-          meta.htmlPath = meta.facadeModuleId.replace(/.*pages\/(.*)\.(j|t)sx$/, 'html/$1.html')
-          return true
-        }
-      })
+    Object.entries(resolvedBundle ?? {}).filter(([id, meta]) => {
+      if (meta.facadeModuleId?.includes('/pages/')) {
+        meta.htmlPath = meta.facadeModuleId.replace(/.*pages\/(.*)\.(j|t)sx$/, 'html/$1.html')
+        return true
+      }
+    }),
   )
   for (const page of Object.values(pages)) {
     const jsImports = page.imports
     const cssImports = page.viteMetadata.importedCss
     const images = page.moduleIds.filter((img) => {
-      return (page.modules[img].originalLength > assetsInlineLimit) && imageFileRE.test(img)
+      return page.modules[img].originalLength > assetsInlineLimit && imageFileRE.test(img)
     })
     let imagePreloads = '\n'
     for (let image of images) {
@@ -45,17 +44,12 @@ export async function closeBundle(resolvedBundle) {
     for (const js of jsImports) {
       jsPreloads += `  <link rel="modulepreload" crossorigin href="${base}${js}">\n`
     }
-    const pageHtml = await appendHead(
-      indexHtml,
-      imagePreloads,
-      cssPreloads,
-      jsPreloads
-    )
+    const pageHtml = await appendHead(indexHtml, imagePreloads, cssPreloads, jsPreloads)
     writeHtml(page, pageHtml, distDir)
   }
 }
 
-async function appendHead (html, ...tags) {
+async function appendHead(html, ...tags) {
   const encoder = new TextEncoder()
   const decoder = new TextDecoder()
   let output = ''

package/plugin/stores.js

@@ -1,4 +1,3 @@
-
 export function generateStores(keys) {
   let code = `
 import { useRouteContext } from '@fastify/react/client'
@@ -34,6 +33,6 @@ export const ${key} = new Proxy({
   }
   return {
     code,
-    map: null
+    map: null,
   }
 }

package/plugin/virtual.js

@@ -2,7 +2,6 @@ import { readFileSync, existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { findExports } from 'mlly'
 
-
 const virtualRoot = resolve(import.meta.dirname, '..', 'virtual')
 const virtualRootTS = resolve(import.meta.dirname, '..', 'virtual-ts')
 
@@ -68,7 +67,6 @@ export function loadVirtualModule(virtualInput) {
   }
 }
 
-
 virtualModulesTS.includes = function (virtual) {
   if (!virtual) {
     return false
@@ -81,7 +79,6 @@ virtualModulesTS.includes = function (virtual) {
   return false
 }
 
-
 virtualModules.includes = function (virtual) {
   if (!virtual) {
     return false
@@ -110,9 +107,7 @@ function loadVirtualModuleOverride(viteProjectRoot, virtualInput) {
 }
 
 export function loadSource(id) {
-  const filePath = id
-    .replace(/\?client$/, '')
-    .replace(/\?server$/, '')
+  const filePath = id.replace(/\?client$/, '').replace(/\?server$/, '')
   return readFileSync(filePath, 'utf8')
 }
 

package/rendering.js

@@ -43,9 +43,9 @@ export function onAllReady(app) {
   })
 }
 
-export async function createRenderFunction ({ routes, create }) {
+export async function createRenderFunction({ routes, create }) {
   // Used when hydrating React Router on the client
-  const routeMap = Object.fromEntries(routes.map(_ => [_.path, _]))
+  const routeMap = Object.fromEntries(routes.map((_) => [_.path, _]))
 
   // Registered as reply.render()
   return function () {
@@ -56,13 +56,13 @@ export async function createRenderFunction ({ routes, create }) {
   }
 }
 
-async function createStreamingResponse (req, routes) {
+async function createStreamingResponse(req, routes) {
   // SSR stream
   const body = await onShellReady(req.route.app)
   return { routes, context: req.route, body }
 }
 
-async function createResponse (req, routes) {
+async function createResponse(req, routes) {
   let body
   if (!req.route.clientOnly) {
     // SSR string
@@ -72,7 +72,7 @@ async function createResponse (req, routes) {
 }
 
 // The return value of this function gets registered as reply.html()
-export async function createHtmlFunction (source, _, config) {
+export async function createHtmlFunction(source, _, config) {
   // Creates `universal` and `serverOnly` sets of
   // HTML `beforeElement` and `afterElement` templates
   const templates = await createHtmlTemplates(source, config)
@@ -89,23 +89,17 @@ export async function createHtmlFunction (source, _, config) {
       // Turn off hydration
       context.hydration = ''
 
-      return streamShell(
-        templates.serverOnly,
-        context,
-        body,
-      )
+      return streamShell(templates.serverOnly, context, body)
     }
 
     // Embed full hydration script
-    context.hydration = (
-      `<script>\nwindow.route = ${
-        // Server data payload
-        devalue.uneval(context.toJSON())
-      }\nwindow.routes = ${
-        // Universal router payload
-        devalue.uneval(routes.toJSON())
-      }\n</script>`
-    )
+    context.hydration = `<script>\nwindow.route = ${
+      // Server data payload
+      devalue.uneval(context.toJSON())
+    }\nwindow.routes = ${
+      // Universal router payload
+      devalue.uneval(routes.toJSON())
+    }\n</script>`
 
     // In all other cases use universal,
     // template which works the same for SSR and CSR.
@@ -118,35 +112,22 @@ export async function createHtmlFunction (source, _, config) {
   }
 }
 
-export async function sendClientOnlyShell (templates, context) {
+export async function sendClientOnlyShell(templates, context) {
   return await transformHtmlTemplate(
     context.useHead,
-    `${
-      templates.beforeElement(context)
-    }${
-      templates.afterElement(context)
-    }`
+    `${templates.beforeElement(context)}${templates.afterElement(context)}`,
   )
 }
 
-export function streamShell (templates, context, body) {
+export function streamShell(templates, context, body) {
   return Readable.from(createShellStream(templates, context, body))
 }
 
-async function * createShellStream (templates, context, body) {
-  yield await transformHtmlTemplate(
-    context.useHead,
-    templates.beforeElement(context)
-  )
+async function* createShellStream(templates, context, body) {
+  yield await transformHtmlTemplate(context.useHead, templates.beforeElement(context))
 
   for await (const chunk of body) {
-    yield await transformHtmlTemplate(
-      context.useHead,
-      chunk.toString()
-    )
+    yield await transformHtmlTemplate(context.useHead, chunk.toString())
   }
-  yield await transformHtmlTemplate(
-    context.useHead,
-    templates.afterElement(context)
-  )
+  yield await transformHtmlTemplate(context.useHead, templates.afterElement(context))
 }

package/routing.js

@@ -4,7 +4,7 @@ import Youch from 'youch'
 import RouteContext from './context.js'
 import { createHtmlFunction } from './rendering.js'
 
-export async function prepareClient (entries, _) {
+export async function prepareClient(entries, _) {
   const client = entries.ssr
   if (client.context instanceof Promise) {
     client.context = await client.context
@@ -19,7 +19,7 @@ export async function prepareClient (entries, _) {
   return client
 }
 
-export function createErrorHandler (_, scope, config) {
+export function createErrorHandler(_, scope, config) {
   return async (error, req, reply) => {
     req.log.error(error)
     if (config.dev) {
@@ -35,25 +35,19 @@ export function createErrorHandler (_, scope, config) {
   }
 }
 
-export async function createRoute ({ client, errorHandler, route }, scope, config) {
+export async function createRoute({ client, errorHandler, route }, scope, config) {
   if (route.configure) {
     await route.configure(scope)
   }
 
   // Used when hydrating Vue Router on the client
-  const routeMap = Object.fromEntries(client.routes.map(_ => [_.path, _]))
+  const routeMap = Object.fromEntries(client.routes.map((_) => [_.path, _]))
 
   // Extend with route context initialization module
   RouteContext.extend(client.context)
 
   const onRequest = async (req, reply) => {
-    req.route = await RouteContext.create(
-      scope,
-      req,
-      reply,
-      route,
-      client.context,
-    )
+    req.route = await RouteContext.create(scope, req, reply, route, client.context)
   }
 
   const preHandler = [
@@ -67,7 +61,7 @@ export async function createRoute ({ client, errorHandler, route }, scope, confi
         })
         req.route.app = app
       }
-    }
+    },
   ]
 
   if (route.getData) {
@@ -111,7 +105,7 @@ export async function createRoute ({ client, errorHandler, route }, scope, confi
     handler = (_, reply) => reply.html()
   } else {
     const { id } = route
-    const htmlPath = id.replace(/pages\/(.*?)\.(j|t)sx/, 'html/$1.html')
+    const htmlPath = id.replace('pages/', 'html/').replace(/\.(j|t)sx$/, '.html')
     let distDir = config.vite.build.outDir
     if (!isAbsolute(config.vite.build.outDir)) {
       distDir = join(config.vite.root, distDir)
@@ -122,8 +116,8 @@ export async function createRoute ({ client, errorHandler, route }, scope, confi
   }
 
   // Replace wildcard routes with Fastify compatible syntax
-  const routePath = route.path.replace(/:[^+]+\+/, '*')
-  
+  const routePath = route.path.replace(/:\w[\w-]*\+/, '*')
+
   unshiftHook(route, 'onRequest', onRequest)
   unshiftHook(route, 'preHandler', preHandler)
 
@@ -139,14 +133,14 @@ export async function createRoute ({ client, errorHandler, route }, scope, confi
     // If getData is provided, register JSON endpoint for it
     scope.get(`/-/data${routePath}`, {
       onRequest,
-      async handler (req, reply) {
+      async handler(req, reply) {
         reply.send(await route.getData(req.route))
       },
     })
   }
 }
 
-function unshiftHook (route, hookName, hook) {
+function unshiftHook(route, hookName, hook) {
   if (!route[hookName]) {
     route[hookName] = []
   }

package/server.js

@@ -1,7 +1,7 @@
 // Otherwise we get a ReferenceError, but since
 // this function is only ran once, there's no overhead
 class Routes extends Array {
-  toJSON () {
+  toJSON() {
     return this.map((route) => {
       return {
         id: route.id,
@@ -39,71 +39,68 @@ export function prepareServer(server) {
   })
 }
 
-export async function createRoutes (fromPromise, { param } = { param: /\[([.\w]+\+?)\]/ }) {
+export async function createRoutes(fromPromise, { param } = { param: /\[([.\w]+\+?)\]/ }) {
   const { default: from } = await fromPromise
   const importPaths = Object.keys(from)
   const promises = []
   if (Array.isArray(from)) {
     for (const routeDef of from) {
       promises.push(
-        getRouteModule(routeDef.path, routeDef.component)
-          .then((routeModule) => {
-            return {
-              id: routeDef.path,
-              name: routeDef.path ?? routeModule.path,
-              path: routeDef.path ?? routeModule.path,
-              ...routeModule,
-            }
-          }),
+        getRouteModule(routeDef.path, routeDef.component).then((routeModule) => {
+          return {
+            id: routeDef.path,
+            name: routeDef.path ?? routeModule.path,
+            path: routeDef.path ?? routeModule.path,
+            ...routeModule,
+          }
+        }),
       )
     }
   } else {
     // Ensure that static routes have precedence over the dynamic ones
-    for (const path of importPaths.sort((a, b) => a > b ? -1 : 1)) {
+    for (const path of importPaths.sort((a, b) => (a > b ? -1 : 1))) {
       promises.push(
-        getRouteModule(path, from[path])
-          .then((routeModule) => {
-            const route = {
-              id: path,
-              layout: routeModule.layout,
-              name: path
+        getRouteModule(path, from[path]).then((routeModule) => {
+          const route = {
+            id: path,
+            layout: routeModule.layout,
+            name: path
+              // Remove /pages and .vue extension
+              .slice(6, -4)
+              // Remove params
+              .replace(param, '')
+              // Remove leading and trailing slashes
+              .replace(/^\/*|\/*$/g, '')
+              // Replace slashes with underscores
+              .replace(/\//g, '_'),
+            path:
+              routeModule.path ??
+              path
                 // Remove /pages and .vue extension
                 .slice(6, -4)
-                // Remove params
-                .replace(param, '')
-                // Remove leading and trailing slashes
-                .replace(/^\/*|\/*$/g, '')
-                // Replace slashes with underscores
-                .replace(/\//g, '_'),
-              path:
-                routeModule.path ??
-                path
-                  // Remove /pages and .vue extension
-                  .slice(6, -4)
-                  // Replace [id] with :id and [slug+] with :slug+
-                  .replace(param, (_, m) => `:${m}`)
-                  .replace(/:\w+\+/, (_, m) => `*`)
-                  // Replace '/index' with '/'
-                  .replace(/\/index$/, '/')
-                  // Remove trailing slashs
-                  .replace(/(.+)\/+$/, (...m) => m[1]),
-              ...routeModule,
-            }
+                // Replace [id] with :id and [slug+] with :slug+
+                .replace(param, (_, m) => `:${m}`)
+                .replace(/:\w+\+/, (_, m) => `*`)
+                // Replace '/index' with '/'
+                .replace(/\/index$/, '/')
+                // Remove trailing slashs
+                .replace(/(.+)\/+$/, (...m) => m[1]),
+            ...routeModule,
+          }
 
-            if (route.name === '') {
-              route.name = 'catch-all'
-            }
+          if (route.name === '') {
+            route.name = 'catch-all'
+          }
 
-            return route
-          }),
+          return route
+        }),
       )
     }
   }
-  return new Routes(...await Promise.all(promises))
+  return new Routes(...(await Promise.all(promises)))
 }
 
-
-function getRouteModuleExports (routeModule) {
+function getRouteModuleExports(routeModule) {
   return {
     // The Route component (default export)
     component: routeModule.default,
@@ -133,7 +130,7 @@ function getRouteModuleExports (routeModule) {
   }
 }
 
-async function getRouteModule (path, routeModuleInput) {
+async function getRouteModule(path, routeModuleInput) {
   if (typeof routeModuleInput === 'function') {
     const routeModule = await routeModuleInput()
     return getRouteModuleExports(routeModule)

package/templating.js

@@ -1,7 +1,7 @@
 import { createHtmlTemplateFunction } from '@fastify/vite/utils'
 import { HTMLRewriter } from 'html-rewriter-wasm'
 
-export async function createHtmlTemplates (source, config) {
+export async function createHtmlTemplates(source, config) {
   const el = '<!-- element -->'
 
   const universal = source.split(el)
@@ -22,7 +22,7 @@ export async function createHtmlTemplates (source, config) {
   }
 }
 
-async function removeClientModule (html, config) {
+async function removeClientModule(html, config) {
   const decoder = new TextDecoder()
 
   let output = ''
@@ -31,7 +31,7 @@ async function removeClientModule (html, config) {
   })
 
   rewriter.on('script', {
-    element (element) {
+    element(element) {
       for (const [attr, value] of element.attributes) {
         if (attr === 'type' && value === 'module') {
           element.replace('')

package/virtual/core.jsx

@@ -18,11 +18,7 @@ export function createServerAction(name) {
 export function useServerAction(action, options = {}) {
   if (import.meta.env.SSR) {
     const { req, server } = useRouteContext()
-    req.route.actionData[action] = waitFetch(
-      `${server.serverURL}${action}`,
-      options,
-      req.fetchMap,
-    )
+    req.route.actionData[action] = waitFetch(`${server.serverURL}${action}`, options, req.fetchMap)
     return req.route.actionData[action]
   }
   const { actionData } = useRouteContext()
@@ -43,9 +39,7 @@ export function AppRoute({ ctxHydration, ctx, children }) {
         value={{
           ...ctx,
           ...ctxHydration,
-          state: isServer
-            ? ctxHydration.state ?? {}
-            : proxy(ctxHydration.state ?? {}),
+          state: isServer ? (ctxHydration.state ?? {}) : proxy(ctxHydration.state ?? {}),
         }}
       >
         <Layout>{children}</Layout>
@@ -72,7 +66,6 @@ export function AppRoute({ ctxHydration, ctx, children }) {
 
   // When the next route renders client-side,
   // force it to execute all URMA hooks again
-  // biome-ignore lint/correctness/useExhaustiveDependencies: I'm inclined to believe you, Biome, but I'm not risking it.
   useEffect(() => {
     window.route.firstRender = false
     window.route.actionData = {}
@@ -125,9 +118,7 @@ export function AppRoute({ ctxHydration, ctx, children }) {
       value={{
         ...ctxHydration,
         ...ctx,
-        state: isServer
-          ? ctxHydration.state ?? {}
-          : proxy(ctxHydration.state ?? {}),
+        state: isServer ? (ctxHydration.state ?? {}) : proxy(ctxHydration.state ?? {}),
       }}
     >
       <Layout>{children}</Layout>

package/virtual/create.jsx

@@ -1,16 +1,10 @@
-import { 
-  UnheadProvider as ClientUnheadProvider 
-} from '@unhead/react/client'
-import { 
-  UnheadProvider as ServerUnheadProvider 
-} from '@unhead/react/server?server'
+import { UnheadProvider as ClientUnheadProvider } from '@unhead/react/client'
+import { UnheadProvider as ServerUnheadProvider } from '@unhead/react/server?server'
 
 import Root from '$app/root.jsx'
 
 export default function create({ url, ...serverInit }) {
-  const UnheadProvider = import.meta.env.SSR
-    ? ServerUnheadProvider
-    : ClientUnheadProvider
+  const UnheadProvider = import.meta.env.SSR ? ServerUnheadProvider : ClientUnheadProvider
   return (
     <UnheadProvider value={serverInit.ctxHydration.useHead}>
       <Root url={url} {...serverInit} />

package/virtual/layouts.js

@@ -4,11 +4,7 @@ const DefaultLayout = () => import('$app/layouts/default.jsx')
 
 const appLayouts = import.meta.glob('/layouts/*.{jsx,tsx}')
 
-if (
-  !Object.keys(appLayouts).some((path) =>
-    path.match(/\/layouts\/default\.(j|t)sx/),
-  )
-) {
+if (!Object.keys(appLayouts).some((path) => path.match(/\/layouts\/default\.(j|t)sx/))) {
   appLayouts['/layouts/default.jsx'] = DefaultLayout
 }
 

package/virtual/mount.js

@@ -5,12 +5,10 @@ import routes from '$app/routes.js'
 import create from '$app/create.jsx'
 import * as context from '$app/context.js'
 
-async function mountApp (...targets) {
+async function mountApp(...targets) {
   const ctxHydration = await extendContext(window.route, context)
   const resolvedRoutes = await hydrateRoutes(routes)
-  const routeMap = Object.fromEntries(
-    resolvedRoutes.map((route) => [route.path, route]),
-  )
+  const routeMap = Object.fromEntries(resolvedRoutes.map((route) => [route.path, route]))
   const useHead = createHead()
   ctxHydration.useHead = useHead
   ctxHydration.useHead.push(window.route.head)
@@ -21,7 +19,6 @@ async function mountApp (...targets) {
     routeMap,
   })
 
-
   let mountTargetFound = false
   for (const target of targets) {
     const targetElem = document.querySelector(target)
@@ -42,14 +39,17 @@ async function mountApp (...targets) {
 
 mountApp('#root', 'main')
 
-async function extendContext (ctx, {
-  // The route context initialization function
-  default: setter,
-  // We destructure state here just to discard it from extra
-  state,
-  // Other named exports from context.js
-  ...extra
-}) {
+async function extendContext(
+  ctx,
+  {
+    // The route context initialization function
+    default: setter,
+    // We destructure state here just to discard it from extra
+    state,
+    // Other named exports from context.js
+    ...extra
+  },
+) {
   Object.assign(ctx, extra)
   if (setter) {
     await setter(ctx)

package/virtual/resource.js

@@ -1,12 +1,7 @@
 const clientFetchMap = new Map()
 const clientResourceMap = new Map()
 
-export function waitResource(
-  path,
-  id,
-  promise,
-  resourceMap = clientResourceMap,
-) {
+export function waitResource(path, id, promise, resourceMap = clientResourceMap) {
   const resourceId = `${path}:${id}`
   const loaderStatus = resourceMap.get(resourceId)
   if (loaderStatus) {

package/virtual/root.jsx

@@ -12,11 +12,7 @@ export default function Root({ url, routes, head, ctxHydration, routeMap }) {
               key={path}
               path={path}
               element={
-                <AppRoute
-                  head={head}
-                  ctxHydration={ctxHydration}
-                  ctx={routeMap[path]}
-                >
+                <AppRoute head={head} ctxHydration={ctxHydration} ctx={routeMap[path]}>
                   <Component />
                 </AppRoute>
               }

package/virtual-ts/core.tsx

@@ -18,11 +18,7 @@ export function createServerAction(name) {
 export function useServerAction(action, options = {}) {
   if (import.meta.env.SSR) {
     const { req, server } = useRouteContext()
-    req.route.actionData[action] = waitFetch(
-      `${server.serverURL}${action}`,
-      options,
-      req.fetchMap,
-    )
+    req.route.actionData[action] = waitFetch(`${server.serverURL}${action}`, options, req.fetchMap)
     return req.route.actionData[action]
   }
   const { actionData } = useRouteContext()
@@ -43,9 +39,7 @@ export function AppRoute({ ctxHydration, ctx, children }) {
         value={{
           ...ctx,
           ...ctxHydration,
-          state: isServer
-            ? ctxHydration.state ?? {}
-            : proxy(ctxHydration.state ?? {}),
+          state: isServer ? (ctxHydration.state ?? {}) : proxy(ctxHydration.state ?? {}),
         }}
       >
         <Layout>{children}</Layout>
@@ -72,7 +66,6 @@ export function AppRoute({ ctxHydration, ctx, children }) {
 
   // When the next route renders client-side,
   // force it to execute all URMA hooks again
-  // biome-ignore lint/correctness/useExhaustiveDependencies: I'm inclined to believe you, Biome, but I'm not risking it.
   useEffect(() => {
     window.route.firstRender = false
     window.route.actionData = {}
@@ -125,9 +118,7 @@ export function AppRoute({ ctxHydration, ctx, children }) {
       value={{
         ...ctxHydration,
         ...ctx,
-        state: isServer
-          ? ctxHydration.state ?? {}
-          : proxy(ctxHydration.state ?? {}),
+        state: isServer ? (ctxHydration.state ?? {}) : proxy(ctxHydration.state ?? {}),
       }}
     >
       <Layout>{children}</Layout>

package/virtual-ts/create.tsx

@@ -1,16 +1,10 @@
-import { 
-  UnheadProvider as ClientUnheadProvider 
-} from '@unhead/react/client'
-import { 
-  UnheadProvider as ServerUnheadProvider 
-} from '@unhead/react/server?server'
+import { UnheadProvider as ClientUnheadProvider } from '@unhead/react/client'
+import { UnheadProvider as ServerUnheadProvider } from '@unhead/react/server?server'
 
 import Root from '$app/root.jsx'
 
 export default function create({ url, ...serverInit }) {
-  const UnheadProvider = import.meta.env.SSR
-    ? ServerUnheadProvider
-    : ClientUnheadProvider
+  const UnheadProvider = import.meta.env.SSR ? ServerUnheadProvider : ClientUnheadProvider
   return (
     <UnheadProvider value={serverInit.ctxHydration.useHead}>
       <Root url={url} {...serverInit} />

package/virtual-ts/layouts.ts

@@ -4,11 +4,7 @@ const DefaultLayout = () => import('$app/layouts/default.tsx')
 
 const appLayouts = import.meta.glob('/layouts/*.{jsx,tsx}')
 
-if (
-  !Object.keys(appLayouts).some((path) =>
-    path.match(/\/layouts\/default\.(j|t)sx/),
-  )
-) {
+if (!Object.keys(appLayouts).some((path) => path.match(/\/layouts\/default\.(j|t)sx/))) {
   appLayouts['/layouts/default.tsx'] = DefaultLayout
 }
 

package/virtual-ts/mount.ts

@@ -5,12 +5,10 @@ import routes from '$app/routes.js'
 import create from '$app/create.jsx'
 import * as context from '$app/context.js'
 
-async function mountApp (...targets) {
+async function mountApp(...targets) {
   const ctxHydration = await extendContext(window.route, context)
   const resolvedRoutes = await hydrateRoutes(routes)
-  const routeMap = Object.fromEntries(
-    resolvedRoutes.map((route) => [route.path, route]),
-  )
+  const routeMap = Object.fromEntries(resolvedRoutes.map((route) => [route.path, route]))
   const useHead = createHead()
   ctxHydration.useHead = useHead
   ctxHydration.useHead.push(window.route.head)
@@ -21,7 +19,6 @@ async function mountApp (...targets) {
     routeMap,
   })
 
-
   let mountTargetFound = false
   for (const target of targets) {
     const targetElem = document.querySelector(target)
@@ -42,14 +39,17 @@ async function mountApp (...targets) {
 
 mountApp('#root', 'main')
 
-async function extendContext (ctx, {
-  // The route context initialization function
-  default: setter,
-  // We destructure state here just to discard it from extra
-  state,
-  // Other named exports from context.js
-  ...extra
-}) {
+async function extendContext(
+  ctx,
+  {
+    // The route context initialization function
+    default: setter,
+    // We destructure state here just to discard it from extra
+    state,
+    // Other named exports from context.js
+    ...extra
+  },
+) {
   Object.assign(ctx, extra)
   if (setter) {
     await setter(ctx)

package/virtual-ts/resource.ts

@@ -1,12 +1,7 @@
 const clientFetchMap = new Map()
 const clientResourceMap = new Map()
 
-export function waitResource(
-  path,
-  id,
-  promise,
-  resourceMap = clientResourceMap,
-) {
+export function waitResource(path, id, promise, resourceMap = clientResourceMap) {
   const resourceId = `${path}:${id}`
   const loaderStatus = resourceMap.get(resourceId)
   if (loaderStatus) {

package/virtual-ts/root.tsx

@@ -12,11 +12,7 @@ export default function Root({ url, routes, head, ctxHydration, routeMap }) {
               key={path}
               path={path}
               element={
-                <AppRoute
-                  head={head}
-                  ctxHydration={ctxHydration}
-                  ctx={routeMap[path]}
-                >
+                <AppRoute head={head} ctxHydration={ctxHydration} ctx={routeMap[path]}>
                   <Component />
                 </AppRoute>
               }