one 1.1.4 → 1.1.269

package/src/vite/headers.ts

@@ -0,0 +1,39 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+
+export const requestAsyncLocalStore =
+  globalThis['__vxrnrequestAsyncLocalStore'] ?? new AsyncLocalStorage()
+
+export const asyncHeadersCache =
+  globalThis['__vxrnasyncHeadersCache'] ?? new WeakMap<any, Headers>()
+
+// NOTE: we have a big issue right now, we have "one" in optimizeDeps
+// because otherwise you get an error when Root imports Text/View from react-native
+// even though react-native is in optimizeDeps, it seems thats not working
+// but what happens is that somehow one is imported directly by node right away
+// and then later its imported through optimizeDeps, a seaprate instance, creating a separate requestAsyncLocalStore
+globalThis['__vxrnrequestAsyncLocalStore'] ||= requestAsyncLocalStore
+globalThis['__vxrnasyncHeadersCache'] ||= asyncHeadersCache
+
+// TODO move this to `RequestContext.setHeaders()`
+
+export async function setCurrentRequestHeaders(cb: (headers: Headers) => void) {
+  const id = requestAsyncLocalStore.getStore()
+
+  if (!id) {
+    throw new Error(`AsyncLocalStorage not working, no id!`)
+  }
+
+  const headers = asyncHeadersCache.get(id) ?? new Headers()
+  asyncHeadersCache.set(id, headers)
+  cb(headers)
+}
+
+export function mergeHeaders(onto: Headers, from: Headers) {
+  from.forEach((value, key) => {
+    if (value === undefined || value === 'undefined') {
+      onto.delete(key)
+    } else {
+      onto.append(key, value)
+    }
+  })
+}

package/src/vite/loadEnv.ts

@@ -0,0 +1,11 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+export async function loadEnv(root: string) {
+  const envPath = path.join(root, '.env')
+  if (!fs.existsSync(envPath)) return
+  const dotenv = await import('dotenv')
+  const result = dotenv.config({ path: envPath })
+  if (result.error) throw result.error
+  return true
+}

package/src/vite/makePluginWebOnly.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from 'vite'
+
+export function makePluginWebOnly(plugin: Plugin) {
+  const og = plugin.transform as any
+
+  if (og) {
+    plugin.transform = function (this, ...args) {
+      if (this.environment.name !== 'client') {
+        return
+      }
+      return og.call(this, ...args)
+    }
+  }
+
+  return plugin
+}

package/src/vite/one.ts

@@ -0,0 +1,281 @@
+import events from 'node:events'
+import { dirname, resolve } from 'node:path'
+import { type Plugin, type PluginOption, type UserConfig, loadConfigFromFile } from 'vite'
+import tsconfigPaths from 'vite-tsconfig-paths'
+import { getOptimizeDeps, getOptionsFilled, isWebEnvironment } from 'vxrn'
+import '../polyfills-server'
+import { existsAsync } from '../utils/existsAsync'
+import { requireResolve } from '../utils/requireResolve'
+import { clientTreeShakePlugin } from './clientTreeShakePlugin'
+import { createFileSystemRouter } from './createFileSystemRouter'
+import { ensureTSConfig } from './ensureTsConfig'
+import { fixDependenciesPlugin } from './fixDependenciesPlugin'
+import { generateTypesForRoutes } from './generateTypesForRoutes'
+import { loadEnv } from './loadEnv'
+import type { One } from './types'
+import { createVirtualEntry, virtualEntryId } from './virtualEntryPlugin'
+import { vitePluginSsrCss } from './vitePluginSsrCss'
+
+events.setMaxListeners(1_000)
+
+export function one(options: One.PluginOptions = {}): PluginOption {
+  oneOptions = options
+
+  void loadEnv(process.cwd())
+
+  // ensure tsconfig
+  if (options.config?.ensureTSConfig !== false) {
+    void ensureTSConfig()
+  }
+
+  globalThis['__vxrnPluginConfig__'] = options
+
+  // build is superset for now
+  const { optimizeDeps } = getOptimizeDeps('build')
+  const optimizeIds = optimizeDeps.include
+  const optimizeIdRegex = new RegExp(
+    // santize ids for regex
+    // https://stackoverflow.com/questions/6300183/sanitize-string-of-regex-characters-before-regexp-build
+    `${optimizeIds.map((id) => id.replace(/[#-.]|[[-^]|[?|{}]/g, '\\$&')).join('|')}`
+  )
+
+  let tsConfigPathsPlugin: Plugin | null = null
+
+  const vxrnOptions = getOptionsFilled()
+
+  const devAndProdPlugins = [
+    // proxy because you cant add a plugin inside a plugin
+    new Proxy(
+      {
+        name: 'one:tsconfig-paths',
+        config(configIncoming) {
+          const pathsConfig = options.config?.tsConfigPaths
+          if (pathsConfig === false) {
+            return
+          }
+          if (
+            configIncoming.plugins
+              ?.flat()
+              .some((p) => p && (p as any)['name'] === 'vite-tsconfig-paths')
+          ) {
+            // already has it configured
+            return
+          }
+
+          tsConfigPathsPlugin = tsconfigPaths(
+            pathsConfig && typeof pathsConfig === 'object' ? pathsConfig : {}
+          )
+        },
+
+        configResolved() {},
+        resolveId() {},
+      },
+      {
+        get(target, key, thisArg) {
+          if (key === 'config' || key === 'name') {
+            return Reflect.get(target, key, thisArg)
+          }
+
+          if (tsConfigPathsPlugin) {
+            return Reflect.get(tsConfigPathsPlugin, key, thisArg)
+          }
+        },
+      }
+    ),
+
+    {
+      name: 'one:init-config',
+
+      config() {
+        return {
+          define: {
+            ...(options.web?.defaultRenderMode && {
+              'process.env.One_DEFAULT_RENDER_MODE': JSON.stringify(options.web.defaultRenderMode),
+            }),
+
+            ...(options.setupFile && {
+              'process.env.One_SETUP_FILE': JSON.stringify(options.setupFile),
+            }),
+
+            ...(vxrnOptions && {
+              'process.env.ONE_SERVER_URL': JSON.stringify(vxrnOptions.server.url),
+            }),
+          },
+
+          environments: {
+            client: {
+              define: {
+                'process.env.VITE_ENVIRONMENT': '"client"',
+              },
+            },
+
+            ssr: {
+              define: {
+                'process.env.VITE_ENVIRONMENT': '"ssr"',
+              },
+            },
+          },
+        }
+      },
+    } satisfies Plugin,
+
+    {
+      name: 'one-zero',
+      config() {
+        if (!options.zero) {
+          return
+        }
+
+        return {
+          define: {
+            'process.env.ZERO_ENABLED': 'true',
+            TESTING: 'false',
+            REPLICACHE_VERSION: '"15.2.1"',
+            ZERO_VERSION: '"0.0.0"',
+          },
+        }
+      },
+    } satisfies Plugin,
+
+    {
+      name: 'tamagui-react-19',
+      config() {
+        return {
+          define: {
+            // safe to set because it only affects web in tamagui, and one is always react 19
+            'process.env.TAMAGUI_REACT_19': '"1"',
+          },
+        }
+      },
+    } satisfies Plugin,
+  ] satisfies Plugin[]
+
+  // TODO make this passed into vxrn through real API
+  globalThis.__vxrnAddNativePlugins = [clientTreeShakePlugin()]
+  globalThis.__vxrnAddWebPluginsProd = devAndProdPlugins
+
+  return [
+    ...devAndProdPlugins,
+
+    /**
+     * This is really the meat of one, where it handles requests:
+     */
+    createFileSystemRouter(options),
+
+    generateTypesForRoutes(options),
+
+    clientTreeShakePlugin(),
+
+    fixDependenciesPlugin(options.deps),
+
+    createVirtualEntry({
+      ...options,
+      root: 'app',
+    }),
+
+    {
+      name: 'define-app-key',
+      config() {
+        if (!options.app?.key) {
+          return
+        }
+
+        return {
+          define: {
+            'process.env.One_APP_NAME': JSON.stringify(options.app.key),
+          },
+        }
+      },
+    } satisfies Plugin,
+
+    {
+      name: 'use-react-18-for-native',
+      enforce: 'pre',
+
+      async config() {
+        const sharedNativeConfig = {
+          resolve: {
+            alias: {
+              react: requireResolve('one/react-18'),
+              'react-dom': requireResolve('one/react-dom-18'),
+            },
+          },
+        } satisfies UserConfig
+
+        return {
+          environments: {
+            ios: {
+              ...sharedNativeConfig,
+            },
+            android: {
+              ...sharedNativeConfig,
+            },
+            // this started erroring for no reason..
+          } as any,
+        }
+      },
+    } satisfies Plugin,
+
+    {
+      name: 'optimize-deps-load-web-extensions',
+      enforce: 'pre',
+
+      applyToEnvironment(environment) {
+        return isWebEnvironment(environment)
+      },
+
+      async resolveId(id, importer = '') {
+        const shouldOptimize = optimizeIdRegex.test(importer)
+
+        if (shouldOptimize) {
+          const absolutePath = resolve(dirname(importer), id)
+          const webPath = absolutePath.replace(/(.m?js)/, '') + '.web.js'
+          if (webPath === id) return
+          try {
+            const directoryPath = absolutePath + '/index.web.js'
+            if (await existsAsync(directoryPath)) {
+              return directoryPath
+            }
+            if (await existsAsync(webPath)) {
+              return webPath
+            }
+          } catch (err) {
+            console.warn(`error probably fine`, err)
+          }
+        }
+      },
+    } satisfies Plugin,
+
+    vitePluginSsrCss({
+      entries: [virtualEntryId],
+    }),
+  ]
+}
+
+let oneOptions: One.PluginOptions | null = null
+
+async function getUserOneOptions(command?: 'serve' | 'build') {
+  if (!oneOptions) {
+    if (!command) throw new Error(`Options not loaded and no command given`)
+    await loadUserOneOptions(command)
+  }
+  if (!oneOptions) {
+    throw new Error(`No one options loaded`)
+  }
+  return oneOptions
+}
+
+export async function loadUserOneOptions(command: 'serve' | 'build') {
+  const found = await loadConfigFromFile({
+    mode: 'prod',
+    command,
+  })
+  if (!found) {
+    throw new Error(`No config found`)
+  }
+  const foundOptions = getUserOneOptions()
+  if (!foundOptions) {
+    throw new Error(`No One plugin added to config`)
+  }
+  return foundOptions
+}

package/src/vite/removeReactNativeWebAnimatedPlugin.ts

@@ -0,0 +1,50 @@
+import type { Plugin, UserConfig } from 'vite'
+
+/**
+ * TODO this seems to just not work on prod build? it doesnt run setup at all
+ */
+
+export function removeReactNativeWebAnimatedPlugin(opts?: {
+  panResponder?: boolean
+}): Plugin {
+  const filter = opts?.panResponder
+    ? /(react-native\/Animated\/Animated|PlatformPressable|PanResponder|ResponderSystem)/
+    : /(react-native\/Animated\/Animated|PlatformPressable)/
+
+  const optimizeDeps = {
+    esbuildOptions: {
+      plugins: [
+        {
+          name: 'remove-react-native-web-animated',
+          setup(build) {
+            build.onResolve(
+              {
+                filter,
+              },
+              (args) => {
+                return { path: args.path, namespace: 'proxy-wormify' }
+              }
+            )
+
+            build.onLoad({ filter: /.*/, namespace: 'proxy-wormify' }, (args) => {
+              return {
+                contents: `export * from "@tamagui/proxy-worm";`,
+                loader: 'js',
+              }
+            })
+          },
+        },
+      ],
+    },
+  } satisfies UserConfig['optimizeDeps']
+
+  return {
+    name: 'remove-react-native-web-animated',
+
+    config() {
+      return {
+        optimizeDeps,
+      }
+    },
+  }
+}

package/src/vite/replaceLoader.ts

@@ -0,0 +1,18 @@
+export function replaceLoader({
+  code,
+  loaderData,
+}: {
+  code: string
+  loaderData: Object
+}) {
+  const stringifiedData = JSON.stringify(loaderData)
+
+  const out = (() => {
+    if (!code.includes('__vxrn__loader__')) {
+      return code + `\nexport const loader = () => (${stringifiedData})`
+    }
+    return code.replace(/["']__vxrn__loader__['"]/, stringifiedData)
+  })()
+
+  return out
+}

package/src/vite/resolveAPIRequest.ts

@@ -0,0 +1,86 @@
+import { isResponse } from '../utils/isResponse'
+import { asyncHeadersCache, mergeHeaders, requestAsyncLocalStore } from './headers'
+
+export function resolveAPIRequest(
+  asyncImport: () => Promise<any>,
+  request: Request,
+  params: Record<string, string>
+) {
+  if (!asyncImport) return
+
+  return new Promise((res, rej) => {
+    const id = { _id: Math.random() }
+    requestAsyncLocalStore.run(id, async () => {
+      try {
+        const imported = await asyncImport()
+        const requestType = request.method || 'GET'
+        const handler = imported[requestType] || imported.default
+
+        if (!handler) {
+          console.warn(`No handler found for request ${requestType}`)
+          return
+        }
+
+        let response = await handler(request, { params })
+
+        const asyncHeaders = asyncHeadersCache.get(id)
+
+        if (asyncHeaders) {
+          try {
+            if (response instanceof Response) {
+              mergeHeaders(response.headers, asyncHeaders)
+            } else {
+              if (response && typeof response === 'object') {
+                response = Response.json(response, { headers: asyncHeaders })
+              } else {
+                response = new Response(response as any, { headers: asyncHeaders })
+              }
+            }
+          } catch (err) {
+            if (`${err}`.includes('immutable')) {
+              // we have to create a new response
+              const body = response.body ? await streamToString(response.body) : ''
+              response = new Response(body, {
+                headers: response.headers,
+                status: response.status,
+                statusText: response.statusText,
+              })
+              mergeHeaders(response.headers, asyncHeaders)
+            } else {
+              console.error(` [one] error adding headers: ${err}`)
+            }
+          }
+        }
+
+        res(response)
+      } catch (err) {
+        // allow throwing a response
+        if (isResponse(err)) {
+          res(err)
+        } else {
+          rej(err) // reject the promise on any other error
+        }
+      }
+    })
+  })
+}
+
+async function streamToString(stream: ReadableStream) {
+  const reader = stream.getReader()
+  const decoder = new TextDecoder()
+  let result = ''
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      result += decoder.decode(value, { stream: true })
+    }
+  } catch (error) {
+    console.error('Error reading the stream:', error)
+  } finally {
+    reader.releaseLock()
+  }
+
+  return result
+}

package/src/vite/server.ts

@@ -0,0 +1,19 @@
+import { parentPort } from 'node:worker_threads'
+import { fileURLToPath } from 'node:url'
+import { ESModulesEvaluator, ModuleRunner, RemoteRunnerTransport } from 'vite/module-runner'
+
+if (!parentPort) {
+  throw new Error(`No parent port`)
+}
+
+const runner = new ModuleRunner(
+  {
+    root: fileURLToPath(new URL('./', import.meta.url)),
+    transport: new RemoteRunnerTransport({
+      send: (data) => parentPort!.postMessage(data),
+      onMessage: (listener) => parentPort!.on('message', listener),
+      timeout: 5000,
+    }),
+  },
+  new ESModulesEvaluator()
+)

package/src/vite/types.ts

@@ -0,0 +1,147 @@
+import type { Hono } from 'hono'
+import type {
+  DepOptimize,
+  DepPatch,
+  AfterBuildProps as VXRNAfterBuildProps,
+  VXRNOptions,
+} from 'vxrn'
+import type { PluginOptions as TSConfigPluginOptions } from 'vite-tsconfig-paths'
+
+export namespace One {
+  export type Options = Omit<VXRNOptions, keyof PluginOptions> & PluginOptions
+
+  export type RouteRenderMode = 'ssg' | 'spa' | 'ssr'
+
+  export type RouteType = RouteRenderMode | 'api' | 'layout'
+
+  export type RouteOptions = {
+    routeModes?: Record<string, RouteRenderMode>
+  }
+
+  export type FixDependencies = {
+    [key: string]: DepOptimize | DepPatch['patchFiles']
+  }
+
+  export type PluginOptions = {
+    /**
+     * Enabling zero does a couple very simple things:
+     *
+     *   - It makes zero hand of seamelessly from server to client without flicker
+     *
+     */
+    zero?: boolean
+
+    /**
+     * Path to a js or ts file to import before the rest of your app runs
+     * One controls your root, but you may want to runs some JS before anything else
+     * Use this to give One the entrypoint to run
+     */
+    setupFile?: string
+
+    config?: {
+      ensureTSConfig?: false
+
+      /**
+       * One automatically adds vite-tsconfig-paths, set this to false to disable, or
+       * pass in an object to pass options down. If you add your own vite-tsconfig-paths
+       * we will avoid adding it again internally.
+       *
+       * See: https://github.com/aleclarson/vite-tsconfig-paths
+       *
+       * @default false
+       */
+      tsConfigPaths?: boolean | TSConfigPluginOptions
+    }
+
+    app?: {
+      /**
+       * The uid of your native app, this will be used internally in one to call
+       * `AppRegistry.registerComponent(key)`
+       */
+      key?: string
+    }
+
+    web?: {
+      /**
+       * Choose the default strategy for pages to be rendered on the web.
+       *
+       * For sites that are mostly static, choose "ssg":
+       *   SSG stands for "server side generated", in this mode when you run `build`
+       *   your pages will all be fully rendered on the server once during the build,
+       *   outputting a static HTML page with the rendered page and loader data inlined.
+       *   This gives better performance for initial render, and better SEO.
+       *
+       *
+       * For apps that are mostly dynamic, choose "spa":
+       *   SPA stands for "single page app", in this mode when you run `build` your
+       *   pages will only render out an empty shell of HTML and will not attempt to
+       *   server render at all. Loaders will be run on the server side and the data will
+       *   be available to your app on initial render.
+       *
+       * @default 'ssg'
+       */
+      defaultRenderMode?: RouteRenderMode
+
+      redirects?: Redirects
+    }
+
+    server?: VXRNOptions['server']
+
+    build?: {
+      server?: {
+        /**
+         * Controls server build output module format
+         * @default 'esm'
+         */
+        outputFormat?: 'cjs' | 'esm'
+      }
+
+      api?: {
+        /**
+         * Controls server build output module format
+         * @default 'esm'
+         */
+        outputFormat?: 'cjs' | 'esm'
+      }
+    }
+
+    deps?: FixDependencies
+
+    afterBuild?: (props: AfterBuildProps) => void | Promise<void>
+  }
+
+  export interface RouteContext {
+    keys(): string[]
+    (id: string): any
+    <T>(id: string): T
+    resolve(id: string): string
+    id: string
+  }
+
+  export type Redirect = {
+    source: string
+    destination: string
+    permanent: boolean
+  }
+
+  export type Redirects = Redirect[]
+
+  export type BuildInfo = Pick<AfterBuildProps, 'routeMap' | 'builtRoutes'>
+
+  export type AfterBuildProps = VXRNAfterBuildProps & {
+    routeMap: Record<string, string>
+    builtRoutes: RouteBuildInfo[]
+  }
+
+  export type RouteBuildInfo = {
+    type: RouteType
+    path: string
+    cleanPath: string
+    htmlPath: string
+    clientJsPath: string
+    serverJsPath: string
+    params: Object
+    loaderData: any
+    preloads: string[]
+  }
+}