@tamagui/metro-plugin 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/index.cjs

@@ -0,0 +1,102 @@
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+	METRO_COMPILER_CACHE_VERSION: () => import_compilerCache2.METRO_COMPILER_CACHE_VERSION,
+	MetroCompilerCache: () => import_compilerCache2.MetroCompilerCache,
+	MetroCompilerCacheError: () => import_compilerCache2.MetroCompilerCacheError,
+	defaultMetroCompilerCacheRoot: () => import_compilerCache2.defaultMetroCompilerCacheRoot,
+	getMetroCompilerFrontend: () => getMetroCompilerFrontend,
+	withTamagui: () => withTamagui
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+var import_static = __toESM(require("@tamagui/static"), 1);
+var import_compilerCache = require("./compilerCache.cjs");
+var import_zeroSerializer = require("./zeroSerializer.cjs");
+var import_zeroRuntime = require("./zeroRuntime.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+var import_frontend = require("./frontend.cjs");
+var import_transformer = require("./transformer.cjs");
+var import_transformOptions = require("./transformOptions.cjs");
+var import_compilerCache2 = require("./compilerCache.cjs");
+const import_meta = {};
+const frontends = /* @__PURE__ */ new WeakMap();
+const { loadTamaguiBuildConfigSync } = import_static.default;
+const requireFromPlugin = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+function getMetroCompilerFrontend(metroConfig) {
+	return frontends.get(metroConfig) ?? null;
+}
+function withTamagui(metroConfig, optionsIn) {
+	const { compilerCacheRoot, zeroIslandBuild, zeroPublicDir = "public", ...tamaguiOptionsIn } = optionsIn || {};
+	const options = loadTamaguiBuildConfigSync(tamaguiOptionsIn);
+	metroConfig.resolver = {
+		...metroConfig.resolver,
+		sourceExts: [.../* @__PURE__ */ new Set([...metroConfig.resolver?.sourceExts || [], "css"])]
+	};
+	metroConfig.transformer = {
+		...metroConfig.transformer,
+		tamagui: options
+	};
+	const zeroProjectRoot = metroConfig.projectRoot ?? process.cwd();
+	const zero = (0, import_zeroRuntime.createMetroZeroController)(options, zeroProjectRoot, zeroIslandBuild ?? null, zeroPublicDir);
+	if (zero?.isEnforcing) {
+		(0, import_zeroSerializer.applyMetroZeroRuntime)(metroConfig, zero);
+	}
+	if (!options.disable) {
+		const projectRoot = metroConfig.projectRoot ?? process.cwd();
+		const requireFromProject = (0, import_node_module.createRequire)((0, import_node_path.join)(projectRoot, "package.json"));
+		const configuredBabelTransformerPath = metroConfig.transformer.babelTransformerPath ?? "metro-babel-transformer";
+		const originalBabelTransformerPath = (0, import_node_path.isAbsolute)(configuredBabelTransformerPath) ? configuredBabelTransformerPath : requireFromProject.resolve(configuredBabelTransformerPath);
+		const cacheBaseRoot = compilerCacheRoot ?? (0, import_compilerCache.defaultMetroCompilerCacheRoot)(projectRoot);
+		const frontend = new import_frontend.MetroCompilerFrontend({
+			projectRoot,
+			resolver: metroConfig.resolver,
+			transformer: metroConfig.transformer,
+			tamaguiOptions: options,
+			originalBabelTransformerPath,
+			cacheRoot: cacheBaseRoot,
+			zero,
+			reportDiagnostic(diagnostic) {
+				console.warn((0, import_diagnostics.formatMetroCompilerDiagnostic)(diagnostic, projectRoot));
+			}
+		});
+		const transformerFactoryPath = requireFromPlugin.resolve("@tamagui/metro-plugin/transformer");
+		metroConfig.transformer.babelTransformerPath = (0, import_transformer.writeMetroCompilerTransformerBridge)(transformerFactoryPath, {
+			cacheBaseRoot,
+			originalBabelTransformerPath,
+			projectRoot,
+			runtimeLiteral: zero?.isEnforcing && !zero.islandBuild ? "zero" : "full"
+		});
+		const userGetTransformOptions = metroConfig.transformer.getTransformOptions;
+		metroConfig.transformer.getTransformOptions = (0, import_transformOptions.composeMetroGetTransformOptions)(frontend, userGetTransformOptions);
+		frontends.set(metroConfig, frontend);
+	}
+	return metroConfig;
+}

package/dist/cjs/lowering.cjs

@@ -0,0 +1,109 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lowering_exports = {};
+__export(lowering_exports, { applyMetroCompilerPlan: () => applyMetroCompilerPlan });
+module.exports = __toCommonJS(lowering_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_trace_mapping = require("@jridgewell/trace-mapping");
+var import_babel = require("./babel.cjs");
+function lineStarts(source) {
+	const starts = [0];
+	for (let index = 0; index < source.length; index++) {
+		if (source.charCodeAt(index) === 10) starts.push(index + 1);
+	}
+	return starts;
+}
+function sourceIndex(starts, position) {
+	return (starts[position.line - 1] ?? starts.at(-1) ?? 0) + position.column;
+}
+function tracePosition(loweredMap, position) {
+	const original = (0, import_trace_mapping.originalPositionFor)(loweredMap, {
+		line: position.line,
+		column: position.column,
+		bias: import_trace_mapping.GREATEST_LOWER_BOUND
+	});
+	return original.line == null || original.column == null ? null : {
+		line: original.line,
+		column: original.column
+	};
+}
+function remapAstLocations(ast, loweredMap, source, filename) {
+	const starts = lineStarts(source);
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (!value || typeof value !== "object" || seen.has(value)) return;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		const node = value;
+		const loc = node.loc;
+		if (loc?.start && loc?.end) {
+			const start = tracePosition(loweredMap, loc.start);
+			const end = tracePosition(loweredMap, loc.end);
+			if (start && end) {
+				node.start = sourceIndex(starts, start);
+				node.end = sourceIndex(starts, end);
+				node.loc = {
+					...loc,
+					start,
+					end,
+					filename
+				};
+			}
+		}
+		for (const [key, child] of Object.entries(node)) {
+			if (key === "loc" || key === "tokens") continue;
+			visit(child);
+		}
+	};
+	visit(ast);
+}
+async function applyMetroCompilerPlan(args, plan, transformerPath) {
+	const output = (0, import_compiler_core.applyLoweredModule)(args.src, (0, import_compiler_core.resolvedModuleId)(args.filename), plan);
+	if (!output.changed || !output.map) {
+		return {
+			compiled: await (0, import_babel.compileWithUserBabel)(transformerPath, args),
+			lowering: {
+				applied: false,
+				diagnostics: plan.diagnostics,
+				sourceMapComposed: false,
+				stats: plan.stats
+			}
+		};
+	}
+	const compiled = await (0, import_babel.compileWithUserBabel)(transformerPath, {
+		...args,
+		src: output.code
+	});
+	remapAstLocations(compiled.result.ast, new import_trace_mapping.TraceMap(output.map), args.src, args.filename);
+	return {
+		compiled,
+		lowering: {
+			applied: true,
+			diagnostics: plan.diagnostics,
+			sourceMapComposed: true,
+			stats: plan.stats
+		}
+	};
+}

package/dist/cjs/metroResolver.cjs

@@ -0,0 +1,197 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metroResolver_exports = {};
+__export(metroResolver_exports, {
+	createMetroCompilerResolver: () => createMetroCompilerResolver,
+	isCompilerSourceFile: () => isCompilerSourceFile,
+	moduleSpecifiersFromAst: () => moduleSpecifiersFromAst
+});
+module.exports = __toCommonJS(metroResolver_exports);
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function findClosestPackage(path) {
+	let directory = (0, import_node_fs.existsSync)(path) && (0, import_node_fs.statSync)(path).isDirectory() ? path : (0, import_node_path.dirname)(path);
+	const root = (0, import_node_path.parse)(directory).root;
+	while (true) {
+		const packagePath = (0, import_node_path.join)(directory, "package.json");
+		if ((0, import_node_fs.existsSync)(packagePath)) {
+			try {
+				return {
+					rootPath: directory,
+					packageJson: JSON.parse((0, import_node_fs.readFileSync)(packagePath, "utf8")),
+					packageRelativePath: (0, import_node_path.relative)(directory, path)
+				};
+			} catch {
+				return null;
+			}
+		}
+		if (directory === root || directory.endsWith(`${(0, import_node_path.join)("node_modules")}`)) {
+			return null;
+		}
+		directory = (0, import_node_path.dirname)(directory);
+	}
+}
+function lookup(projectRoot, path) {
+	const absolutePath = (0, import_node_path.isAbsolute)(path) ? path : (0, import_node_path.resolve)(projectRoot, path);
+	try {
+		const stat = (0, import_node_fs.lstatSync)(absolutePath);
+		const realPath = (0, import_node_fs.realpathSync)(absolutePath);
+		return {
+			exists: true,
+			type: stat.isDirectory() ? "d" : "f",
+			realPath
+		};
+	} catch {
+		return { exists: false };
+	}
+}
+function moduleSpecifiersFromAst(ast) {
+	const specifiers = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	function add(value, isESMImport) {
+		if (typeof value !== "string") return;
+		specifiers.set(value, (specifiers.get(value) ?? false) || isESMImport);
+	}
+	function visit(value) {
+		if (!value || typeof value !== "object") return;
+		if (seen.has(value)) return;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (const child of value) visit(child);
+			return;
+		}
+		const node = value;
+		if (node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportNamedDeclaration") {
+			add(node.source?.value, true);
+		} else if (node.type === "CallExpression") {
+			const first = node.arguments?.[0];
+			if (node.callee?.type === "Import") {
+				add(first?.value, true);
+			} else if (node.callee?.type === "Identifier" && node.callee.name === "require") {
+				add(first?.value, false);
+			}
+		}
+		for (const [key, child] of Object.entries(node)) {
+			if (key === "loc" || key === "comments" || key === "tokens") continue;
+			visit(child);
+		}
+	}
+	visit(ast);
+	return [...specifiers].sort(([left], [right]) => compareCodeUnits(left, right)).map(([specifier, isESMImport]) => ({
+		specifier,
+		isESMImport
+	}));
+}
+function createMetroCompilerResolver(config) {
+	const requireFromProject = (0, import_node_module.createRequire)((0, import_node_path.join)(config.projectRoot, "package.json"));
+	const resolverPackage = requireFromProject("metro-resolver/package.json");
+	if (!resolverPackage.version.startsWith("0.84.")) {
+		throw new Error(`@tamagui/metro-plugin requires the Metro 0.84 resolver contract, found ${resolverPackage.version}`);
+	}
+	const resolverModule = requireFromProject("metro-resolver");
+	const metroResolve = resolverModule.resolve;
+	const createDefaultContextModule = requireFromProject("metro-resolver/private/createDefaultContext");
+	const createDefaultContext = createDefaultContextModule.default ?? createDefaultContextModule;
+	const resolver = config.resolver ?? {};
+	const fileSystemLookup = (path) => lookup(config.projectRoot, path);
+	const getPackage = (packagePath) => {
+		try {
+			return JSON.parse((0, import_node_fs.readFileSync)(packagePath, "utf8"));
+		} catch {
+			return null;
+		}
+	};
+	return {
+		version: resolverPackage.version,
+		resolve(importer, dependency, platform) {
+			const dependencyDescriptor = {
+				name: dependency.specifier,
+				data: {
+					asyncType: null,
+					isESMImport: dependency.isESMImport,
+					key: dependency.specifier,
+					locs: []
+				}
+			};
+			const context = createDefaultContext({
+				allowHaste: false,
+				assetExts: new Set(resolver.assetExts ?? []),
+				customResolverOptions: {},
+				dev: true,
+				disableHierarchicalLookup: resolver.disableHierarchicalLookup ?? false,
+				doesFileExist: (path) => fileSystemLookup(path).type === "f",
+				extraNodeModules: resolver.extraNodeModules ?? null,
+				fileSystemLookup,
+				getPackage,
+				getPackageForModule: findClosestPackage,
+				isESMImport: dependency.isESMImport,
+				mainFields: resolver.resolverMainFields ?? [
+					"react-native",
+					"browser",
+					"main"
+				],
+				nodeModulesPaths: resolver.nodeModulesPaths ?? [],
+				originModulePath: importer,
+				preferNativePlatform: true,
+				projectRoot: config.projectRoot,
+				resolveAsset: () => null,
+				resolveHasteModule: () => null,
+				resolveHastePackage: () => null,
+				resolveRequest: resolver.resolveRequest ?? null,
+				sourceExts: resolver.sourceExts ?? [
+					"js",
+					"jsx",
+					"json",
+					"ts",
+					"tsx"
+				],
+				unstable_conditionNames: resolver.unstable_conditionNames ?? [],
+				unstable_conditionsByPlatform: resolver.unstable_conditionsByPlatform ?? {},
+				unstable_enablePackageExports: resolver.unstable_enablePackageExports ?? true,
+				unstable_logWarning: (message) => config.resolver?.unstable_logWarning?.(message)
+			}, dependencyDescriptor);
+			const result = metroResolve(context, dependency.specifier, platform);
+			if (result.type === "empty") return null;
+			if (result.type !== "sourceFile" || !result.filePath) return null;
+			const resolvedId = (0, import_node_fs.realpathSync)(result.filePath);
+			return {
+				specifier: dependency.specifier,
+				resolvedId,
+				external: resolvedId.includes(`${(0, import_node_path.join)("node_modules")}`)
+			};
+		}
+	};
+}
+function isCompilerSourceFile(path) {
+	return [
+		".js",
+		".jsx",
+		".mjs",
+		".cjs",
+		".ts",
+		".tsx"
+	].includes((0, import_node_path.extname)(path));
+}

package/dist/cjs/transformOptions.cjs

@@ -0,0 +1,35 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformOptions_exports = {};
+__export(transformOptions_exports, { composeMetroGetTransformOptions: () => composeMetroGetTransformOptions });
+module.exports = __toCommonJS(transformOptions_exports);
+function composeMetroGetTransformOptions(frontend, userGetTransformOptions) {
+	return async function(entryFiles, transformOptions, getDependencies) {
+		const userOptions = userGetTransformOptions ? await userGetTransformOptions.call(this, entryFiles, transformOptions, getDependencies) : { transform: {} };
+		await frontend.ensureValidCache({
+			...transformOptions,
+			entryFiles,
+			transform: userOptions.transform ?? {}
+		});
+		return userOptions;
+	};
+}

package/dist/cjs/transformer.cjs

@@ -0,0 +1,142 @@
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformer_exports = {};
+__export(transformer_exports, {
+	createMetroCompilerTransformer: () => createMetroCompilerTransformer,
+	writeMetroCompilerTransformerBridge: () => writeMetroCompilerTransformerBridge
+});
+module.exports = __toCommonJS(transformer_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_babel = require("./babel.cjs");
+var import_compilerCache = require("./compilerCache.cjs");
+var import_diagnostics = require("./diagnostics.cjs");
+var import_metroResolver = require("./metroResolver.cjs");
+var import_lowering = require("./lowering.cjs");
+function createMetroCompilerTransformer(config) {
+	const moduleIdCache = /* @__PURE__ */ new Map();
+	const missWarned = /* @__PURE__ */ new Set();
+	function cacheModuleId(filename) {
+		let id = moduleIdCache.get(filename);
+		if (!id) {
+			const absolute = (0, import_node_path.isAbsolute)(filename) ? filename : (0, import_node_path.resolve)(config.projectRoot, filename);
+			try {
+				id = (0, import_node_fs.realpathSync)(absolute);
+			} catch {
+				id = absolute;
+			}
+			moduleIdCache.set(filename, id);
+		}
+		return id;
+	}
+	function planEligible(moduleId) {
+		return (0, import_metroResolver.isCompilerSourceFile)(moduleId) && !moduleId.includes(`${(0, import_node_path.join)("node_modules")}`) && (0, import_node_fs.existsSync)(moduleId);
+	}
+	const runtimeLiteral = config.runtimeLiteral ?? "full";
+	const inlineRuntimeLiteral = ({ types }) => ({ visitor: { MemberExpression(nodePath) {
+		const node = nodePath.node;
+		if (node.computed || !types.isIdentifier(node.property, { name: "TAMAGUI_RUNTIME" }) || !types.isMemberExpression(node.object) || node.object.computed || !types.isIdentifier(node.object.object, { name: "process" }) || !types.isIdentifier(node.object.property, { name: "env" })) {
+			return;
+		}
+		nodePath.replaceWith(types.stringLiteral(runtimeLiteral));
+	} } });
+	return {
+		async transform(argsIn) {
+			const args = {
+				...argsIn,
+				plugins: [...argsIn.plugins ?? [], inlineRuntimeLiteral]
+			};
+			const platform = typeof args.options.platform === "string" ? args.options.platform : "default";
+			const cache = new import_compilerCache.MetroCompilerCache((0, import_node_path.join)(config.cacheBaseRoot, platform));
+			let tamagui = {
+				cacheHit: false,
+				diagnostics: []
+			};
+			const moduleId = cacheModuleId(args.filename);
+			try {
+				const entry = await cache.read(moduleId, args.src, (reason, detail) => {
+					if (missWarned.has(moduleId) || !planEligible(moduleId)) return;
+					missWarned.add(moduleId);
+					const diagnostic = (0, import_diagnostics.metroDiagnostic)("metro/plan-miss", `Lowering plan lookup missed for ${moduleId} (${reason}${detail ? `: ${detail}` : ""}); module ships unlowered`, { moduleId });
+					tamagui.diagnostics.push(diagnostic);
+					console.warn((0, import_diagnostics.formatMetroCompilerDiagnostic)(diagnostic, config.projectRoot));
+				});
+				if (entry) {
+					try {
+						const lowered = await (0, import_lowering.applyMetroCompilerPlan)({
+							...args,
+							filename: moduleId
+						}, entry.plan, config.originalBabelTransformerPath);
+						return {
+							...lowered.compiled.result,
+							metadata: {
+								...lowered.compiled.result.metadata,
+								tamagui: {
+									cacheHit: true,
+									diagnostics: entry.diagnostics,
+									lowering: lowered.lowering
+								}
+							}
+						};
+					} catch (error) {
+						const diagnostic = (0, import_diagnostics.metroDiagnostic)("metro/cache-corrupt", `Cached lowering plan for ${args.filename} could not be applied: ${error instanceof Error ? error.message : String(error)}`, { moduleId });
+						tamagui = {
+							cacheHit: true,
+							diagnostics: [...entry.diagnostics, diagnostic]
+						};
+						console.warn((0, import_diagnostics.formatMetroCompilerDiagnostic)(diagnostic, config.projectRoot));
+					}
+				}
+			} catch (error) {
+				if (!(error instanceof import_compilerCache.MetroCompilerCacheError)) throw error;
+				tamagui.diagnostics.push(error.diagnostic);
+				console.warn((0, import_diagnostics.formatMetroCompilerDiagnostic)(error.diagnostic, config.projectRoot));
+			}
+			const compiled = await (0, import_babel.compileWithUserBabel)(config.originalBabelTransformerPath, args);
+			return {
+				...compiled.result,
+				metadata: {
+					...compiled.result.metadata,
+					tamagui
+				}
+			};
+		},
+		getCacheKey() {
+			return (0, import_node_crypto.createHash)("sha256").update(`tamagui-metro-compiler-v${import_compilerCache.METRO_COMPILER_CACHE_VERSION}`).update("\0").update(runtimeLiteral).update("\0").update((0, import_babel.userBabelCacheKey)(config.originalBabelTransformerPath)).digest("hex");
+		}
+	};
+}
+function writeMetroCompilerTransformerBridge(transformerFactoryPath, config) {
+	const serializedConfig = JSON.stringify(config);
+	const bridgeHash = (0, import_node_crypto.createHash)("sha256").update(transformerFactoryPath).update("\0").update(serializedConfig).digest("hex");
+	const directory = (0, import_node_path.join)(config.cacheBaseRoot, "bridge");
+	const bridgePath = (0, import_node_path.join)(directory, `${bridgeHash}.cjs`);
+	const temporaryPath = `${bridgePath}.${process.pid}.tmp`;
+	const source = `'use strict'
+module.exports = require(${JSON.stringify(transformerFactoryPath)}).createMetroCompilerTransformer(${serializedConfig})
+`;
+	(0, import_node_fs.mkdirSync)(directory, { recursive: true });
+	(0, import_node_fs.writeFileSync)(temporaryPath, source, "utf8");
+	(0, import_node_fs.renameSync)(temporaryPath, bridgePath);
+	return bridgePath;
+}