@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/src/extractor/concatClassName.ts

@@ -68,12 +68,7 @@ export function concatClassName(_cn: Record<string, any> | null | undefined): st
       if (propName && propObjects) {
         if (
           propObjects.some((po) => {
-            if (pseudoKey) {
-              const propKey = pseudoInvert[pseudoKey]
-              return po && po[propKey] && propName in po[propKey] && po[propKey] !== null
-            }
-            const res = po && propName in po && po[propName] !== null
-            return res
+            return po && propName in po && po[propName] !== null
           })
         ) {
           // if (shouldDebug) console.log('debug exclude:', name)
@@ -114,17 +109,15 @@ function getClassNameScope(name: string, splitIndex: number) {
   return { mediaKey, pseudoKey }
 }
 
-const pseudoInvert = {
-  hover: 'hoverStyle',
-  active: 'pressStyle',
-  focus: 'focusStyle',
-  'focus-visible': 'focusVisibleStyle',
-  'focus-within': 'focusWithinStyle',
-  focusVisible: 'focusVisibleStyle',
-  focusWithin: 'focusWithinStyle',
-  disabled: 'disabledStyle',
-  enter: 'enterStyle',
-  exit: 'exitStyle',
-}
-
-const pseudoKeys = Object.keys(pseudoInvert).sort((a, b) => b.length - a.length)
+const pseudoKeys = [
+  'focus-visible',
+  'focus-within',
+  'focusVisible',
+  'focusWithin',
+  'disabled',
+  'active',
+  'hover',
+  'focus',
+  'enter',
+  'exit',
+]

package/src/extractor/getTamaguiConfigPathFromOptionsConfig.ts

@@ -1,16 +1,17 @@
-import { isAbsolute, join } from 'node:path'
+import { isAbsolute, join, resolve } from 'node:path'
 
 import { statSync } from 'node:fs'
 import type { TamaguiOptions } from '../types'
 
 export function getTamaguiConfigPathFromOptionsConfig(
-  config: NonNullable<TamaguiOptions['config']>
+  config: NonNullable<TamaguiOptions['config']>,
+  root = process.cwd()
 ) {
   if (isAbsolute(config)) {
     return config
   }
 
-  const fullPath = join(process.cwd(), config)
+  const fullPath = join(root, config)
 
   try {
     if (statSync(fullPath).isFile()) {
@@ -20,5 +21,5 @@ export function getTamaguiConfigPathFromOptionsConfig(
     //
   }
 
-  return config
+  return resolve(config)
 }

package/src/extractor/loadTamagui.ts

@@ -1,21 +1,22 @@
 import { basename, dirname, extname, join, relative, resolve } from 'node:path'
+import { createRequire } from 'node:module'
 // @ts-ignore why
 import { Color, colorLog } from '@tamagui/cli-color'
 import type { CLIResolvedOptions, CLIUserOptions, TamaguiOptions } from '@tamagui/types'
 import type { TamaguiInternalConfig } from '@tamagui/web'
 import esbuild from 'esbuild'
-import * as esbuildWasm from 'esbuild-wasm'
-import * as fsExtra from 'fs-extra'
+import fsExtra from 'fs-extra'
 
-import { SHOULD_DEBUG } from '../constants'
 import { requireTamaguiCore } from '../helpers/requireTamaguiCore'
-import { getNameToPaths, registerRequire } from '../registerRequire'
+import { getNameToPaths, registerRequire, setRequireResult } from '../registerRequire'
 import {
   type TamaguiProjectInfo,
+  getComponentStaticConfigByName,
   getBundledConfig,
   getLoadedConfig,
   hasBundledConfigChanged,
   loadComponentsSync,
+  setLoadedConfig,
   writeTamaguiCSS,
 } from './bundleConfig'
 import { getTamaguiConfigPathFromOptionsConfig } from './getTamaguiConfigPathFromOptionsConfig'
@@ -25,6 +26,10 @@ import {
   regenerateConfigSync,
 } from './regenerateConfig'
 
+const nodeRequire = createRequire(
+  typeof __filename === 'string' ? __filename : import.meta.url
+)
+
 const getFilledOptions = (propsIn: Partial<TamaguiOptions>): TamaguiOptions => ({
   // defaults
   platform: (process.env.TAMAGUI_TARGET as any) || 'web',
@@ -36,31 +41,23 @@ const getFilledOptions = (propsIn: Partial<TamaguiOptions>): TamaguiOptions => (
 let isLoadingPromise: null | Promise<any>
 
 export async function loadTamagui(
-  propsIn: Partial<TamaguiOptions>
+  propsIn: Partial<TamaguiOptions>,
+  rebuild = false
 ): Promise<TamaguiProjectInfo | null> {
   if (isLoadingPromise) return await isLoadingPromise
 
-  let resolvePromise
-  let rejectPromise
-  isLoadingPromise = new Promise((res, rej) => {
-    resolvePromise = res
-    rejectPromise = rej
-  })
-
-  try {
+  isLoadingPromise = (async () => {
     const props = getFilledOptions(propsIn)
 
-    const bundleInfo = await getBundledConfig(props)
+    const bundleInfo = await getBundledConfig(props, rebuild)
     if (!bundleInfo) {
-      console.warn(
-        `No bundled config generated, maybe an error in bundling. Set DEBUG=tamagui and re-run to get logs.`
+      throw new Error(
+        `[tamagui] The config and component bundle completed without a project result`
       )
-      resolvePromise(null)
-      return null
     }
 
     // this affects the bundled config so run it first
-    await generateThemesAndLog(props)
+    await generateThemesAndLog(props, rebuild)
 
     // if they accidently pass in a config without createTamagui called,call it
     const maybeTamaguiConfig = bundleInfo.tamaguiConfig as TamaguiInternalConfig
@@ -70,22 +67,100 @@ export async function loadTamagui(
     }
 
     if (!hasBundledConfigChanged()) {
-      resolvePromise(bundleInfo)
       return bundleInfo
     }
 
     await regenerateConfig(props, bundleInfo)
 
-    resolvePromise(bundleInfo)
     return bundleInfo
-  } catch (err) {
-    rejectPromise()
-    throw err
+  })()
+
+  try {
+    return await isLoadingPromise
   } finally {
     isLoadingPromise = null
   }
 }
 
+export type EvaluatedTamaguiModule = {
+  moduleName: string
+  module: Record<string, unknown>
+}
+
+export type EvaluatedTamaguiProject = {
+  config: Record<string, unknown>
+  components: EvaluatedTamaguiModule[]
+  /**
+   * Every file the host's module runner evaluated to produce this config and
+   * these components, node_modules included. The compile cache stamp is hashed
+   * from their bytes, so an incomplete list is worse than none: omit it and the
+   * project simply gets no cache.
+   */
+  stampSources?: string[]
+}
+
+/**
+ * Load a Tamagui project from modules evaluated by the host bundler.
+ *
+ * Bundler adapters with a module runner use this boundary so aliases, package
+ * conditions, and user plugins are identical between application and compiler
+ * evaluation. Adapters without a module runner continue to use loadTamagui().
+ */
+export async function loadTamaguiFromModules(
+  propsIn: Partial<TamaguiOptions>,
+  evaluated: EvaluatedTamaguiProject
+): Promise<TamaguiProjectInfo> {
+  const props = getFilledOptions(propsIn)
+
+  await generateThemesAndLog(props)
+
+  const configModule = evaluated.config as any
+  let tamaguiConfig = (configModule.default || configModule.config || configModule) as
+    | TamaguiInternalConfig
+    | { config?: TamaguiInternalConfig }
+
+  if ('config' in tamaguiConfig && tamaguiConfig.config && !('tokens' in tamaguiConfig)) {
+    tamaguiConfig = tamaguiConfig.config
+  }
+
+  if (!tamaguiConfig) {
+    throw new Error(`The Vite module runner did not return a valid Tamagui config`)
+  }
+
+  const hostCore = requireTamaguiCore(props.platform || 'web')
+  if (!(tamaguiConfig as TamaguiInternalConfig).parsed) {
+    tamaguiConfig = hostCore.createTamagui(tamaguiConfig as any) as TamaguiInternalConfig
+  } else {
+    // Module runners can evaluate the config in a separate Tamagui module
+    // instance. Install the already-parsed config so host module-local state
+    // matches without re-parsing it or running browser-only CSS discovery.
+    hostCore.installTamaguiConfig(tamaguiConfig as TamaguiInternalConfig)
+  }
+
+  setLoadedConfig(tamaguiConfig as TamaguiInternalConfig)
+
+  const components = evaluated.components.map(({ moduleName, module }) => {
+    setRequireResult(moduleName, module)
+    return {
+      moduleName,
+      nameToInfo: getComponentStaticConfigByName(moduleName, module.default ?? module),
+    }
+  })
+
+  const projectInfo = {
+    components,
+    nameToPaths: {},
+    tamaguiConfig: tamaguiConfig as TamaguiInternalConfig,
+    stampSources: evaluated.stampSources,
+  } satisfies TamaguiProjectInfo
+
+  if (props.outputCSS) {
+    await writeTamaguiCSS(props.outputCSS, projectInfo.tamaguiConfig)
+  }
+
+  return projectInfo
+}
+
 // debounce a bit
 let waiting = false
 
@@ -103,7 +178,7 @@ export const generateThemesAndLog = async (options: TamaguiOptions, force = fals
       colorLog(
         Color.FgYellow,
         `${whitespaceBefore}➡ [tamagui] generated themes: ${relative(
-          process.cwd(),
+          options.root || process.cwd(),
           options.themeBuilder.output
         )}`
       )
@@ -123,70 +198,62 @@ export const generateThemesAndLog = async (options: TamaguiOptions, force = fals
 const last: Record<string, TamaguiProjectInfo | null> = {}
 const lastVersion: Record<string, string> = {}
 
-// esbuild-wasm state - initialized once per process
-let esbuildWasmInitialized = false
+const buildConfigDependencies = new WeakMap<TamaguiOptions, readonly string[]>()
+
+export function getTamaguiBuildConfigDependencies(
+  options: TamaguiOptions
+): readonly string[] {
+  return buildConfigDependencies.get(options) ?? []
+}
 
 /**
- * Load tamagui.build.ts config using esbuild-wasm transform
- * Uses WASM to avoid native esbuild service lifecycle issues (EPIPE errors)
+ * Load tamagui.build.ts and its relative imports as one Node module.
  */
 export async function loadTamaguiBuildConfigAsync(
   tamaguiOptions: Partial<TamaguiOptions> | undefined
 ): Promise<TamaguiOptions> {
   const buildFilePath = tamaguiOptions?.buildFile ?? './tamagui.build.ts'
-  const absolutePath =
-    buildFilePath[0] === '.' ? join(process.cwd(), buildFilePath) : buildFilePath
+  const root = tamaguiOptions?.root || process.cwd()
+  const absolutePath = resolve(root, buildFilePath)
 
   if (fsExtra.existsSync(absolutePath)) {
     try {
-      const source = await fsExtra.readFile(absolutePath, 'utf-8')
-
-      // initialize esbuild-wasm once
-      if (!esbuildWasmInitialized) {
-        await esbuildWasm.initialize({})
-        esbuildWasmInitialized = true
-      }
-
-      // use esbuild-wasm.transform to compile this one small config file. note
-      // that in node, even esbuild-wasm's transform spawns a long-lived
-      // `--service --ping` child via ensureServiceIsRunning, so we tear it down
-      // below - otherwise every plugin instance leaks a persistent esbuild
-      // process for the lifetime of the dev server.
-      const result = await esbuildWasm.transform(source, {
-        loader: 'ts',
+      const result = await esbuild.build({
+        entryPoints: [absolutePath],
+        absWorkingDir: root,
+        bundle: true,
+        packages: 'external',
+        platform: 'node',
         format: 'cjs',
         target: 'node18',
-        sourcefile: absolutePath,
+        write: false,
+        metafile: true,
       })
 
-      // evaluate the compiled code to get the exports
-      // pass process so process.env works in the config
       const module = { exports: {} as any }
-      const fn = new Function('module', 'exports', 'require', 'process', result.code)
-      fn(module, module.exports, require, process)
+      const projectRequire = createRequire(absolutePath)
+      const code = result.outputFiles[0]?.text
+      if (!code) throw new Error(`No output generated for ${buildFilePath}`)
+      const fn = new Function('module', 'exports', 'require', 'process', code)
+      fn(module, module.exports, projectRequire, process)
 
       const out = module.exports.default || module.exports
       if (!out || typeof out !== 'object') {
         throw new Error(`No default export found in ${buildFilePath}: ${out}`)
       }
 
-      tamaguiOptions = {
+      const loadedOptions = {
         ...tamaguiOptions,
         ...out,
-      }
+      } as TamaguiOptions
+      const dependencies = Object.keys(result.metafile.inputs).map((input) =>
+        resolve(root, input)
+      )
+      buildConfigDependencies.set(loadedOptions, dependencies)
+      tamaguiOptions = loadedOptions
     } catch (err) {
       console.error(`[tamagui] Error loading ${buildFilePath}:`, err)
       throw err
-    } finally {
-      // this is a one-shot transform - don't keep the esbuild-wasm service
-      // running for the rest of the process. it gets lazily re-spawned if
-      // transform is ever called again.
-      try {
-        esbuildWasm.stop()
-        esbuildWasmInitialized = false
-      } catch {
-        // ok - service may already be gone
-      }
     }
   }
 
@@ -196,11 +263,14 @@ export async function loadTamaguiBuildConfigAsync(
     )
   }
 
-  return {
+  const options = {
     config: 'tamagui.config.ts',
     components: ['tamagui', '@tamagui/core'],
     ...tamaguiOptions,
   } as TamaguiOptions
+  const dependencies = buildConfigDependencies.get(tamaguiOptions)
+  if (dependencies) buildConfigDependencies.set(options, dependencies)
+  return options
 }
 
 /**
@@ -210,12 +280,14 @@ export function loadTamaguiBuildConfigSync(
   tamaguiOptions: Partial<TamaguiOptions> | undefined
 ) {
   const buildFilePath = tamaguiOptions?.buildFile ?? './tamagui.build.ts'
-  if (fsExtra.existsSync(buildFilePath)) {
-    const registered = registerRequire('web')
+  const root = tamaguiOptions?.root || process.cwd()
+  const absolutePath = resolve(root, buildFilePath)
+  if (fsExtra.existsSync(absolutePath)) {
+    const registered = registerRequire('web', {
+      ignoredModules: tamaguiOptions?.dangerouslyIgnoreStaticEvaluationModules,
+    })
     try {
-      const out = require(
-        buildFilePath[0] === '.' ? join(process.cwd(), buildFilePath) : buildFilePath
-      ).default
+      const out = nodeRequire(absolutePath).default
       if (!out) {
         throw new Error(`No default export found in ${buildFilePath}: ${out}`)
       }
@@ -260,6 +332,9 @@ export function loadTamaguiSync({
   lastVersion[key] = cacheKey || ''
 
   const props = getFilledOptions(propsIn)
+  const previousIsStatic = process.env.IS_STATIC
+  const previousIsServer = process.env.TAMAGUI_IS_SERVER
+  const previousDev = globalThis['__DEV__' as any]
 
   // lets shim require and avoid importing react-native + react-native-web
   // we just need to read the config around them
@@ -267,97 +342,76 @@ export function loadTamaguiSync({
   process.env.TAMAGUI_IS_SERVER = 'true'
 
   const { unregister } = registerRequire(props.platform || 'web', {
-    proxyWormImports: !!forceExports,
+    ignoredModules: props.dangerouslyIgnoreStaticEvaluationModules,
   })
 
   try {
-    const devValueOG = globalThis['__DEV__' as any]
     globalThis['__DEV__' as any] = process.env.NODE_ENV === 'development'
+    // config
+    let tamaguiConfig: TamaguiInternalConfig | null = null
+    if (propsIn.config) {
+      const configPath = getTamaguiConfigPathFromOptionsConfig(
+        propsIn.config,
+        propsIn.root
+      )
+      const exp = nodeRequire(configPath)
 
-    try {
-      // config
-      let tamaguiConfig: TamaguiInternalConfig | null = null
-      if (propsIn.config) {
-        const configPath = getTamaguiConfigPathFromOptionsConfig(propsIn.config)
-        const exp = require(configPath)
-
-        if (!exp || exp._isProxyWorm) {
-          throw new Error(`Got a empty / proxied config!`)
-        }
+      if (!exp) {
+        throw new Error(`The Tamagui config module did not export a value`)
+      }
 
-        tamaguiConfig = (exp['default'] || exp['config'] || exp) as TamaguiInternalConfig
+      tamaguiConfig = (exp['default'] || exp['config'] || exp) as TamaguiInternalConfig
 
-        if (!tamaguiConfig || !tamaguiConfig.parsed) {
-          const confPath = require.resolve(configPath)
-          throw new Error(`Can't find valid config in ${confPath}:
+      if (!tamaguiConfig || !tamaguiConfig.parsed) {
+        const confPath = nodeRequire.resolve(configPath)
+        throw new Error(`Can't find valid config in ${confPath}:
           
   Be sure you "export default" or "export const config" the config.`)
-        }
-
-        // set up core
-        if (tamaguiConfig) {
-          const { createTamagui } = requireTamaguiCore(props.platform || 'web')
-          createTamagui(tamaguiConfig as any)
-        }
       }
 
-      // components
-      const components = loadComponentsSync(props, forceExports)
-      if (!components) {
-        throw new Error(`No components loaded`)
-      }
-      if (process.env.DEBUG === 'tamagui') {
-        console.info(`components`, components)
+      // set up core
+      if (tamaguiConfig) {
+        const { createTamagui } = requireTamaguiCore(props.platform || 'web')
+        createTamagui(tamaguiConfig as any)
       }
+    }
 
-      // undo shims
-      process.env.IS_STATIC = undefined
-      globalThis['__DEV__' as any] = devValueOG
-
-      const info = {
-        components,
-        tamaguiConfig,
-        nameToPaths: getNameToPaths(),
-      } satisfies TamaguiProjectInfo
-
-      if (tamaguiConfig) {
-        const { outputCSS } = props
-        if (outputCSS) {
-          writeTamaguiCSS(outputCSS, tamaguiConfig)
-        }
+    // components
+    const components = loadComponentsSync(props, forceExports)
+    if (!components) {
+      throw new Error(`No components loaded`)
+    }
+    if (process.env.DEBUG === 'tamagui') {
+      console.info(`components`, components)
+    }
 
-        regenerateConfigSync(props, info)
-      }
+    const info = {
+      components,
+      tamaguiConfig,
+      nameToPaths: getNameToPaths(),
+    } satisfies TamaguiProjectInfo
 
-      last[key] = {
-        ...info,
-        cached: true,
+    if (tamaguiConfig) {
+      const { outputCSS } = props
+      if (outputCSS) {
+        writeTamaguiCSS(outputCSS, tamaguiConfig)
       }
 
-      return info as any
-    } catch (err) {
-      if (err instanceof Error) {
-        if (!SHOULD_DEBUG && !forceExports) {
-          console.warn(
-            `Error loading tamagui.config.ts (set DEBUG=tamagui to see full stack), running tamagui without custom config`
-          )
-          console.info(`\n\n    ${err.message}\n\n`)
-        } else {
-          if (SHOULD_DEBUG) {
-            console.error(err)
-          }
-        }
-      } else {
-        console.error(`Error loading tamagui.config.ts`, err)
-      }
+      regenerateConfigSync(props, info)
+    }
 
-      return {
-        components: [],
-        tamaguiConfig: null,
-        nameToPaths: {},
-      }
+    last[key] = {
+      ...info,
+      cached: true,
     }
+
+    return info as any
   } finally {
+    if (previousIsStatic === undefined) delete process.env.IS_STATIC
+    else process.env.IS_STATIC = previousIsStatic
+    if (previousIsServer === undefined) delete process.env.TAMAGUI_IS_SERVER
+    else process.env.TAMAGUI_IS_SERVER = previousIsServer
+    globalThis['__DEV__' as any] = previousDev
     unregister()
   }
 }
@@ -404,7 +458,7 @@ export async function getOptions({
 
 export function resolveWebOrNativeSpecificEntry(entry: string, platform?: string) {
   const workspaceRoot = resolve()
-  const resolved = require.resolve(entry, { paths: [workspaceRoot] })
+  const resolved = nodeRequire.resolve(entry, { paths: [workspaceRoot] })
   const ext = extname(resolved)
   const fileName = basename(resolved).replace(ext, '')
   const target = platform || process.env.TAMAGUI_TARGET || 'web'
@@ -458,9 +512,8 @@ export async function esbuildWatchFiles(entry: string, onChanged: () => void) {
     write: false,
 
     alias: {
-      '@react-native/normalize-color': '@tamagui/proxy-worm',
       'react-native-web': '@tamagui/react-native-web-lite',
-      'react-native': '@tamagui/proxy-worm',
+      'react-native': '@tamagui/react-native-web-lite',
     },
 
     plugins: [