one 1.2.0 → 1.2.1

package/src/vite/plugins/virtualEntryPlugin.ts

@@ -0,0 +1,87 @@
+import type { Plugin } from 'vite'
+import { isNativeEnvironment } from 'vxrn'
+import {
+  API_ROUTE_GLOB_PATTERN,
+  ROUTE_GLOB_PATTERN,
+  ROUTE_NATIVE_EXCLUSION_GLOB_PATTERNS,
+  ROUTE_WEB_EXCLUSION_GLOB_PATTERNS,
+} from '../../router/glob-patterns'
+import type { One } from '../types'
+import {
+  resolvedVirtualEntryId,
+  resolvedVirtualEntryIdNative,
+  virtualEntryId,
+  virtualEntryIdNative,
+} from './virtualEntryConstants'
+
+const USE_ONE_SETUP_FILE = `
+if (process.env.ONE_SETUP_FILE) {
+  import(/* @vite-ignore */ process.env.ONE_SETUP_FILE)
+}
+`
+
+export function createVirtualEntry(options: {
+  root: string
+  router?: {
+    ignoredRouteFiles?: Array<string>
+  }
+  flags: One.Flags
+}): Plugin {
+  const routeGlobs = [
+    `/${options.root}/${ROUTE_GLOB_PATTERN}`,
+    ...(options.router?.ignoredRouteFiles?.map((pattern) => `!/${options.root}/${pattern}`) || []),
+  ]
+  const apiRouteGlobs = `/${options.root}/${API_ROUTE_GLOB_PATTERN}`
+
+  return {
+    name: 'one-virtual-entry',
+    enforce: 'pre',
+
+    resolveId(id) {
+      if (id === virtualEntryId) {
+        return resolvedVirtualEntryId
+      }
+      if (id === virtualEntryIdNative) {
+        return resolvedVirtualEntryIdNative
+      }
+    },
+
+    load(id) {
+      if (id === resolvedVirtualEntryId) {
+        const prependCode = isNativeEnvironment(this.environment)
+          ? '' /* `import()` will not work on native */
+          : USE_ONE_SETUP_FILE
+        return `
+${prependCode}
+
+import { createApp } from 'one'
+
+// globbing ${JSON.stringify(routeGlobs)}
+export default createApp({
+  routes: import.meta.glob(${JSON.stringify([...routeGlobs, ...ROUTE_WEB_EXCLUSION_GLOB_PATTERNS.map((p) => `!${p}`)])}, { exhaustive: true }),
+  routerRoot: ${JSON.stringify(options.root)},
+  flags: ${JSON.stringify(options.flags)},
+})
+        `
+      }
+
+      if (id === resolvedVirtualEntryIdNative) {
+        const prependCode = isNativeEnvironment(this.environment)
+          ? '' /* `import()` will not work on native */
+          : USE_ONE_SETUP_FILE
+        return `
+${prependCode}
+
+import { createApp } from 'one'
+
+// globbing ${JSON.stringify(routeGlobs)}
+export default createApp({
+  routes: import.meta.glob(${JSON.stringify([...routeGlobs, ...ROUTE_NATIVE_EXCLUSION_GLOB_PATTERNS.map((p) => `!${p}`), `!${apiRouteGlobs}`])}, { exhaustive: true }),
+  routerRoot: ${JSON.stringify(options.root)},
+  flags: ${JSON.stringify(options.flags)},
+})
+        `
+      }
+    },
+  }
+}

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__['"]/,
+      // make sure this ' ' is added in front,
+      // minifiers will do `return"something"
+      // but if its null then it becomes returnnull
+      ' ' + stringifiedData.replace(/\$/g, '$$$$')
+    )
+  })()
+
+  return out
+}

package/src/vite/resolveResponse.ts

@@ -0,0 +1,92 @@
+import { isResponse } from '../utils/isResponse'
+import { asyncHeadersCache, mergeHeaders, runWithAsyncLocalContext } from './one-server-only'
+
+export function resolveResponse(getResponse: () => Promise<Response>) {
+  return new Promise<Response>((res, rej) => {
+    runWithAsyncLocalContext(async (id) => {
+      try {
+        const response = await getResponse()
+        const modifiedResponse = await getResponseWithAddedHeaders(response, id)
+        res(modifiedResponse)
+      } catch (err) {
+        // allow throwing a response
+        if (isResponse(err)) {
+          res(err)
+        } else {
+          rej(err) // reject the promise on any other error
+        }
+      }
+    })
+  })
+}
+
+export function resolveAPIEndpoint(
+  // this is the result of importing the file:
+  runEndpoint: () => Promise<any>,
+  request: Request,
+  params: Record<string, string>
+) {
+  return resolveResponse(async () => {
+    const imported = await runEndpoint()
+    const requestType = request.method || 'GET'
+    const handler = imported[requestType] || imported.default
+    if (!handler) {
+      console.warn(`No handler found for request ${requestType}`)
+      return
+    }
+    return await handler(request, { params })
+  })
+}
+
+async function getResponseWithAddedHeaders(response: any, id: Object) {
+  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}`)
+      }
+    }
+  }
+
+  return response
+}
+
+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/types.ts

@@ -0,0 +1,369 @@
+import type { GetTransform } from '@vxrn/compiler'
+import type { metroPlugin } from '@vxrn/vite-plugin-metro'
+import type { PluginOptions as TSConfigPluginOptions } from 'vite-tsconfig-paths'
+import type {
+  AutoDepOptimizationOptions,
+  DepOptimize,
+  DepPatch,
+  AfterBuildProps as VXRNAfterBuildProps,
+  VXRNBuildOptions,
+  VXRNOptions,
+} from 'vxrn'
+import type { RouteNode } from '../router/Route'
+
+type MetroPluginOptions = Parameters<typeof metroPlugin>[0]
+
+export type RouteInfo<TRegex = string> = {
+  file: string
+  page: string
+  namedRegex: TRegex
+  loaderPath?: string
+  loaderServerPath?: string
+  urlPath: string
+  urlCleanPath: string
+  routeKeys: Record<string, string>
+  layouts?: RouteNode[]
+  middlewares?: RouteNode[]
+  type: One.RouteType
+  isNotFound?: boolean
+}
+
+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 ClientData = Record<string, any>
+
+  export type RouteOptions = {
+    routeModes?: Record<string, RouteRenderMode>
+  }
+
+  // todo move into vxrn
+  export type FixDependencies = {
+    [key: string]: DepOptimize | DepPatch['patchFiles']
+  }
+
+  type PluginPlatformTarget = 'native' | 'web'
+
+  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
+
+    /**
+     * Per-file control over how code transforms.
+     * Defaults to SWC, runs babel before SWC if:
+     *
+     *  - options.react.compiler is `true`, on tsx files in your app
+     *  - `react-native-reanimated` is in your dependencies and a file contains a reanimated keyword
+     *
+     * Otherwise One defaults to using `@swc/core`.
+     *
+     * Accepts a function:
+     *
+     *   (props: {
+     *      id: string
+     *      code: string
+     *      development: boolean
+     *      environment: Environment
+     *      reactForRNVersion: '18' | '19'
+     *   }) =>
+     *      | true     // default transforms
+     *      | false    // no transforms
+     *      | 'babel'  // force babel default transform
+     *      | 'swc'    // force swc default transform
+     *
+     *       // force babel, custom transform
+     *
+     *      | {
+     *          transform: 'babel'
+     *          excludeDefaultPlugins?: boolean
+     *        } & babel.TransformOptions
+     *
+     *      // force swc, custom transform
+     *
+     *      | {
+     *          transform: 'swc'
+     *        } & SWCOptions
+     *
+     * Babel defaults to preset `@babel/preset-typescript` with plugins:
+     *
+     *  - @babel/plugin-transform-destructuring
+     *  - @babel/plugin-transform-runtime
+     *  - @babel/plugin-transform-react-jsx
+     *  - @babel/plugin-transform-async-generator-functions
+     *  - @babel/plugin-transform-async-to-generator
+     *
+     *
+     * SWC defaults to target es5 for native, es2020 for web.
+     *
+     */
+    transform?: GetTransform
+
+    // compiler?: {
+    //   workletTransform?: 'reanimated' | 'worklets'
+    // }
+
+    router?: {
+      /**
+       * An array of globs that One uses to ignore files in your routes directory. If a file matches any pattern, it will not be treated as a route.
+       *
+       * This is useful for ignoring test or utility files you wish to colocate.
+       *
+       * Currently, we only support patterns starting with <code>&#42;&#42;/&#42;</code>.
+       *
+       * Example:
+       * * <code>&#42;&#42;/&#42;.test.*</code>
+       */
+      ignoredRouteFiles?: Array<`**/*${string}`>
+      /**
+       * Dangerously customize the router root directory. This may lead to unexpected behavior.
+       */
+      root?: string
+      experimental?: {
+        /**
+         * If enabled, the router will try to avoid unnecessary remounts of _layout components.
+         *
+         * We aren't sure that this won't cause any side effects and break things, so this is still experimental and defaults to `false`.
+         *
+         * Currently, this will only effect the `<Slot />` navigator, where it will modify the screen element provided by `react-navigation` and set the `key` to a static value to prevent re-mounting.
+         */
+        preventLayoutRemounting?: boolean
+      }
+    }
+
+    react?: {
+      /**
+       * Enable the React Compiler, for all or specific platforms
+       * @default false
+       */
+      compiler?: boolean | PluginPlatformTarget
+    }
+
+    optimization?: {
+      /**
+       * Turn on [vite-plugin-barrel](https://github.com/JiangWeixian/vite-plugin-barrel/tree/master).
+       * Optimizes barrel export files to speed up your build, you must list the packages that have
+       * barrel exports. Especially useful for icon packs.
+       *
+       * @default ['@tamagui/lucide-icons']
+       */
+      barrel?: boolean | string[]
+
+      /**
+       * By default One scans your fs routes and adds them as Vite `entries`, this prevents some hard
+       * reloads on web as you navigate to new pages, but can slow things startup.
+       *
+       * The 'flat' option is default and will automatically add just the routes at the root of your
+       * app but nothing nested in non-group folders below that.
+       *
+       * @default 'flat'
+       */
+      autoEntriesScanning?: boolean | 'flat'
+    }
+
+    /**
+     * 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
+    }
+
+    native?: {
+      /**
+       * The uid of your native app, this will be used internally in one to call
+       * `AppRegistry.registerComponent(key)`
+       */
+      key?: string
+
+      /**
+       * Turns on react-native-css-interop support when importing CSS on native
+       */
+      css?: boolean
+
+      /**
+       * Specifies the bundler to use for native builds. Defaults to 'vite'.
+       *
+       * - 'metro' is recommended for production stability. Note that this option comes with some limitations, see https://onestack.dev/docs/metro-mode#limitations for more info.
+       * - 'vite' is experimental but offers faster builds with SWC.
+       *
+       * Note that the ONE_METRO_MODE environment variable can override this setting to 'metro'.
+       */
+      bundler?: 'metro' | 'vite'
+    } & (
+      | {
+          bundler: 'metro'
+          /** Options merging for Metro is not fully implemented in the One plugin, changing this may not work properly. Search for "METRO-OPTIONS-MERGING" in the codebase for details. */
+          bundlerOptions?: MetroPluginOptions
+        }
+      | {
+          bundler?: 'vite'
+          /** No configurable options with the default vite bundler. */
+          bundlerOptions?: { currentlyHaveNoOptions?: null }
+        }
+    )
+
+    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
+
+      /**
+       * An array of redirect objects, works in development and production:
+       *
+       * @example
+       *
+       * [
+       *   {
+       *     source: '/vite',
+       *     destination: 'https://vxrn.dev',
+       *     permanent: true,
+       *   },
+       *   {
+       *     source: '/docs/components/:slug/:version',
+       *     destination: '/ui/:slug/:version',
+       *     permanent: true,
+       *   },
+       * ]
+       *
+       */
+      redirects?: Redirect[]
+
+      /**
+       * Can be one of "node" or "vercel" ("vercel" support is experimental and currently not recommended for production use), this will determine the Hono adapter and build to run
+       * properly in production for each platform.
+       *
+       * @default node
+       */
+      deploy?: 'vercel' | 'node'
+    }
+
+    server?: VXRNOptions['server']
+
+    build?: {
+      server?: VXRNBuildOptions | false
+      api?: VXRNBuildOptions
+    }
+
+    deps?: FixDependencies
+
+    ssr?: {
+      /**
+       * One scans dependencies on startup and decides which ones to optimize based on known broken
+       * dependencies. These include react-native and react, which need to be optimized to work.
+       * It finds all parent dependencies of the know bad deps and adds them to ssr.optimizeDeps.include.
+       *
+       * You can disable with false, or configure the include/exclude with options.
+       *
+       * Note: the **full path** (e.g. `<your_project_path>/node_modules/<some_package>`) will be used to match dependencies, if you are using a string to match a package name you may want to add `*` + `/` at the start and `/*` the end.
+       *
+       * @default { include: /node_modules/ }
+       */
+      autoDepsOptimization?: boolean | AutoDepOptimizationOptions
+    }
+  }
+
+  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 BuildInfo = {
+    constants: {
+      CACHE_KEY: string
+    }
+    oneOptions?: PluginOptions
+    routeToBuildInfo: Record<string, Omit<One.RouteBuildInfo, 'loaderData'>>
+    /** A mapping to lookup the full route name from a path */
+    pathToRoute: Record<string, string>
+    routeMap: Record<string, string>
+    manifest: {
+      pageRoutes: RouteInfo[]
+      apiRoutes: RouteInfo[]
+      allRoutes: RouteInfo[]
+    }
+
+    // for quick checking if preload exists
+    preloads: Record<string, boolean>
+    loaders: Record<string, boolean>
+  }
+
+  export type AfterBuildProps = VXRNAfterBuildProps & BuildInfo
+
+  export type RouteBuildInfo = {
+    type: One.RouteType
+    path: string
+    routeFile: string
+    middlewares: string[]
+    preloadPath: string
+    loaderPath: string
+    cleanPath: string
+    htmlPath: string
+    clientJsPath: string
+    serverJsPath: string
+    params: Object
+    loaderData: any
+    preloads: string[]
+    css: string[]
+  }
+
+  export type ServerContext = {
+    css?: string[]
+    postRenderData?: any
+    loaderData?: any
+    loaderProps?: any
+    mode?: 'spa' | 'ssg' | 'ssr'
+  }
+
+  export type Flags = {
+    /** See PluginOptions.router.experimental.PreventLayoutRemounting */
+    experimentalPreventLayoutRemounting?: boolean
+  }
+}

package/src/vite.ts

@@ -0,0 +1,14 @@
+// This needs to load before any other imports that might use the server globals.
+// Specifically `one-server-only`, which will be imported at some level under
+// some of the subsequent imports.
+import './server/setupServerGlobals'
+
+// plugins
+export { resolvePath } from '@vxrn/resolve'
+export { build } from './cli/build'
+export { makePluginWebOnly } from './vite/makePluginWebOnly'
+export { one } from './vite/one'
+export { clientTreeShakePlugin } from './vite/plugins/clientTreeShakePlugin'
+export { createFileSystemRouterPlugin } from './vite/plugins/fileSystemRouterPlugin'
+export { removeReactNativeWebAnimatedPlugin } from './vite/plugins/removeReactNativeWebAnimatedPlugin'
+export { SSRCSSPlugin } from './vite/plugins/SSRCSSPlugin'

package/src/zero/getQueryKey.ts

@@ -0,0 +1,5 @@
+import { hashString } from '../utils/hashString'
+
+export function getQueryKey(query: { ast: any }): string {
+  return hashString(JSON.stringify(query.ast))
+}

package/src/zero/isZeroQuery.ts

@@ -0,0 +1,7 @@
+// TODO more legit
+export function isZeroQuery(obj: any): boolean {
+  if (!obj) return false
+  if (typeof obj !== 'object') return false
+  if (!obj.ast || !obj.ast.table) return false
+  return true
+}

package/src/zero/resolveQuery.ts

@@ -0,0 +1,29 @@
+// TODO get proper type
+type Query = any
+
+export async function resolveZeroQuery(query: Query): Promise<any> {
+  const view = query.materialize()
+
+  // slow query warning
+  const tm = setTimeout(() => {
+    console.warn(
+      ` Warning: query slow to resolve, ensure Zero server is running`,
+      JSON.stringify(query.ast, null, 2)
+    )
+  }, 2000)
+
+  return new Promise((res, rej) => {
+    try {
+      const unsubscribe = view.addListener((snapshot) => {
+        unsubscribe()
+        clearTimeout(tm)
+        res(snapshot)
+      })
+
+      view.hydrate()
+    } catch (err) {
+      clearTimeout(tm)
+      rej(err)
+    }
+  })
+}

package/src/zero/subscribeToQuery.ts

@@ -0,0 +1,12 @@
+// TODO get proper type
+type Query = any
+
+export function subscribeToZeroQuery(query: Query, onUpdate: (val: any) => void): () => void {
+  const view = query.materialize()
+  view.hydrate()
+  const unsubscribe = view.addListener(onUpdate)
+  return () => {
+    unsubscribe()
+    view.destroy()
+  }
+}

package/src/zero/types.ts

@@ -0,0 +1,17 @@
+// import type { Query, QueryRowType } from 'zql/src/zql/query/query.js'
+type Query<a, b> = any
+type QueryRowType<a> = any
+
+type GenericQuery = Query<any, any>
+
+// works with .expect or regular queries:
+
+export type ZeroResult<X extends GenericQuery | ((props: any) => GenericQuery)> = X extends (
+  props: any
+) => infer Y
+  ? Y extends GenericQuery
+    ? QueryRowType<Y>
+    : unknown
+  : X extends GenericQuery
+    ? QueryRowType<X>
+    : unknown