one 1.10.1 → 1.10.3

package/src/daemon/tui.ts

@@ -52,6 +52,14 @@ interface TUIState {
   popup: { message: string; timeout: NodeJS.Timeout } | null
 }
 
+const CABLE_COLORS = [
+  colors.green,
+  colors.cyan,
+  colors.magenta,
+  colors.blue,
+  colors.yellow,
+]
+
 const ESC = '\x1b'
 const CSI = `${ESC}[`
 
@@ -447,8 +455,6 @@ async function refreshData(): Promise<void> {
   tuiState.simulators = newSims
   tuiState.servers = newServers
 
-  const isDragging = tuiState.draggingSimIndex !== null
-
   // get actual simulator -> server mappings from routing state
   const simMappings = getSimulatorMappings()
 
@@ -558,15 +564,7 @@ function render(): void {
       const isSelected = tuiState.selectedCol === 0 && tuiState.selectedRow === row
       const cable = tuiState.cables.get(row)
       const hasConnection = cable?.serverIndex !== null
-      // unique color per cable
-      const cableColors = [
-        colors.green,
-        colors.cyan,
-        colors.magenta,
-        colors.blue,
-        colors.yellow,
-      ]
-      const cableColor = cableColors[row % cableColors.length]
+      const cableColor = CABLE_COLORS[row % CABLE_COLORS.length]
       const plug = hasConnection ? cableColor('●') : colors.dim('○')
       const name = truncate(sim.name, simEndX - 5)
       simText = `${name} ${plug}`
@@ -591,18 +589,10 @@ function render(): void {
     let srvRight = ''
     if (server) {
       const isSelected = tuiState.selectedCol === 1 && tuiState.selectedRow === row
-      // check which cables are connected to this server and get their colors
-      const cableColors = [
-        colors.green,
-        colors.cyan,
-        colors.magenta,
-        colors.blue,
-        colors.yellow,
-      ]
       let connectedColor: ((s: string) => string) | null = null
       for (const [simIndex, cable] of tuiState.cables) {
         if (cable.serverIndex === row) {
-          connectedColor = cableColors[simIndex % cableColors.length]
+          connectedColor = CABLE_COLORS[simIndex % CABLE_COLORS.length]
           break
         }
       }
@@ -695,15 +685,7 @@ function getCableCharAt(x: number, y: number): string | null {
 
       if (px === x && py === y) {
         const connected = cable.serverIndex !== null
-        // unique color per cable based on sim index
-        const cableColors = [
-          colors.green,
-          colors.cyan,
-          colors.magenta,
-          colors.blue,
-          colors.yellow,
-        ]
-        const baseColor = cableColors[simIndex % cableColors.length]
+        const baseColor = CABLE_COLORS[simIndex % CABLE_COLORS.length]
         const color = connected ? baseColor : colors.dim
 
         // determine character based on curve direction

package/src/router/getRoutes.ts

@@ -536,7 +536,7 @@ function getFileMeta(
   const isLayout = filenameWithoutExtensions.startsWith('_layout')
   const isMiddleware = filenameWithoutExtensions.startsWith('_middleware')
 
-  const [_fullname, renderModeFound] =
+  const [, renderModeFound] =
     filename.match(/\+(api|ssg|ssr|spa)\.(\w+\.)?[jt]sx?$/) || []
   const fileRenderMode = renderModeFound as 'api' | One.RouteRenderMode | undefined
 
@@ -656,6 +656,7 @@ function getFileMeta(
 }
 
 function getMostSpecific(routes: RouteNode[]) {
+  // holey array: .length includes holes, so last element is most specific
   const route = routes[routes.length - 1]
 
   if (!routes[0]) {
@@ -664,9 +665,7 @@ function getMostSpecific(routes: RouteNode[]) {
     )
   }
 
-  // This works even tho routes is holey array (e.g it might have index 0 and 2 but not 1)
-  // `.length` includes the holes in its count
-  return routes[routes.length - 1]
+  return route
 }
 
 export function getIgnoreList(options?: Options) {

package/src/router/interceptRoutes.ts

@@ -27,10 +27,6 @@ export function isHardNavigation(): boolean {
   return navigationMode === 'hard'
 }
 
-export function isSoftNavigation(): boolean {
-  return navigationMode === 'soft'
-}
-
 // ============================================
 // Intercept Route Matching
 // ============================================
@@ -241,8 +237,7 @@ function findMatchingInterceptInSlot(
     const resolvedTargetPath = resolveInterceptTargetPath(
       interceptTargetPath,
       levels,
-      layoutNode,
-      currentPath
+      layoutNode
     )
 
     // Try to match the target path against the resolved intercept path
@@ -273,24 +268,11 @@ function findMatchingInterceptInSlot(
 function resolveInterceptTargetPath(
   interceptTargetPath: string,
   levels: number,
-  layoutNode: RouteNode,
-  currentPath: string
+  layoutNode: RouteNode
 ): string {
-  // Get the base path for resolution
-  // contextKey is like './app/_layout.tsx' or './_layout.tsx'
-  // We need to extract just the route path portion
-  let layoutPath = layoutNode.contextKey
-    .replace(/^\.\//, '') // Remove leading ./
-    .replace(/\/?_layout.*$/, '') // Remove _layout and extension (with optional leading /)
-    .replace(/^app\/?/, '') // Remove 'app/' prefix since routes are relative to app dir
-
-  // Strip route groups like (app), (tabs) since they don't appear in URLs
-  layoutPath = stripGroupSegmentsFromPath(layoutPath)
-
-  // Normalize: empty string or '/' means root
-  if (!layoutPath || layoutPath === '/') {
-    layoutPath = ''
-  }
+  // reuse getLayoutPath and strip leading slash for internal resolution
+  const fullLayoutPath = getLayoutPath(layoutNode)
+  let layoutPath = fullLayoutPath === '/' ? '' : fullLayoutPath.slice(1)
 
   if (levels === Infinity) {
     // (...) matches from root - target path is absolute
@@ -468,13 +450,6 @@ export function isReturningFromIntercept(): boolean {
   return returningFromIntercept
 }
 
-// Store intercept state info for forward navigation restoration
-interface StoredInterceptState {
-  slotName: string
-  routeContextKey: string
-  params: Record<string, string>
-}
-
 // Callback to set slot state - set from Navigator.tsx to avoid circular deps
 let setSlotStateCallback:
   | ((

package/src/router/router.ts

@@ -475,7 +475,6 @@ export function subscribeToStore(subscriber: () => void) {
   }
 }
 
-// Subscription functions
 export function subscribeToLoadingState(subscriber: OneRouter.LoadingStateListener) {
   loadingStateSubscribers.add(subscriber)
   return () => {
@@ -1163,8 +1162,6 @@ export async function linkTo(
       }, 1000)
     }
   })
-
-  return
 }
 
 const hashes: Record<string, string> = {}

package/src/server/oneServe.ts

@@ -22,6 +22,19 @@ import { getFetchStaticHtml } from './staticHtmlFetcher'
 
 const debugRouter = process.env.ONE_DEBUG_ROUTER
 
+async function readStaticHtml(htmlPath: string): Promise<string | null> {
+  const fetchStaticHtml = getFetchStaticHtml()
+  if (fetchStaticHtml) {
+    const html = await fetchStaticHtml(htmlPath)
+    if (html) return html
+  }
+  try {
+    return await readFile(join('dist/client', htmlPath), 'utf-8')
+  } catch {
+    return null
+  }
+}
+
 /**
  * Lazy import functions for route modules.
  * Modules are loaded on-demand when a route is matched, not all upfront.
@@ -102,6 +115,43 @@ export async function oneServe(
 
   const apiCJS = oneOptions.build?.api?.outputFormat === 'cjs'
 
+  // shared helper to import a route module and run its loader
+  async function importAndRunLoader(
+    routeId: string,
+    serverPath: string | undefined,
+    lazyKey: string | undefined,
+    loaderProps: any
+  ): Promise<{ loaderData: unknown; routeId: string; isEnoent?: boolean }> {
+    if (!serverPath && !lazyKey) {
+      return { loaderData: undefined, routeId }
+    }
+
+    try {
+      const pathToResolve = serverPath || lazyKey || ''
+      const resolvedPath = pathToResolve.includes('dist/server')
+        ? pathToResolve
+        : join('./', 'dist/server', pathToResolve)
+
+      const routeExported = lazyKey
+        ? options?.lazyRoutes?.pages?.[lazyKey]
+          ? await options.lazyRoutes.pages[lazyKey]()
+          : await import(toAbsolute(resolvedPath))
+        : await import(toAbsolute(serverPath!))
+
+      const loaderData = await routeExported?.loader?.(loaderProps)
+      return { loaderData, routeId }
+    } catch (err) {
+      if (isResponse(err)) {
+        throw err
+      }
+      if ((err as any)?.code === 'ENOENT') {
+        return { loaderData: undefined, routeId, isEnoent: true }
+      }
+      console.error(`[one] Error running loader for ${routeId}:`, err)
+      return { loaderData: undefined, routeId }
+    }
+  }
+
   // Lazy load server entry only when needed for SSR
   let render: ((props: RenderAppProps) => any) | null = null
   async function getRender() {
@@ -211,57 +261,24 @@ export async function oneServe(
         }
 
         try {
-          // helper to import and run a single loader
-          async function runLoader(
-            routeId: string,
-            serverPath: string | undefined,
-            lazyKey?: string
-          ): Promise<{ loaderData: unknown; routeId: string; isEnoent?: boolean }> {
-            if (!serverPath && !lazyKey) {
-              return { loaderData: undefined, routeId }
-            }
-
-            try {
-              // serverPath may already include dist/server if it came from buildInfo.serverJsPath
-              const pathToResolve = serverPath || lazyKey || ''
-              const resolvedPath = pathToResolve.includes('dist/server')
-                ? pathToResolve
-                : join('./', 'dist/server', pathToResolve)
-
-              const routeExported = lazyKey
-                ? options?.lazyRoutes?.pages?.[lazyKey]
-                  ? await options.lazyRoutes.pages[lazyKey]()
-                  : await import(toAbsolute(resolvedPath))
-                : await import(toAbsolute(serverPath!))
-
-              const loaderData = await routeExported?.loader?.(loaderProps)
-              return { loaderData, routeId }
-            } catch (err) {
-              // if a loader throws a Response (redirect), re-throw it
-              if (isResponse(err)) {
-                throw err
-              }
-              if ((err as any)?.code === 'ENOENT') {
-                return { loaderData: undefined, routeId, isEnoent: true }
-              }
-              console.error(`[one] Error running loader for ${routeId}:`, err)
-              return { loaderData: undefined, routeId }
-            }
-          }
-
           // collect layout loaders to run in parallel
           const layoutRoutes = route.layouts || []
           const layoutLoaderPromises = layoutRoutes.map((layout: any) => {
-            // layouts may have loaderServerPath set from build, or we can try contextKey
             const serverPath = layout.loaderServerPath || layout.contextKey
-            return runLoader(layout.contextKey, serverPath, layout.contextKey)
+            return importAndRunLoader(
+              layout.contextKey,
+              serverPath,
+              layout.contextKey,
+              loaderProps
+            )
           })
 
           // run page loader
-          const pageLoaderPromise = runLoader(
+          const pageLoaderPromise = importAndRunLoader(
             route.file,
             buildInfo.serverJsPath,
-            route.file
+            route.file,
+            loaderProps
           )
 
           // wait for all loaders in parallel
@@ -375,43 +392,16 @@ url: ${url}`)
 
         if (needsSpaShell) {
           try {
-            // helper to import and run a single loader
-            async function runShellLoader(
-              routeId: string,
-              serverPath: string | undefined,
-              lazyKey?: string
-            ): Promise<{ loaderData: unknown; routeId: string }> {
-              if (!serverPath && !lazyKey) {
-                return { loaderData: undefined, routeId }
-              }
-              try {
-                const pathToResolve = serverPath || lazyKey || ''
-                const resolvedPath = pathToResolve.includes('dist/server')
-                  ? pathToResolve
-                  : join('./', 'dist/server', pathToResolve)
-
-                const routeExported = lazyKey
-                  ? options?.lazyRoutes?.pages?.[lazyKey]
-                    ? await options.lazyRoutes.pages[lazyKey]()
-                    : await import(toAbsolute(resolvedPath))
-                  : await import(toAbsolute(serverPath!))
-
-                const loaderData = await routeExported?.loader?.(loaderProps)
-                return { loaderData, routeId }
-              } catch (err) {
-                if (isResponse(err)) {
-                  throw err
-                }
-                console.error(`[one] Error running shell loader for ${routeId}:`, err)
-                return { loaderData: undefined, routeId }
-              }
-            }
-
             // run layout loaders only (page content is client-rendered)
             const layoutResults = await Promise.all(
               layoutRoutes.map((layout: any) => {
                 const serverPath = layout.loaderServerPath || layout.contextKey
-                return runShellLoader(layout.contextKey, serverPath, layout.contextKey)
+                return importAndRunLoader(
+                  layout.contextKey,
+                  serverPath,
+                  layout.contextKey,
+                  loaderProps
+                )
               })
             )
 
@@ -477,22 +467,7 @@ url: ${url}`)
             : routeMap[url.pathname] || routeMap[buildInfo?.cleanPath]
 
         if (htmlPath) {
-          // Try Worker ASSETS binding first (for Cloudflare Workers), fall back to filesystem
-          const fetchStaticHtml = getFetchStaticHtml()
-          let html: string | null = null
-
-          if (fetchStaticHtml) {
-            html = await fetchStaticHtml(htmlPath)
-          }
-
-          if (!html) {
-            // Fall back to filesystem (Node.js)
-            try {
-              html = await readFile(join('dist/client', htmlPath), 'utf-8')
-            } catch {
-              // File not found
-            }
-          }
+          const html = await readStaticHtml(htmlPath)
 
           if (html) {
             const headers = new Headers()
@@ -511,23 +486,7 @@ url: ${url}`)
           const notFoundHtmlPath = routeMap[notFoundRoute]
 
           if (notFoundHtmlPath) {
-            const fetchStaticHtml = getFetchStaticHtml()
-            let notFoundHtml: string | null = null
-
-            if (fetchStaticHtml) {
-              notFoundHtml = await fetchStaticHtml(notFoundHtmlPath)
-            }
-
-            if (!notFoundHtml) {
-              try {
-                notFoundHtml = await readFile(
-                  join('dist/client', notFoundHtmlPath),
-                  'utf-8'
-                )
-              } catch {
-                // File not found
-              }
-            }
+            const notFoundHtml = await readStaticHtml(notFoundHtmlPath)
 
             if (notFoundHtml) {
               // inject 404 marker so client knows this is a 404 response

package/src/useLoader.ts

@@ -398,8 +398,7 @@ export function useLoaderState<
   if (
     !loaderStateEntry.data &&
     !loaderStateEntry.promise &&
-    !loaderStateEntry.hasLoadedOnce &&
-    loader
+    !loaderStateEntry.hasLoadedOnce
   ) {
     // check for already-resolved preloaded data first (synchronous)
     // use != null to also exclude null values (which indicate preload failures)
@@ -641,33 +640,24 @@ export function useLoaderState<
     }
   }
 
-  // handle errors and suspension
-  if (loader) {
-    // only throw error on initial load
-    if (loaderStateEntry.error && !loaderStateEntry.hasLoadedOnce) {
-      throw loaderStateEntry.error
-    }
-
-    // only throw promise for suspension on initial load
-    if (
-      loaderStateEntry.data === undefined &&
-      loaderStateEntry.promise &&
-      !loaderStateEntry.hasLoadedOnce
-    ) {
-      throw loaderStateEntry.promise
-    }
+  // handle errors and suspension (only on initial load)
+  if (loaderStateEntry.error && !loaderStateEntry.hasLoadedOnce) {
+    throw loaderStateEntry.error
+  }
 
-    return {
-      data: loaderStateEntry.data,
-      refetch,
-      state: loaderStateEntry.state,
-    } as any
-  } else {
-    return {
-      refetch,
-      state: loaderStateEntry.state,
-    } as any
+  if (
+    loaderStateEntry.data === undefined &&
+    loaderStateEntry.promise &&
+    !loaderStateEntry.hasLoadedOnce
+  ) {
+    throw loaderStateEntry.promise
   }
+
+  return {
+    data: loaderStateEntry.data,
+    refetch,
+    state: loaderStateEntry.state,
+  } as any
 }
 
 /**

package/src/utils/redirect.ts

@@ -6,7 +6,7 @@ export const redirect = (
   path: '__branded__' extends keyof OneRouter.Href ? string : OneRouter.Href,
   status?: number
 ) => {
-  if (process.env.VITE_ENVIRONMENT === 'client') {
+  if (process.env.VITE_ENVIRONMENT !== 'ssr') {
     router.navigate(path)
     return
   }

package/src/views/Navigator.tsx

@@ -240,9 +240,7 @@ export function useSlot() {
     return null
   }
 
-  const current = state.routes.find((route, i) => {
-    return state.index === i
-  })
+  const current = state.routes[state.index]
 
   if (!current) {
     return null

package/src/vite/one.ts

@@ -7,7 +7,7 @@ import {
 } from '@vxrn/vite-plugin-metro'
 import events from 'node:events'
 import path from 'node:path'
-import { mergeConfig, type Plugin, type PluginOption } from 'vite'
+import { type Plugin, type PluginOption } from 'vite'
 import tsconfigPaths from 'vite-tsconfig-paths'
 import { autoDepOptimizePlugin, getOptionsFilled, loadEnv } from 'vxrn'
 import vxrnVitePlugin from 'vxrn/vite-plugin'
@@ -252,8 +252,6 @@ export function one(options: One.PluginOptions = {}): PluginOption {
       enforce: 'pre',
 
       config() {
-        // const forkPath = dirname(resolvePath('one'))
-
         let tslibLitePath = ''
 
         try {
@@ -279,22 +277,6 @@ export function one(options: One.PluginOptions = {}): PluginOption {
                 tslib: tslibLitePath,
               }),
             },
-
-            // [
-            //   {
-            //     find: /tslib/,
-            //     replacement: resolvePath('@vxrn/tslib-lite'),
-            //   },
-            //   // not working but would save ~30Kb stat
-            //   // {
-            //   //   find: /@react-navigation\/core.*\/getStateFromPath/,
-            //   //   replacement: join(forkPath, 'fork', 'getStateFromPath.mjs'),
-            //   // },
-            //   // {
-            //   //   find: /@react-navigation\/core.*\/getPathFromState/,
-            //   //   replacement: join(forkPath, 'fork', 'getPathFromState.mjs'),
-            //   // },
-            // ],
           },
         }
       },
@@ -526,88 +508,8 @@ export function one(options: One.PluginOptions = {}): PluginOption {
     },
   ] satisfies Plugin[]
 
-  // leaving this as a good example of an option that loads a library conditionally
-  // // react scan
-  // const scan = options.react?.scan
-
-  // const reactScanPlugin = {
-  //   name: `one:react-scan`,
-  //   config() {
-  //     return reactScanConfig
-  //   },
-  // }
-  // devAndProdPlugins.push(reactScanPlugin)
-
-  // // do it here because it gets called a few times
-  // const reactScanConfig = ((): UserConfig => {
-  //   const stringify = (obj: Object) => JSON.stringify(JSON.stringify(obj))
-
-  //   const configs = {
-  //     disabled: {
-  //       define: {
-  //         'process.env.ONE_ENABLE_REACT_SCAN': '""',
-  //       },
-  //     },
-  //     enabled: {
-  //       define: {
-  //         'process.env.ONE_ENABLE_REACT_SCAN': stringify({
-  //           enabled: true,
-  //           animationSpeed: 'slow',
-  //           showToolbar: false,
-  //         }),
-  //       },
-  //     },
-  //   } satisfies Record<string, UserConfig>
-
-  //   const getConfigFor = (platform: 'ios' | 'android' | 'client'): UserConfig => {
-  //     if (process.env.NODE_ENV === 'production') {
-  //       return configs.disabled
-  //     }
-  //     if (!scan) {
-  //       return configs.disabled
-  //     }
-  //     if (scan === true) {
-  //       return configs.enabled
-  //     }
-  //     if (typeof scan === 'string') {
-  //       if (scan === 'native' && platform === 'client') {
-  //         return configs.disabled
-  //       }
-  //       if (scan === 'web' && platform !== 'client') {
-  //         return configs.disabled
-  //       }
-  //       return configs.enabled
-  //     }
-
-  //     const defaultConfig = scan.options || configs.enabled
-  //     const perPlatformConfig =
-  //       platform === 'ios' || platform === 'android' ? scan.native : scan.web
-
-  //     return {
-  //       define: {
-  //         'process.env.ONE_ENABLE_REACT_SCAN': stringify({
-  //           ...defaultConfig,
-  //           ...perPlatformConfig,
-  //         }),
-  //       },
-  //     }
-  //   }
-
-  //   return {
-  //     environments: {
-  //       client: getConfigFor('client'),
-  //       ios: getConfigFor('ios'),
-  //       android: getConfigFor('android'),
-  //     },
-  //   }
-  // })()
-
   // TODO move to single config and through environments
-  const nativeWebDevAndProdPlugsin: Plugin[] = [
-    clientTreeShakePlugin(),
-    //
-    // reactScanPlugin
-  ]
+  const nativeWebDevAndProdPlugsin: Plugin[] = [clientTreeShakePlugin()]
 
   // TODO make this passed into vxrn through real API
   globalThis.__vxrnAddNativePlugins = nativeWebDevAndProdPlugsin