@tamagui/static 3.0.0-beta.924.1 → 3.0.1

package/src/exports.ts

@@ -11,5 +11,8 @@ export * from './extractor/watchTamaguiConfig'
 export * from './registerRequire'
 export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat'
 export { esbundleTamaguiConfig } from './extractor/bundle'
+export { createTsconfigPathsMatcher } from './extractor/esbuildTsconfigPaths'
 export * from './getPragmaOptions'
 export * from './zero'
+
+export { generateConfigMarkdown } from './extractor/generateConfigMarkdown'

package/src/extractor/bundle.ts

@@ -65,6 +65,7 @@ function getESBuildConfig(
     resolvePlatformSpecificEntries,
     dangerouslyIgnoreStaticEvaluationModules = [],
     define: callerDefine,
+    conditions: callerConditions = [],
     ...options
   }: Props,
   platform: TamaguiPlatform,
@@ -109,9 +110,13 @@ function getESBuildConfig(
       ...platformDefines,
       ...callerDefine,
     },
+    conditions: [
+      'tamagui-compiler',
+      ...(platform === 'native' ? ['react-native'] : []),
+      ...callerConditions,
+    ],
     ...(platform === 'native'
       ? {
-          conditions: ['react-native'],
           mainFields: ['react-native', 'module', 'main'],
         }
       : {}),
@@ -282,13 +287,20 @@ export async function esbundleTamaguiConfig(
   // build to memory first, then write atomically (temp file + rename)
   // to prevent other threads from reading partially-written files.
   // The suffix is per call, not per process: two bundles of the same config in
-  // one process shared a temp path, and whichever renamed first left the other
-  // renaming a file that no longer existed.
+  // one process (or one worker thread) shared a temp path, and whichever
+  // renamed first left the other renaming a file that no longer existed.
   const tmpFile = `${props.outfile}.tmp.${process.pid}-${randomBytes(6).toString('hex')}`
-  const result = await esbuild.build({
-    ...config,
-    outfile: tmpFile,
-  })
+
+  const result = await esbuild
+    .build({
+      ...config,
+      outfile: tmpFile,
+    })
+    .catch(async (err) => {
+      // a failed build can still leave a partial temp file behind
+      await FS.remove(tmpFile).catch(() => {})
+      throw err
+    })
 
   // atomic rename prevents other threads from reading partial files
   await FS.rename(tmpFile, props.outfile)

package/src/extractor/bundleConfig.ts

@@ -504,7 +504,6 @@ export async function bundleConfig(props: TamaguiOptions, rebuild = false) {
                 props.platform !== 'native' ||
                 componentModule.startsWith('.') ||
                 isAbsolute(componentModule),
-              conditions: props.platform === 'native' ? ['react-native'] : undefined,
               external,
               outfile: componentOutPaths[i],
               target: 'node24',

package/src/extractor/esbuildTsconfigPaths.ts

@@ -1,103 +1,131 @@
 import type { Plugin } from 'esbuild'
+import {
+  createPathsMatcher,
+  getTsconfig,
+  parseTsconfig,
+  type TsConfigJsonResolved,
+  type TsConfigResult,
+} from 'get-tsconfig'
 import fs from 'node:fs'
 import path from 'node:path'
-import {
-  findConfigFile,
-  nodeModuleNameResolver,
-  parseJsonConfigFileContent,
-  readConfigFile,
-  sys,
-} from 'typescript'
 
 const name = 'tsconfig-paths'
 
-interface Tsconfig {
-  compilerOptions?: {
-    baseUrl?: string
-    paths?: Record<string, string[]>
+type Tsconfig = Pick<TsConfigJsonResolved, 'compilerOptions'>
+type TsconfigPathMatcher = (specifier: string) => string[]
+
+function loadTsconfig(
+  tsconfig?: Tsconfig | string,
+  cwd = process.cwd()
+): TsConfigResult | null {
+  if (!tsconfig) {
+    return getTsconfig(cwd) || getTsconfig(cwd, 'jsconfig.json')
   }
-}
 
-export function TsconfigPathsPlugin(): Plugin {
-  const compilerOptions = loadCompilerOptionsFromTsconfig()
+  if (typeof tsconfig === 'string') {
+    const configPath = path.resolve(cwd, tsconfig)
+    if (!fs.existsSync(configPath)) {
+      throw new Error(`Specified tsconfig file not found: ${configPath}`)
+    }
+    return { path: configPath, config: parseTsconfig(configPath) }
+  }
 
   return {
-    name,
-    setup({ onResolve }) {
-      onResolve({ filter: /.*/ }, (args) => {
-        // skip @tamagui packages - they should be externalized, not resolved via tsconfig
-        if (args.path.startsWith('@tamagui/')) {
-          return null
-        }
+    path: path.join(cwd, 'tsconfig.json'),
+    config: tsconfig,
+  }
+}
 
-        const paths = compilerOptions.paths || {}
-        const hasMatchingPath = Object.keys(paths).some((p) =>
-          new RegExp(p.replace('*', '\\w*')).test(args.path)
-        )
+export function createTsconfigPathsMatcher(
+  tsconfig?: Tsconfig | string,
+  cwd = process.cwd()
+): ((specifier: string) => string[]) | null {
+  const loaded = loadTsconfig(tsconfig, cwd)
+  return loaded ? createPathsMatcher(loaded) : null
+}
 
-        if (!hasMatchingPath) {
-          return null
-        }
+export function loadTsconfigPathMatcher(
+  tsconfig?: TsConfigJsonResolved | string
+): TsconfigPathMatcher {
+  let result: TsConfigResult | null
+  if (!tsconfig) {
+    result = getTsconfig(process.cwd()) || getTsconfig(process.cwd(), 'jsconfig.json')
+  } else if (typeof tsconfig === 'string') {
+    if (fs.existsSync(tsconfig)) {
+      const configPath = path.resolve(tsconfig)
+      result = { config: parseTsconfig(configPath), path: configPath }
+    } else {
+      throw new Error(`Specified tsconfig file not found: ${tsconfig}`)
+    }
+  } else {
+    result = { config: tsconfig, path: path.join(process.cwd(), 'tsconfig.json') }
+  }
 
-        const { resolvedModule } = nodeModuleNameResolver(
-          args.path,
-          args.importer,
-          compilerOptions,
-          sys
-        )
+  if (!result) return () => []
+  const matchPaths = createPathsMatcher(result)
+  const patterns = Object.keys(result.config.compilerOptions?.paths || {})
+  if (!matchPaths || patterns.length === 0) return () => []
+
+  return (specifier) => {
+    const matchesExplicitPath = patterns.some((pattern) => {
+      const wildcardIndex = pattern.indexOf('*')
+      if (wildcardIndex === -1) return pattern === specifier
+      return (
+        specifier.startsWith(pattern.slice(0, wildcardIndex)) &&
+        specifier.endsWith(pattern.slice(wildcardIndex + 1))
+      )
+    })
+    return matchesExplicitPath ? matchPaths(specifier) : []
+  }
+}
 
-        if (!resolvedModule) {
+export function TsconfigPathsPlugin(): Plugin {
+  const matchTsconfigPath = loadTsconfigPathMatcher()
+
+  return {
+    name,
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, async (args) => {
+        const pluginData = args.pluginData as
+          | { tamaguiTsconfigPaths?: boolean; tamaguiTsconfigPathsResolved?: boolean }
+          | undefined
+        if (
+          pluginData?.tamaguiTsconfigPaths ||
+          pluginData?.tamaguiTsconfigPathsResolved
+        ) {
           return null
         }
 
-        const { resolvedFileName } = resolvedModule
-
-        if (!resolvedFileName || resolvedFileName.endsWith('.d.ts')) {
+        // skip @tamagui packages - they should be externalized, not resolved via tsconfig
+        if (args.path.startsWith('@tamagui/')) {
           return null
         }
 
-        return {
-          path: resolvedFileName,
+        for (const candidate of matchTsconfigPath(args.path)) {
+          const resolved = await build.resolve(candidate, {
+            importer: args.importer,
+            kind: args.kind,
+            namespace: args.namespace,
+            pluginData: {
+              ...(args.pluginData && typeof args.pluginData === 'object'
+                ? args.pluginData
+                : {}),
+              tamaguiTsconfigPaths: true,
+              tamaguiTsconfigPathsResolved: true,
+            },
+            resolveDir: args.resolveDir,
+          })
+          if (
+            resolved.path &&
+            !resolved.path.endsWith('.d.ts') &&
+            resolved.errors.length === 0
+          ) {
+            return resolved
+          }
         }
+
+        return null
       })
     },
   }
 }
-
-export function loadCompilerOptionsFromTsconfig(tsconfig?: Tsconfig | string) {
-  if (!tsconfig) {
-    const configPath =
-      findConfigFile(process.cwd(), sys.fileExists, 'tsconfig.json') ||
-      findConfigFile(process.cwd(), sys.fileExists, 'jsconfig.json')
-
-    if (configPath) {
-      return parseTsconfig(configPath)
-    }
-    return {}
-  }
-
-  if (typeof tsconfig === 'string') {
-    if (fs.existsSync(tsconfig)) {
-      return parseTsconfig(tsconfig)
-    } else {
-      throw new Error(`Specified tsconfig file not found: ${tsconfig}`)
-    }
-  }
-
-  const baseDir = process.cwd()
-  const parsed = parseJsonConfigFileContent(tsconfig, sys, baseDir)
-  return parsed.options
-}
-
-function parseTsconfig(configFilePath: string) {
-  const configFile = readConfigFile(configFilePath, sys.readFile)
-  if (configFile.error) {
-    throw new Error(
-      `Error reading tsconfig file '${configFilePath}': ${configFile.error.messageText}`
-    )
-  }
-
-  const baseDir = path.dirname(configFilePath)
-  const parsed = parseJsonConfigFileContent(configFile.config, sys, baseDir)
-  return parsed.options
-}