@tamagui/vite-plugin 2.7.7 → 3.0.0-beta.1097.1

package/src/loadTamagui.ts

@@ -1,94 +1,288 @@
-import * as StaticWorker from '@tamagui/static-worker'
+import Static from '@tamagui/static'
+import type { TamaguiProjectInfo } from '@tamagui/static'
 import type { TamaguiOptions } from '@tamagui/types'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import type { RunnableDevEnvironment } from 'vite'
 
-// use globalThis to share state across vite environments (SSR, client, etc.)
-const LOAD_STATE_KEY = '__tamagui_load_state__'
+export const TAMAGUI_EVALUATION_ENVIRONMENT = 'tamagui'
 
-type LoadState = {
-  loadPromise: Promise<TamaguiOptions> | null
-  loadedOptions: TamaguiOptions | null
-  fullConfigLoaded: boolean
-  fullConfigLoadPromise: Promise<void> | null
-}
+const requireFromLoader = createRequire(
+  typeof __filename === 'string' ? __filename : import.meta.url
+)
 
-function getLoadState(): LoadState {
-  if (!(globalThis as any)[LOAD_STATE_KEY]) {
-    ;(globalThis as any)[LOAD_STATE_KEY] = {
-      loadPromise: null,
-      loadedOptions: null,
-      fullConfigLoaded: false,
-      fullConfigLoadPromise: null,
-    }
-  }
-  return (globalThis as any)[LOAD_STATE_KEY]
+// upgrading the plugin must invalidate cached plans even when the project did
+// not change
+const vitePluginVersions = [
+  `@tamagui/vite-plugin@${(requireFromLoader('@tamagui/vite-plugin/package.json') as { version: string }).version}`,
+]
+
+type ResolvedEvaluationModule = {
+  moduleName: string
+  id: string
+  module: Record<string, unknown>
 }
 
-export function getTamaguiOptions(): TamaguiOptions | null {
-  return getLoadState().loadedOptions
+type EvaluatedProjectModules = {
+  config: ResolvedEvaluationModule
+  components: ResolvedEvaluationModule[]
 }
 
-export function getLoadPromise(): Promise<TamaguiOptions> | null {
-  return getLoadState().loadPromise
+export type ViteTamaguiLoader = {
+  getEnvironment(): RunnableDevEnvironment | null
+  getGeneration(): number
+  getLoadPromise(): Promise<TamaguiOptions> | null
+  getTamaguiOptions(): TamaguiOptions | null
+  getTamaguiConfig(): Promise<TamaguiProjectInfo['tamaguiConfig']>
+  getCompilerProject(): Promise<Static.CompilerProject>
+  getEvaluationDependencies(): string[]
+  isEvaluationDependency(id: string): boolean
+  evaluateProjectModules(options: TamaguiOptions): Promise<EvaluatedProjectModules>
+  /**
+   * Evaluate one host-resolved module in the evaluation environment for the
+   * compiler's component discovery. Null when the environment is not ready or
+   * the module cannot run in node; the compiler then leaves its elements alone.
+   */
+  evaluateModule(id: string): Promise<Record<string, unknown> | null>
+  loadTamaguiBuildConfig(): Promise<TamaguiOptions>
+  setEnvironment(next: RunnableDevEnvironment, options?: { owned?: boolean }): void
+  invalidate(file?: string): void
+  ensureFullConfigLoaded(): Promise<string[]>
+  cleanup(): Promise<void>
 }
 
-/**
- * Load just the tamagui.build.ts config (lightweight)
- * This doesn't bundle the full tamagui config - call ensureFullConfigLoaded() for that
- */
-export async function loadTamaguiBuildConfig(
-  optionsIn?: Partial<TamaguiOptions>
-): Promise<TamaguiOptions> {
-  const state = getLoadState()
-  if (state.loadedOptions) return state.loadedOptions
-  if (state.loadPromise) return state.loadPromise
-
-  state.loadPromise = (async () => {
-    const options = await StaticWorker.loadTamaguiBuildConfig({
+export function createViteTamaguiLoader(
+  optionsIn: Partial<TamaguiOptions> = {}
+): ViteTamaguiLoader {
+  let environment: RunnableDevEnvironment | null = null
+  let ownsEnvironment = false
+  let loadPromise: Promise<TamaguiOptions> | null = null
+  let loadedOptions: TamaguiOptions | null = null
+  let projectPromise: Promise<Static.CompilerProject> | null = null
+  const evaluationDependencies = new Set<string>()
+  const stampSources = new Set<string>()
+  let generation = 0
+
+  const normalizeDependency = (id: string) => id.split('?')[0]
+
+  const captureEvaluationDependencies = (modules: ResolvedEvaluationModule[]) => {
+    stampSources.clear()
+    for (const { id } of modules) {
+      const dependency = normalizeDependency(id)
+      if (path.isAbsolute(dependency)) {
+        evaluationDependencies.add(dependency)
+        stampSources.add(dependency)
+      }
+    }
+    if (environment) {
+      for (const module of environment.runner.evaluatedModules.urlToIdModuleMap.values()) {
+        const dependency = normalizeDependency(module.file)
+        if (!path.isAbsolute(dependency)) continue
+        // watching node_modules is pointless, but the compile cache stamp has to
+        // see them: a component package defines every staticConfig the compiler
+        // lowers against, so bumping one in place must invalidate cached plans
+        stampSources.add(dependency)
+        if (!dependency.includes('/node_modules/')) {
+          evaluationDependencies.add(dependency)
+        }
+      }
+    }
+  }
+
+  const loadTamaguiBuildConfig = async (): Promise<TamaguiOptions> => {
+    if (loadedOptions) return loadedOptions
+    if (loadPromise) return loadPromise
+
+    loadPromise = Static.loadTamaguiBuildConfigAsync({
       ...optionsIn,
       platform: 'web',
+    }).then((options) => {
+      loadedOptions = options
+      return options
     })
 
-    state.loadedOptions = options
-    return options
-  })()
+    return loadPromise
+  }
 
-  return state.loadPromise
-}
+  const resolveAndImport = async (
+    moduleName: string,
+    root: string,
+    kind: 'config' | 'component'
+  ): Promise<ResolvedEvaluationModule> => {
+    if (!environment) {
+      throw new Error(
+        `The Tamagui Vite evaluation environment is not ready. Config and component evaluation requires Vite's ModuleRunner.`
+      )
+    }
 
-/**
- * Ensure the full tamagui config is loaded (heavy - bundles config + components)
- * Call this lazily when transform/extraction is actually needed
- */
-export async function ensureFullConfigLoaded(): Promise<void> {
-  const state = getLoadState()
-
-  if (state.fullConfigLoaded) return
-  if (state.fullConfigLoadPromise) return state.fullConfigLoadPromise
-
-  // set promise immediately to prevent race conditions
-  // (don't await loadTamaguiBuildConfig before setting this)
-  state.fullConfigLoadPromise = (async () => {
-    const options = await loadTamaguiBuildConfig()
-
-    // load full tamagui config in worker (asynchronous)
-    if (!options.disableWatchTamaguiConfig && !options.disable) {
-      await StaticWorker.loadTamagui({
-        components: ['tamagui'],
-        platform: 'web',
-        ...options,
-      })
+    const source = path.isAbsolute(moduleName)
+      ? moduleName
+      : kind === 'config' || moduleName.startsWith('.')
+        ? path.resolve(root, moduleName)
+        : moduleName
+    let environmentResolution = await environment.pluginContainer.resolveId(source)
+
+    // Config paths are app-root relative by default, but package/alias config
+    // entries remain supported when no root-relative file resolves.
+    if (!environmentResolution && kind === 'config' && source !== moduleName) {
+      environmentResolution = await environment.pluginContainer.resolveId(moduleName)
     }
-    state.fullConfigLoaded = true
-  })()
 
-  return state.fullConfigLoadPromise
-}
+    const resolvedId = environmentResolution?.id
 
-export async function cleanup() {
-  await StaticWorker.destroyPool()
-  const state = getLoadState()
-  state.loadPromise = null
-  state.loadedOptions = null
-  state.fullConfigLoaded = false
-  state.fullConfigLoadPromise = null
+    if (!resolvedId) {
+      throw new Error(
+        `Unable to resolve ${moduleName} in the Tamagui Vite environment (plugins: ${environment.plugins.map((plugin) => plugin.name).join(', ')})`
+      )
+    }
+
+    return {
+      moduleName,
+      id: resolvedId,
+      module: (await environment.runner.import(resolvedId)) as Record<string, unknown>,
+    }
+  }
+
+  const evaluateProjectModules = async (
+    options: TamaguiOptions
+  ): Promise<EvaluatedProjectModules> => {
+    if (!environment) {
+      throw new Error(
+        `Cannot evaluate Tamagui without the ${TAMAGUI_EVALUATION_ENVIRONMENT} Vite environment`
+      )
+    }
+
+    const root = environment.config.root
+    const config = await resolveAndImport(
+      options.config || 'tamagui.config.ts',
+      root,
+      'config'
+    )
+    const components = await Promise.all(
+      (options.components || []).map((name) => resolveAndImport(name, root, 'component'))
+    )
+
+    captureEvaluationDependencies([config, ...components])
+
+    return { config, components }
+  }
+
+  const loadProject = async (
+    options: TamaguiOptions
+  ): Promise<Static.CompilerProject> => {
+    if (projectPromise) return projectPromise
+
+    projectPromise = (async () => {
+      if (!environment) {
+        throw new Error(
+          `Cannot load Tamagui without the ${TAMAGUI_EVALUATION_ENVIRONMENT} Vite environment`
+        )
+      }
+
+      let evaluated: EvaluatedProjectModules | null = null
+      return Static.loadCompilerProject({
+        root: environment.config.root,
+        target: 'web',
+        options,
+        generation: `vite:${generation}`,
+        hostVersions: vitePluginVersions,
+        async load(normalizedOptions) {
+          evaluated = await evaluateProjectModules(normalizedOptions)
+          return Static.loadTamaguiFromModules(normalizedOptions, {
+            config: evaluated.config.module,
+            components: evaluated.components.map(({ moduleName, module }) => ({
+              moduleName,
+              module,
+            })),
+            stampSources: [...stampSources],
+          })
+        },
+        async resolveComponents(moduleNames) {
+          if (!evaluated) {
+            throw new Error('The Tamagui compiler project modules were not evaluated')
+          }
+          const byName = new Map(
+            evaluated.components.map(({ moduleName, id }) => [moduleName, id])
+          )
+          return moduleNames.map((moduleName) => {
+            const id = byName.get(moduleName)
+            if (!id) throw new Error(`Unable to resolve compiler component ${moduleName}`)
+            return { moduleName, id }
+          })
+        },
+      })
+    })()
+
+    return projectPromise
+  }
+
+  return {
+    getEnvironment: () => environment,
+    getGeneration: () => generation,
+    getLoadPromise: () => loadPromise,
+    getTamaguiOptions: () => loadedOptions,
+    async getTamaguiConfig() {
+      const options = await loadTamaguiBuildConfig()
+      if (options.disable) return null
+      return (await loadProject(options)).projectInfo.tamaguiConfig
+    },
+    async getCompilerProject() {
+      const options = await loadTamaguiBuildConfig()
+      return loadProject(options)
+    },
+    getEvaluationDependencies: () => [...evaluationDependencies],
+    isEvaluationDependency: (id: string) =>
+      evaluationDependencies.has(normalizeDependency(id)),
+    evaluateProjectModules,
+    async evaluateModule(id) {
+      if (!environment) return null
+      try {
+        return (await environment.runner.import(id)) as Record<string, unknown>
+      } catch (error) {
+        if (process.env.DEBUG === 'tamagui') {
+          console.info(`[tamagui] component discovery skipped ${id}:`, error)
+        }
+        return null
+      }
+    },
+    loadTamaguiBuildConfig,
+
+    setEnvironment(next: RunnableDevEnvironment, options?: { owned?: boolean }) {
+      if (environment === next) return
+      environment = next
+      ownsEnvironment = options?.owned === true
+      generation++
+      projectPromise = null
+    },
+
+    invalidate(file?: string) {
+      if (file && environment) {
+        environment.runner.clearCache()
+      }
+      generation++
+      projectPromise = null
+    },
+
+    async ensureFullConfigLoaded() {
+      const options = await loadTamaguiBuildConfig()
+      if (!options.disable) {
+        await loadProject(options)
+      }
+      return [...evaluationDependencies]
+    },
+
+    async cleanup() {
+      try {
+        if (ownsEnvironment && environment) {
+          await environment.close()
+        }
+      } finally {
+        environment = null
+        ownsEnvironment = false
+        loadPromise = null
+        loadedOptions = null
+        projectPromise = null
+      }
+    },
+  }
 }