@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/dist/esm/extractor/bundleConfig.mjs

@@ -0,0 +1,706 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Color, colorLog } from "@tamagui/cli-color";
+import esbuild from "esbuild";
+import FS from "fs-extra";
+import { readFile } from "node:fs/promises";
+import { registerRequire, setRequireResult } from "../registerRequire.mjs";
+import { addLocalExports } from "./addLocalExports.mjs";
+import { esbuildLoaderConfig, esbundleTamaguiConfig } from "./bundle.mjs";
+import { getTamaguiConfigPathFromOptionsConfig } from "./getTamaguiConfigPathFromOptionsConfig.mjs";
+import { requireTamaguiCore } from "../helpers/requireTamaguiCore.mjs";
+import { detectModuleFormat } from "./detectModuleFormat.mjs";
+import { staticEvaluationIgnorePlugin } from "../staticEvaluationIgnoredModules.mjs";
+
+const nodeRequire = createRequire(typeof __filename === "string" ? __filename : import.meta.url);
+const componentDisplayName = /* @__PURE__ */ Symbol.for("tamagui.componentDisplayName");
+const activeTempFiles = /* @__PURE__ */ new Set();
+function getDynamicEvalOutfile(name, format, contents) {
+	const ext = format === "esm" ? "mjs" : "cjs";
+	const hash = createHash("sha1").update(name).update("\0").update(format).update("\0").update(contents).digest("hex").slice(0, 10);
+	return join(process.cwd(), ".tamagui", `dynamic-eval-${hash}-${basename(name)}.${ext}`);
+}
+function getEsbuildStdinLoader(filePath) {
+	if (filePath.endsWith(".tsx")) return "tsx";
+	if (filePath.endsWith(".ts")) return "ts";
+	if (filePath.endsWith(".jsx")) return "jsx";
+	return "js";
+}
+function resolvePackageEntry(packageName, format) {
+	if (format === "cjs") {
+		return nodeRequire.resolve(packageName);
+	}
+	const packageJsonPath = nodeRequire.resolve(`${packageName}/package.json`);
+	const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	const packageRoot = dirname(packageJsonPath);
+	const exportEntry = packageJson.exports?.["."];
+	const esmEntry = exportEntry?.import || exportEntry?.module || exportEntry?.browser || packageJson.module;
+	if (typeof esmEntry === "string") {
+		return join(packageRoot, esmEntry);
+	}
+	return nodeRequire.resolve(packageName);
+}
+function cleanupTempFiles() {
+	for (const f of activeTempFiles) {
+		try {
+			unlinkSync(f);
+		} catch {}
+	}
+	activeTempFiles.clear();
+}
+process.on("exit", cleanupTempFiles);
+process.on("SIGINT", () => {
+	cleanupTempFiles();
+	process.exit();
+});
+process.on("SIGTERM", () => {
+	cleanupTempFiles();
+	process.exit();
+});
+const external = [
+	"@tamagui/core",
+	"@tamagui/web",
+	"react",
+	"react-dom",
+	"react-native-svg"
+];
+const esbuildExtraOptions = { define: { __DEV__: `${process.env.NODE_ENV === "development"}` } };
+const handleEsmFeaturesPlugin = {
+	name: "handle-esm-features",
+	setup(build) {
+		const isCjs = build.initialOptions.format === "cjs" || !build.initialOptions.format;
+		build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs)$/ }, (args) => {
+			if (!isCjs) {
+				return null;
+			}
+			if (args.path.includes("node_modules") && !args.path.includes("@tamagui")) {
+				return null;
+			}
+			let contents = readFileSync(args.path, "utf8");
+			let modified = false;
+			if (contents.includes("import.meta.env")) {
+				contents = contents.replace(/import\.meta\.env/g, "process.env");
+				modified = true;
+			}
+			if (contents.includes("import.meta.url")) {
+				contents = contents.replace(/import\.meta\.url/g, "\"\"");
+				modified = true;
+			}
+			if (contents.includes("import.meta.main")) {
+				contents = contents.replace(/import\.meta\.main/g, "false");
+				modified = true;
+			}
+			if (modified) {
+				return {
+					contents,
+					loader: args.path.endsWith(".tsx") ? "tsx" : args.path.endsWith(".ts") ? "ts" : args.path.endsWith(".jsx") ? "jsx" : "js"
+				};
+			}
+			return null;
+		});
+	}
+};
+const esbuildTransformOptions = {
+	target: "es2022",
+	format: "cjs",
+	jsx: "automatic",
+	platform: "node",
+	...esbuildExtraOptions
+};
+const esbuildOptions = { ...esbuildTransformOptions };
+const esbuildOptionsWithPlugins = {
+	...esbuildTransformOptions,
+	plugins: [handleEsmFeaturesPlugin]
+};
+let currentBundle = null;
+let currentBundleKey = "";
+let isBundling = false;
+let lastBundle = null;
+const waitForBundle = /* @__PURE__ */ new Set();
+function hasBundledConfigChanged() {
+	if (lastBundle === currentBundle) {
+		return false;
+	}
+	lastBundle = currentBundle;
+	return true;
+}
+let loadedConfig = null;
+const getLoadedConfig = () => loadedConfig;
+const setLoadedConfig = (config) => {
+	loadedConfig = config;
+};
+function getBundleKey(props) {
+	return JSON.stringify({
+		root: props.root,
+		components: props.components,
+		config: props.config,
+		platform: props.platform,
+		dangerouslyIgnoreStaticEvaluationModules: props.dangerouslyIgnoreStaticEvaluationModules
+	});
+}
+function getPackageNameFromPath(modulePath) {
+	const normalized = modulePath.split(sep).join("/");
+	const nodeModulesIndex = normalized.lastIndexOf("/node_modules/");
+	if (nodeModulesIndex === -1) {
+		return normalized.startsWith(".") || isAbsolute(normalized) ? void 0 : normalized;
+	}
+	const packagePath = normalized.slice(nodeModulesIndex + "/node_modules/".length);
+	const parts = packagePath.split("/");
+	return parts[0]?.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function findStaticEvaluationError(error) {
+	let current = error;
+	while (current instanceof Error) {
+		if ("code" in current && current.code === "TAMAGUI_STATIC_EVALUATION_ERROR" && "moduleName" in current && "importer" in current && "failedModule" in current && "reason" in current) {
+			return current;
+		}
+		current = current.cause;
+	}
+}
+async function getBundledConfig(props, rebuild = false) {
+	const bundleKey = getBundleKey(props);
+	if (isBundling) {
+		await new Promise((res) => {
+			waitForBundle.add(res);
+		});
+	}
+	if (!currentBundle || currentBundleKey !== bundleKey || rebuild) {
+		return await bundleConfig(props, rebuild);
+	}
+	return currentBundle;
+}
+global.tamaguiLastLoaded ||= 0;
+function updateLastLoaded(config, bundleKey) {
+	global.tamaguiLastLoaded = Date.now();
+	global.tamaguiLastBundledConfig = config;
+	global.tamaguiLastBundledConfigKey = bundleKey;
+}
+let hasBundledOnce = false;
+let hasLoggedBuild = false;
+const packageNameByDirectory = /* @__PURE__ */ new Map();
+function owningPackageName(file) {
+	let directory = dirname(file);
+	const walked = [];
+	while (true) {
+		const known = packageNameByDirectory.get(directory);
+		if (known !== void 0) {
+			for (const step of walked) packageNameByDirectory.set(step, known);
+			return known;
+		}
+		walked.push(directory);
+		const manifest = join(directory, "package.json");
+		if (existsSync(manifest)) {
+			let name = null;
+			try {
+				name = JSON.parse(readFileSync(manifest, "utf-8")).name ?? null;
+			} catch {
+				name = null;
+			}
+			for (const step of walked) packageNameByDirectory.set(step, name);
+			return name;
+		}
+		const parent = dirname(directory);
+		if (parent === directory) {
+			for (const step of walked) packageNameByDirectory.set(step, null);
+			return null;
+		}
+		directory = parent;
+	}
+}
+function requiredTamaguiPackageFiles() {
+	const found = [];
+	for (const file of Object.keys(nodeRequire.cache)) {
+		if (!file.includes(".")) continue;
+		const name = owningPackageName(file);
+		if (name === "tamagui" || name?.startsWith("@tamagui/")) found.push(file);
+	}
+	return found;
+}
+async function bundleConfig(props, rebuild = false) {
+	const bundleKey = getBundleKey(props);
+	const root = props.root || process.cwd();
+	const configEntry = props.config ? getTamaguiConfigPathFromOptionsConfig(props.config, root) : "";
+	const baseComponents = (props.components || []).filter((x) => x !== "@tamagui/core");
+	let componentOutPaths = [];
+	let componentImports = [];
+	if (!rebuild && global.tamaguiLastBundledConfig && global.tamaguiLastBundledConfigKey === bundleKey && Date.now() - global.tamaguiLastLoaded < 3e3) {
+		return global.tamaguiLastBundledConfig;
+	}
+	try {
+		isBundling = true;
+		const rootRequire = createRequire(join(root, "package.json"));
+		const tmpDir = join(root, ".tamagui");
+		const platformSuffix = (props.platform || "web") === "native" ? ".native" : ".web";
+		const configFormat = configEntry ? detectModuleFormat(configEntry) : "cjs";
+		const configExt = configFormat === "esm" ? ".mjs" : ".cjs";
+		const configOutPath = join(tmpDir, `tamagui.config${platformSuffix}${configExt}`);
+		const componentFormats = baseComponents.map((mod) => {
+			try {
+				let packageRoot = dirname(rootRequire.resolve(mod));
+				while (!existsSync(join(packageRoot, "package.json"))) {
+					const parent = dirname(packageRoot);
+					if (parent === packageRoot) {
+						return "cjs";
+					}
+					packageRoot = parent;
+				}
+				const pkg = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf-8"));
+				return pkg.type === "module" ? "esm" : "cjs";
+			} catch {
+				return "cjs";
+			}
+		});
+		componentOutPaths = baseComponents.map((componentModule, i) => {
+			const ext = componentFormats[i] === "esm" ? ".mjs" : ".cjs";
+			return join(tmpDir, `${componentModule.split(sep).join("-").replace(/[^a-z0-9]+/gi, "")}-components.config${platformSuffix}${ext}`);
+		});
+		let compilerDependencies = currentBundle?.dependencies ?? [];
+		if (process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("tamagui")) {
+			console.info(`Building config entry`, configEntry);
+		}
+		let shouldBuild = rebuild || !props.disableInitialBuild;
+		if (shouldBuild && props.config && !rebuild) {
+			const allOutFiles = [configOutPath, ...componentOutPaths];
+			try {
+				const stats = await Promise.all(allOutFiles.map((f) => FS.stat(f).catch(() => null)));
+				const allExistAndRecent = stats.every((s) => s !== null && Date.now() - s.mtimeMs < 3e3);
+				if (allExistAndRecent) {
+					shouldBuild = false;
+				}
+			} catch {}
+		}
+		if (shouldBuild) {
+			try {
+				await FS.ensureDir(tmpDir);
+			} catch {}
+			const start = Date.now();
+			const buildResults = await Promise.all([props.config ? esbundleTamaguiConfig({
+				entryPoints: [configEntry],
+				external,
+				outfile: configOutPath,
+				target: "node24",
+				format: configFormat,
+				absWorkingDir: root,
+				metafile: true,
+				dangerouslyIgnoreStaticEvaluationModules: props.dangerouslyIgnoreStaticEvaluationModules,
+				...esbuildExtraOptions
+			}, props.platform || "web") : null, ...baseComponents.map((componentModule, i) => {
+				return esbundleTamaguiConfig({
+					entryPoints: [componentModule],
+					resolvePlatformSpecificEntries: props.platform !== "native" || componentModule.startsWith(".") || isAbsolute(componentModule),
+					conditions: props.platform === "native" ? ["react-native"] : void 0,
+					external,
+					outfile: componentOutPaths[i],
+					target: "node24",
+					format: componentFormats[i],
+					absWorkingDir: root,
+					metafile: true,
+					dangerouslyIgnoreStaticEvaluationModules: props.dangerouslyIgnoreStaticEvaluationModules,
+					...esbuildExtraOptions
+				}, props.platform || "web");
+			})]);
+			compilerDependencies = buildResults.flatMap((result) => result?.metafile ? Object.keys(result.metafile.inputs).map((input) => resolve(root, input)) : []);
+			componentImports = buildResults.slice(1).map((result) => {
+				if (!result?.metafile) {
+					return [];
+				}
+				const entryPoint = Object.values(result.metafile.outputs).find((output) => output.entryPoint)?.entryPoint;
+				if (!entryPoint) {
+					return [];
+				}
+				return [...new Set(result.metafile.inputs[entryPoint]?.imports.map((item) => getPackageNameFromPath(item.path)).filter((moduleName) => Boolean(moduleName)) || [])];
+			});
+			if (!hasLoggedBuild && !props["_skipBuildLog"]) {
+				hasLoggedBuild = true;
+				colorLog(Color.FgYellow, `
+  \u27A1 [tamagui] built config, components, prompt (${Date.now() - start}ms)`);
+				if (process.env.DEBUG?.startsWith("tamagui")) {
+					colorLog(Color.Dim, `
+          Config     .${sep}${relative(root, configOutPath)}
+          Components ${componentOutPaths.map((p) => `.${sep}${relative(root, p)}`).join("\n             ")}
+          `);
+				}
+			}
+		}
+		if (hasBundledOnce) {
+			try {
+				delete nodeRequire.cache[nodeRequire.resolve(configOutPath)];
+			} catch {}
+			for (const p of componentOutPaths) {
+				try {
+					delete nodeRequire.cache[nodeRequire.resolve(p)];
+				} catch {}
+			}
+		} else {
+			hasBundledOnce = true;
+		}
+		let out;
+		if (configFormat === "esm") {
+			out = await import(`${pathToFileURL(configOutPath).href}?v=${FS.statSync(configOutPath).mtimeMs}`);
+		} else {
+			out = nodeRequire(configOutPath);
+		}
+		let config = out.default || out || out.config;
+		if (config && config.config && !config.tokens) {
+			config = config.config;
+		}
+		if (!config) {
+			throw new Error(`No config: ${config}`);
+		}
+		loadedConfig = config;
+		if (!config.parsed) {
+			const { createTamagui } = requireTamaguiCore(props.platform || "web");
+			config = createTamagui(config);
+		} else {
+			const { installTamaguiConfig } = requireTamaguiCore(props.platform || "web");
+			installTamaguiConfig(config);
+		}
+		if (props.outputCSS) {
+			await writeTamaguiCSS(props.outputCSS, config);
+		}
+		if (rebuild) {
+			delete cacheComponents[componentOutPaths.join("\0")];
+		}
+		let components = await loadComponents({
+			...props,
+			components: componentOutPaths
+		});
+		if (!components) {
+			throw new Error(`No components found: ${componentOutPaths.join(", ")}`);
+		}
+		for (const component of components) {
+			component.moduleName = baseComponents[componentOutPaths.indexOf(component.moduleName)] || component.moduleName;
+			if (!component.moduleName) {
+				if (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) {
+					console.warn(`\u26A0\uFE0F no module name found: ${component.moduleName} ${JSON.stringify(baseComponents)} in ${JSON.stringify(componentOutPaths)}`);
+				}
+			}
+		}
+		if (process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("tamagui")) {
+			console.info("Loaded components", components);
+		}
+		const res = {
+			components,
+			nameToPaths: {},
+			tamaguiConfig: config,
+			dependencies: compilerDependencies,
+			stampSources: [
+				...configEntry ? [configOutPath] : [],
+				...componentOutPaths,
+				...requiredTamaguiPackageFiles()
+			]
+		};
+		currentBundle = res;
+		currentBundleKey = bundleKey;
+		updateLastLoaded(res, bundleKey);
+		return res;
+	} catch (err) {
+		const failure = findStaticEvaluationError(err);
+		const componentIndex = failure ? componentOutPaths.findIndex((outputPath) => outputPath === failure.moduleName || outputPath === failure.importer) : -1;
+		const configuredComponent = baseComponents[componentIndex];
+		if (failure && configuredComponent) {
+			const configuredImport = configuredComponent.startsWith(".") || isAbsolute(configuredComponent) ? componentImports[componentIndex]?.[0] || configuredComponent : configuredComponent;
+			throw new Error(`[tamagui] Static evaluation could not proceed for configured component "${configuredComponent}".
+The import "${configuredImport}" reached module "${failure.failedModule}", which failed during Node evaluation.
+Reason: ${failure.reason}
+Fix the failing module so it can run in Node during the build. If "${configuredImport}" is runtime-only and none of its exports create your Tamagui config or components, add "${configuredImport}" to dangerouslyIgnoreStaticEvaluationModules in tamagui.build.ts.`, { cause: err });
+		}
+		throw new Error(`[tamagui] Static evaluation could not proceed for configured Tamagui config "${configEntry || "<default config>"}".
+Reason: ${err instanceof Error ? err.message : String(err)}
+Fix the failing import so it can run in Node during the build. If it is runtime-only and none of its exports create your Tamagui config or components, add its exact module name to dangerouslyIgnoreStaticEvaluationModules in tamagui.build.ts.`, { cause: err });
+	} finally {
+		isBundling = false;
+		waitForBundle.forEach((cb) => cb());
+		waitForBundle.clear();
+	}
+}
+async function writeTamaguiCSS(outputCSS, config) {
+	const flush = async () => {
+		colorLog(Color.FgYellow, `  \u27A1 [tamagui] output css: ${outputCSS}`);
+		await FS.mkdirp(dirname(outputCSS));
+		await FS.writeFile(outputCSS, css);
+	};
+	const css = config.getCSS();
+	if (typeof css !== "string") {
+		throw new Error(`Invalid CSS: ${typeof css} ${css}`);
+	}
+	try {
+		if (existsSync(outputCSS) && await readFile(outputCSS, "utf8") === css) {} else {
+			await flush();
+		}
+	} catch (err) {
+		console.info("Error writing themes", err);
+	}
+}
+async function loadComponents(props, forceExports = false) {
+	const coreComponents = getCoreComponentsSync(props);
+	const otherComponents = await loadComponentsInner(props, forceExports);
+	return [...coreComponents, ...otherComponents];
+}
+function loadComponentsSync(props, forceExports = false) {
+	const coreComponents = getCoreComponentsSync(props);
+	const otherComponents = loadComponentsInnerSync(props, forceExports);
+	return [...coreComponents, ...otherComponents];
+}
+function getCoreComponentsSync(props) {
+	const loaded = loadComponentsInnerSync({
+		...props,
+		components: ["@tamagui/core"]
+	});
+	if (!loaded[0]) {
+		throw new Error(`Core should always load`);
+	}
+	return [{
+		...loaded[0],
+		moduleName: "@tamagui/core"
+	}];
+}
+async function loadComponentsInner(props, forceExports = false) {
+	const componentsModules = props.components || [];
+	const key = JSON.stringify([
+		props.platform,
+		componentsModules,
+		props.dangerouslyIgnoreStaticEvaluationModules
+	]);
+	if (!forceExports && cacheComponents[key]) {
+		return cacheComponents[key];
+	}
+	const { unregister } = registerRequire(props.platform || "web", { ignoredModules: props.dangerouslyIgnoreStaticEvaluationModules });
+	try {
+		const results = [];
+		for (const name of componentsModules) {
+			const extension = extname(name);
+			const isLocal = Boolean(extension);
+			const isDynamic = isLocal && forceExports;
+			const format = isLocal ? detectModuleFormat(name) : "cjs";
+			const fileContents = isDynamic ? readFileSync(name, "utf-8") : "";
+			let loadModule = name;
+			let writtenContents = fileContents;
+			const attemptLoad = async ({ forceExports: forceExports2 = false } = {}) => {
+				if (isDynamic) {
+					writtenContents = forceExports2 ? addLocalExports(esbuildit(fileContents, "modern"), name) : fileContents;
+					loadModule = getDynamicEvalOutfile(name, format, writtenContents);
+					FS.ensureDirSync(dirname(loadModule));
+					activeTempFiles.add(loadModule);
+					await esbuild.build({
+						...esbuildOptionsWithPlugins,
+						plugins: [...esbuildOptionsWithPlugins.plugins || [], staticEvaluationIgnorePlugin(props.dangerouslyIgnoreStaticEvaluationModules)],
+						format,
+						outfile: loadModule,
+						stdin: {
+							contents: writtenContents,
+							resolveDir: dirname(name),
+							sourcefile: name,
+							loader: getEsbuildStdinLoader(name)
+						},
+						alias: {
+							"react-native": resolvePackageEntry("@tamagui/react-native-web-lite", format),
+							"@tamagui/react-native-web-lite": resolvePackageEntry("@tamagui/react-native-web-lite", format),
+							"@tamagui/react-native-web-internals": resolvePackageEntry("@tamagui/react-native-web-internals", format)
+						},
+						bundle: true,
+						packages: "external",
+						allowOverwrite: true,
+						sourcemap: false,
+						loader: esbuildLoaderConfig
+					});
+				}
+				if (process.env.DEBUG === "tamagui") {
+					console.info(`loadModule`, loadModule, format);
+				}
+				let moduleResult;
+				if (format === "esm") {
+					moduleResult = await import(`${pathToFileURL(loadModule).href}?v=${FS.statSync(loadModule).mtimeMs}`);
+				} else {
+					moduleResult = nodeRequire(loadModule);
+				}
+				if (!forceExports2) {
+					setRequireResult(name, moduleResult);
+				}
+				const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
+				return {
+					moduleName: name,
+					nameToInfo
+				};
+			};
+			const dispose = () => {
+				if (isDynamic) {
+					FS.removeSync(loadModule);
+					activeTempFiles.delete(loadModule);
+				}
+			};
+			let loaded;
+			try {
+				loaded = await attemptLoad({ forceExports: isDynamic });
+			} catch (err) {
+				if (!isDynamic) {
+					throw new Error(`[tamagui] Failed to statically evaluate configured component module "${name}". ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+				}
+				writtenContents = fileContents;
+				if (process.env.DEBUG?.startsWith("tamagui")) {
+					console.info(`Error adding local component exports`, err);
+				}
+				try {
+					loaded = await attemptLoad({ forceExports: false });
+				} catch (err2) {
+					throw new Error(`[tamagui] Failed to statically evaluate configured component module "${name}" at "${loadModule}". ${err2 instanceof Error ? err2.message : String(err2)}`, { cause: err2 });
+				}
+			} finally {
+				dispose();
+			}
+			if (Array.isArray(loaded)) {
+				results.push(...loaded);
+			} else if (loaded) {
+				results.push(loaded);
+			}
+		}
+		cacheComponents[key] = results;
+		return results;
+	} finally {
+		unregister();
+	}
+}
+function loadComponentsInnerSync(props, forceExports = false) {
+	const componentsModules = props.components || [];
+	const key = JSON.stringify([
+		props.platform,
+		componentsModules,
+		props.dangerouslyIgnoreStaticEvaluationModules
+	]);
+	if (!forceExports && cacheComponents[key]) {
+		return cacheComponents[key];
+	}
+	const { unregister } = registerRequire(props.platform || "web", { ignoredModules: props.dangerouslyIgnoreStaticEvaluationModules });
+	try {
+		const info = componentsModules.flatMap((name) => {
+			const extension = extname(name);
+			const isLocal = Boolean(extension);
+			const isDynamic = isLocal && forceExports;
+			const fileContents = isDynamic ? readFileSync(name, "utf-8") : "";
+			let loadModule = name;
+			let writtenContents = fileContents;
+			function attemptLoad({ forceExports: forceExports2 = false } = {}) {
+				if (isDynamic) {
+					writtenContents = forceExports2 ? addLocalExports(esbuildit(fileContents, "modern"), name) : fileContents;
+					loadModule = getDynamicEvalOutfile(name, "cjs", writtenContents);
+					FS.ensureDirSync(dirname(loadModule));
+					activeTempFiles.add(loadModule);
+					esbuild.buildSync({
+						...esbuildOptions,
+						outfile: loadModule,
+						stdin: {
+							contents: writtenContents,
+							resolveDir: dirname(name),
+							sourcefile: name,
+							loader: getEsbuildStdinLoader(name)
+						},
+						alias: {
+							"react-native": resolvePackageEntry("@tamagui/react-native-web-lite", "esm"),
+							"@tamagui/react-native-web-lite": resolvePackageEntry("@tamagui/react-native-web-lite", "esm"),
+							"@tamagui/react-native-web-internals": resolvePackageEntry("@tamagui/react-native-web-internals", "esm")
+						},
+						bundle: true,
+						packages: "external",
+						allowOverwrite: true,
+						sourcemap: false,
+						loader: esbuildLoaderConfig
+					});
+				}
+				if (process.env.DEBUG === "tamagui") {
+					console.info(`loadModule`, loadModule, nodeRequire.resolve(loadModule));
+				}
+				const moduleResult = nodeRequire(loadModule);
+				if (!forceExports2) {
+					setRequireResult(name, moduleResult);
+				}
+				const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
+				return {
+					moduleName: name,
+					nameToInfo
+				};
+			}
+			const dispose = () => {
+				if (isDynamic) {
+					FS.removeSync(loadModule);
+					activeTempFiles.delete(loadModule);
+				}
+			};
+			try {
+				const res = attemptLoad({ forceExports: isDynamic });
+				return res;
+			} catch (err) {
+				if (!isDynamic) {
+					throw new Error(`[tamagui] Failed to statically evaluate configured component module "${name}". ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+				}
+				writtenContents = fileContents;
+				if (process.env.DEBUG?.startsWith("tamagui")) {
+					console.info(`Error adding local component exports`, err);
+				}
+			} finally {
+				dispose();
+			}
+			try {
+				return attemptLoad({ forceExports: false });
+			} catch (err) {
+				throw new Error(`[tamagui] Failed to statically evaluate configured component module "${name}" at "${loadModule}". ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+			} finally {
+				dispose();
+			}
+		});
+		cacheComponents[key] = info;
+		return info;
+	} finally {
+		unregister();
+	}
+}
+const esbuildit = (src, target) => {
+	return esbuild.transformSync(src, {
+		...esbuildTransformOptions,
+		...target === "modern" && {
+			target: "es2022",
+			jsx: "automatic",
+			loader: "tsx",
+			platform: "neutral",
+			format: "esm"
+		}
+	}).code;
+};
+function getComponentStaticConfigByName(name, exported) {
+	const components = {};
+	if (!exported || typeof exported !== "object" || Array.isArray(exported)) {
+		throw new Error(`Invalid export from package ${name}: ${typeof exported}`);
+	}
+	for (const key in exported) {
+		const found = getTamaguiComponent(key, exported[key]);
+		if (found) {
+			const { Component, ...sc } = found.staticConfig;
+			components[key] = {
+				staticConfig: sc,
+				...found.displayName && { displayName: found.displayName }
+			};
+		}
+	}
+	return components;
+}
+function getTamaguiComponent(name, Component) {
+	if (name[0].toUpperCase() !== name[0]) {
+		return;
+	}
+	const staticConfig = Component?.staticConfig;
+	if (staticConfig) {
+		return {
+			staticConfig,
+			displayName: Component[componentDisplayName]
+		};
+	}
+}
+function interopDefaultExport(mod) {
+	return mod?.default ?? mod;
+}
+const cacheComponents = {};
+
+export { bundleConfig, esbuildOptions, esbuildOptionsWithPlugins, getBundledConfig, getComponentStaticConfigByName, getLoadedConfig, hasBundledConfigChanged, loadComponents, loadComponentsInner, loadComponentsInnerSync, loadComponentsSync, setLoadedConfig, writeTamaguiCSS };
+//# sourceMappingURL=bundleConfig.mjs.map