one 1.8.2 → 1.8.3

package/src/utils/getPageExport.ts

@@ -0,0 +1,33 @@
+const getPageLikeExports = (x: string) => x !== 'loader' && x[0].toUpperCase() === x[0]
+
+export const getPageExport = (exported: Record<string, any>) => {
+  return (
+    exported.default ||
+    // because HMR fails with default exports, allow exporting something else
+    // we just find the first non-loader export for now...
+    (() => {
+      const keys = Object.keys(exported)
+
+      if (process.env.NODE_ENV === 'development') {
+        const upperCaseExports = keys.filter(getPageLikeExports)
+        if (upperCaseExports.length > 1) {
+          console.warn(`Warning: You've exported more than one uppercase non-default export.
+
+If there is no default export, One uses the first capitalized non-default export.
+This is because React Refresh, the hot reloading library, does not work on default
+exports, so you may prefer to use non-default exports. But exporting multiple can
+cause issues, as browser clients and server runtimes may not sort the export keys
+the same.
+
+Be sure to only export a single capitalized non-default export per-route.
+            `)
+        }
+      }
+
+      const nonLoader = keys.find(getPageLikeExports)
+      if (nonLoader) {
+        return exported[nonLoader]
+      }
+    })()
+  )
+}

package/src/utils/getPathnameFromFilePath.ts

@@ -0,0 +1,68 @@
+import Path from 'node:path'
+
+export function getPathnameFromFilePath(
+  inputPath: string,
+  params = {},
+  strict = false,
+  options: { preserveExtensions?: boolean; includeIndex?: boolean } = {}
+) {
+  const path = inputPath.replace(/\+(spa|ssg|ssr|api)\.tsx?$/, '')
+  // remove groups, folder render mode suffixes, and convert [param] to :param in dirname
+  const dirname = Path.dirname(path)
+    .split('/')
+    .map((segment) => segment.replace(/\+(api|ssg|ssr|spa)$/, ''))
+    .join('/')
+    .replace(/\([^/]+\)/gi, '')
+    .replace(/\[([^\]]+)\]/g, ':$1')
+  const file = Path.basename(path)
+  const fileName = options.preserveExtensions ? file : file.replace(/\.[a-z]+$/, '')
+
+  function paramsError(part: string) {
+    throw new Error(
+      `[one] Params doesn't fit route:
+
+      - path: ${path}
+      - part: ${part}
+      - fileName: ${fileName}
+      - params:
+
+${JSON.stringify(params, null, 2)}`
+    )
+  }
+
+  const nameWithParams = (() => {
+    if (fileName === 'index' && !options.includeIndex) {
+      return '/'
+    }
+    if (fileName.startsWith('[...')) {
+      const part = fileName.replace('[...', '').replace(']', '')
+      if (!params[part]) {
+        if (strict) {
+          throw paramsError(part)
+        }
+        return `/*`
+      }
+      return `/${params[part]}`
+    }
+    return `/${fileName
+      .split('/')
+      .map((part) => {
+        if (part[0] === '[') {
+          const found = params[part.slice(1, part.length - 1)]
+          if (!found) {
+            if (strict) {
+              throw paramsError(part)
+            }
+
+            return ':' + part.replace('[', '').replace(']', '')
+          }
+          return found
+        }
+        return part
+      })
+      .join('/')}`
+  })()
+
+  // hono path will convert +not-found etc too
+  return `${dirname}${nameWithParams}`.replace(/\/\/+/gi, '/')
+}

package/src/utils/getRouterRootFromOneOptions.ts

@@ -0,0 +1,5 @@
+import type { One } from '../vite/types'
+
+export function getRouterRootFromOneOptions(options: One.PluginOptions) {
+  return options?.router?.root || process.env.ONE_ROUTER_ROOT || 'app'
+}

package/src/utils/globDir.ts

@@ -0,0 +1,13 @@
+import Glob from 'fast-glob'
+
+// Used to emulate a context module, but way faster. TODO: May need to adjust the extensions to stay in sync with Metro.
+export function globDir(cwd: string) {
+  return Glob.sync('**/*.@(ts|tsx|js|jsx)', {
+    cwd,
+    dot: true,
+  }).map((p) => './' + normalizePaths(p))
+}
+
+function normalizePaths(p: string) {
+  return p.replace(/\\/g, '/')
+}

package/src/utils/hashString.ts

@@ -0,0 +1,5 @@
+import xxh from 'xxhashjs'
+
+export function hashString(str: string): string {
+  return xxh.h64(0).update(str).digest().toString(36)
+}

package/src/utils/htmlEscape.ts

@@ -0,0 +1,35 @@
+// Based on https://github.com/zertosh/htmlescape
+// Prevents XSS when embedding JSON in <script> tags
+// See: https://pragmaticwebsecurity.com/articles/spasecurity/json-stringify-xss.html
+
+const ESCAPE_LOOKUP: Record<string, string> = {
+  '\u0026': '\\u0026', // &
+  '\u003c': '\\u003c', // <
+  '\u003e': '\\u003e', // >
+  '\u2028': '\\u2028', // Line separator
+  '\u2029': '\\u2029', // Paragraph separator
+}
+
+const ESCAPE_REGEX = /[\u0026\u003c\u003e\u2028\u2029]/g
+
+/**
+ * Escapes a JSON string for safe embedding in HTML <script> tags.
+ *
+ * JSON.stringify doesn't escape characters like < and >, which means
+ * a string containing "</script>" can break out of a script tag and
+ * allow arbitrary code execution.
+ *
+ * This function escapes those characters as unicode escape sequences
+ * (e.g., < becomes \u003c) which are valid JSON but won't be parsed
+ * as HTML.
+ */
+export function htmlEscapeJsonString(str: string): string {
+  return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match])
+}
+
+/**
+ * Safely serializes a value to JSON for embedding in HTML <script> tags.
+ */
+export function safeJsonStringify(value: unknown): string {
+  return htmlEscapeJsonString(JSON.stringify(value))
+}

package/src/utils/isResponse.ts

@@ -0,0 +1,7 @@
+// for some reason instanceof isnt working reliably
+export function isResponse(res: any): res is Response {
+  return (
+    res instanceof Response ||
+    (typeof res.status === 'number' && 'body' in res && typeof res.ok === 'boolean')
+  )
+}

package/src/utils/isRolldown.ts

@@ -0,0 +1,17 @@
+let _isRolldown: boolean | undefined
+
+export async function isRolldown(): Promise<boolean> {
+  if (_isRolldown !== undefined) {
+    return _isRolldown
+  }
+
+  try {
+    const vite = await import('vite')
+    // withFilter only exists in rolldown-vite
+    _isRolldown = 'withFilter' in vite
+  } catch {
+    _isRolldown = false
+  }
+
+  return _isRolldown
+}

package/src/utils/isStatus.ts

@@ -0,0 +1,5 @@
+import type { RedirectStatusCode } from 'hono/utils/http-status'
+
+export function isStatusRedirect(status: number): status is RedirectStatusCode {
+  return status > 300 && status < 309
+}

package/src/utils/pLimit.ts

@@ -0,0 +1,40 @@
+/**
+ * Simple concurrency limiter for parallel async operations.
+ * Returns a function that wraps promises to limit concurrent execution.
+ *
+ * @param concurrency - Maximum number of concurrent operations
+ * @returns A function that takes a promise-returning function and queues it
+ *
+ * @example
+ * const limit = pLimit(4)
+ * const results = await Promise.all(
+ *   urls.map(url => limit(() => fetch(url)))
+ * )
+ */
+export function pLimit(concurrency: number) {
+  const queue: (() => void)[] = []
+  let active = 0
+
+  const next = () => {
+    if (active < concurrency && queue.length > 0) {
+      active++
+      const fn = queue.shift()!
+      fn()
+    }
+  }
+
+  return <T>(fn: () => Promise<T>): Promise<T> => {
+    return new Promise<T>((resolve, reject) => {
+      queue.push(() => {
+        fn()
+          .then(resolve)
+          .catch(reject)
+          .finally(() => {
+            active--
+            next()
+          })
+      })
+      next()
+    })
+  }
+}

package/src/utils/platform.ts

@@ -0,0 +1,5 @@
+// being a bit more thorough here because for some reason window as defined on native
+export const isWeb =
+  typeof window !== 'undefined' &&
+  typeof navigator !== 'undefined' &&
+  typeof document !== 'undefined'

package/src/utils/promiseWithResolvers.ts

@@ -0,0 +1,9 @@
+export function promiseWithResolvers<T>() {
+  let a
+  let b
+  const c = new Promise<T>((resolve, reject) => {
+    a = resolve
+    b = reject
+  })
+  return { resolve: a, reject: b, promise: c }
+}

package/src/utils/rand.ts

@@ -0,0 +1 @@
+export const rand = () => `${Math.round(Math.random() * 100_000_000)}`

package/src/utils/redirect.ts

@@ -0,0 +1,16 @@
+import { getURL } from '../getURL'
+import type { OneRouter } from '../interfaces/router'
+import { router } from '../router/imperative-api'
+
+export const redirect = (
+  path: '__branded__' extends keyof OneRouter.Href ? string : OneRouter.Href,
+  status?: number
+) => {
+  if (process.env.VITE_ENVIRONMENT === 'client') {
+    router.navigate(path)
+    return
+  }
+
+  const finalPath = path[0] === '/' ? `${getURL()}${path}` : path
+  return Response.redirect(finalPath as string, status)
+}

package/src/utils/removeSearch.ts

@@ -0,0 +1,5 @@
+export function removeSearch(url: string) {
+  return url
+    .replace(/#.*/, '') // remove hash
+    .replace(/\?.*/, '') // remove query params
+}

package/src/utils/removeUndefined.ts

@@ -0,0 +1,16 @@
+type RemoveUndefined<T> = {
+  [K in keyof T]: T[K] extends undefined ? never : T[K]
+}
+
+export function removeUndefined<T extends object>(obj: T): RemoveUndefined<T> {
+  const result = {} as RemoveUndefined<T>
+
+  for (const key in obj) {
+    if (obj[key] !== undefined) {
+      // @ts-expect-error
+      result[key] = obj[key] as RemoveUndefined<T>[keyof T]
+    }
+  }
+
+  return result
+}

package/src/utils/style.ts

@@ -0,0 +1,17 @@
+import type { TextStyle } from 'react-native'
+
+/**
+ * Convert numeric font weights to string format for React Navigation compatibility.
+ * React Navigation only accepts string font weights, not numbers.
+ */
+export function convertFontWeightToStringFontWeight(
+  fontWeight: TextStyle['fontWeight']
+): Exclude<TextStyle['fontWeight'], number> | undefined {
+  if (fontWeight === undefined) {
+    return undefined
+  }
+  if (typeof fontWeight === 'number') {
+    return String(fontWeight) as Exclude<TextStyle['fontWeight'], number>
+  }
+  return fontWeight
+}

package/src/utils/toAbsolute.ts

@@ -0,0 +1,3 @@
+import { resolve } from 'node:path'
+
+export const toAbsolute = (p: string) => resolve(process.cwd(), p)

package/src/utils/trackLoaderDependencies.ts

@@ -0,0 +1,53 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { _registerWatchFileImpl } from './watchFile'
+
+export type LoaderResult<T> = {
+  result: T
+  dependencies: Set<string>
+}
+
+const LOADER_DEPS_KEY = '__oneLoaderDepsContext'
+
+type LoaderDepsStore = {
+  deps: Set<string>
+}
+
+const LOADER_DEPS_STORE = {
+  get current(): AsyncLocalStorage<LoaderDepsStore> {
+    if (globalThis[LOADER_DEPS_KEY]) return globalThis[LOADER_DEPS_KEY]
+    const als = new AsyncLocalStorage<LoaderDepsStore>()
+    globalThis[LOADER_DEPS_KEY] = als
+    return als
+  },
+}
+
+const debugLoaderDeps = process.env.ONE_DEBUG_LOADER_DEPS
+
+function watchFileImpl(path: string): void {
+  const store = LOADER_DEPS_STORE.current.getStore()
+  if (store) {
+    store.deps.add(path)
+  }
+}
+
+_registerWatchFileImpl(watchFileImpl)
+
+export async function trackLoaderDependencies<T>(
+  fn: () => T | Promise<T>
+): Promise<LoaderResult<Awaited<T>>> {
+  const deps = new Set<string>()
+  const context = LOADER_DEPS_STORE.current
+
+  const result = await context.run({ deps }, async () => {
+    return await fn()
+  })
+
+  if (debugLoaderDeps && deps.size > 0) {
+    console.info('[loader-deps] tracked dependencies:', [...deps])
+  }
+
+  return {
+    result,
+    dependencies: deps,
+  }
+}

package/src/utils/url.ts

@@ -0,0 +1,21 @@
+/**
+ * Does the input string start with a valid URL scheme.
+ * NOTE: Additional strictness added to ensure URLs sent in query parameters for in-app navigation are not matched.
+ */
+export function hasUrlProtocolPrefix(href: string): boolean {
+  return /^[\w\d_+.-]+:\/\//.test(href)
+}
+
+export function isWellKnownUri(href: string): boolean {
+  // This is a hack and we should change this to work like the web in the future where we have full confidence in the
+  // ability to match URLs and send anything unmatched to the OS. The main difference between this and `hasUrlProtocolPrefix` is
+  // that we don't require `//`, e.g. `mailto:` is valid and common, and `mailto://bacon` is invalid.
+  return /^(https?|mailto|tel|sms|geo|maps|market|itmss?|itms-apps|content|file):/.test(
+    href
+  )
+}
+
+export function shouldLinkExternally(href: string): boolean {
+  // Cheap check first to avoid regex if the href is not a path fragment.
+  return !/^[./]/.test(href) && (hasUrlProtocolPrefix(href) || isWellKnownUri(href))
+}

package/src/utils/useConstant.ts

@@ -0,0 +1,18 @@
+import * as React from 'react'
+
+type ResultBox<T> = { v: T }
+
+export function useConstant<T>(fn: () => T): T {
+  // RSC compat
+  if (typeof document === 'undefined') {
+    return React.useMemo(() => fn(), [])
+  }
+
+  const ref = React.useRef<ResultBox<T> | undefined>(undefined)
+
+  if (!ref.current) {
+    ref.current = { v: fn() }
+  }
+
+  return ref.current.v
+}

package/src/utils/watchFile.ts

@@ -0,0 +1,19 @@
+const WATCH_FILE_KEY = '__oneWatchFile'
+
+/**
+ * Register a file dependency for loader HMR.
+ * No-op on client, registers file path for watching on server.
+ */
+export function watchFile(path: string): void {
+  if (typeof window !== 'undefined') return
+
+  const impl = globalThis[WATCH_FILE_KEY] as ((path: string) => void) | undefined
+  if (impl) {
+    impl(path)
+  }
+}
+
+/** @internal */
+export function _registerWatchFileImpl(impl: (path: string) => void): void {
+  globalThis[WATCH_FILE_KEY] = impl
+}

package/src/utils/weakKey.ts

@@ -0,0 +1,11 @@
+const w = new WeakMap<any, string>()
+export const weakKey = (item: any): string => {
+  return (
+    w.get(item) ??
+    (() => {
+      const k = `${Math.random()}`
+      w.set(item, k)
+      return k
+    })()
+  )
+}

package/src/utils/weakMemo.ts

@@ -0,0 +1,15 @@
+const cache = new WeakMap()
+
+export function weakMemoObject(obj: any) {
+  if (!cache.has(obj)) {
+    const memoizedObj = {}
+    for (const key of Object.keys(obj)) {
+      if (!cache.has(obj[key])) {
+        cache.set(obj[key], obj[key])
+      }
+      memoizedObj[key] = cache.get(obj[key])
+    }
+    cache.set(obj, memoizedObj)
+  }
+  return cache.get(obj)
+}

package/src/utils/withStaticProperties.ts

@@ -0,0 +1,32 @@
+import React from 'react'
+
+const Decorated = Symbol()
+
+type Combined<A, B> = A & B
+
+export const withStaticProperties = <A extends Function, B>(
+  component: A,
+  staticProps: B
+): Combined<A, B> => {
+  // clone component if already wrapped once
+  const next = (() => {
+    if (component[Decorated]) {
+      const _ = React.forwardRef((props, ref) =>
+        React.createElement(component as any, { ...props, ref })
+      )
+      // attach existing things again
+      for (const key in component) {
+        const v = component[key]
+        // @ts-expect-error
+        _[key] = v && typeof v === 'object' ? { ...v } : v
+      }
+    }
+    return component
+  })()
+
+  // add new things
+  Object.assign(next, staticProps)
+  next[Decorated] = true
+
+  return next as any as A & B
+}

package/src/utils/workerImport.ts

@@ -0,0 +1,39 @@
+/**
+ * Helper for importing modules in worker threads.
+ * Workers need .mjs extensions for proper ESM resolution.
+ *
+ * Usage: Pass the caller's import.meta.url to resolve relative paths correctly.
+ */
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+type ModuleCache = Map<string, any>
+const cache: ModuleCache = new Map()
+
+/**
+ * Import a module in a worker-safe way with caching.
+ * Automatically appends .mjs extension for proper ESM resolution in workers.
+ *
+ * @param relativePath - Path relative to the caller's file
+ * @param callerUrl - Pass import.meta.url from the calling file
+ */
+export async function workerImport<T = any>(
+  relativePath: string,
+  callerUrl: string
+): Promise<T> {
+  const callerDir = dirname(fileURLToPath(callerUrl))
+  const absolutePath = resolve(callerDir, relativePath)
+  const cacheKey = absolutePath
+
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey)
+  }
+
+  // ensure .mjs extension for worker thread ESM resolution
+  const mjsPath = absolutePath.endsWith('.mjs') ? absolutePath : `${absolutePath}.mjs`
+
+  // @ts-ignore - runtime needs .mjs extension for proper ESM resolution
+  const mod = await import(mjsPath)
+  cache.set(cacheKey, mod)
+  return mod
+}