@tamagui/metro-plugin 2.7.6 → 3.0.0-beta.637.1

package/README.md

@@ -0,0 +1,12 @@
+# `@tamagui/metro-plugin`
+
+The E4 frontend runs the configured user Babel transformer first, resolves the
+compiled module graph with Metro's resolver contract in the main process, and
+publishes versioned content-addressed `LoweredModulePlan` values for isolated Metro
+workers.
+
+The cache, invalidation, diagnostics, and worker handoff are production-owned. Workers
+apply the same compiler-core plan used by Vite to the post-user-Babel source, parse the
+lowered output back into a Babel AST, and compose locations through both compiler maps.
+Uncertain candidates remain byte-identical runtime work. The deleted Babel/static Metro
+extractor is never invoked as a fallback.

package/dist/cjs/babel.cjs

@@ -0,0 +1,77 @@
+
+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 babel_exports = {};
+__export(babel_exports, {
+	compileWithUserBabel: () => compileWithUserBabel,
+	loadMetroBabelTransformer: () => loadMetroBabelTransformer,
+	transformerDirectory: () => transformerDirectory,
+	userBabelCacheKey: () => userBabelCacheKey
+});
+module.exports = __toCommonJS(babel_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_module = require("node:module");
+var import_node_path = require("node:path");
+function asTransformer(module2, path) {
+	const transformer = module2?.default?.transform ? module2.default : module2;
+	if (!transformer || typeof transformer.transform !== "function") {
+		throw new Error(`Metro Babel transformer ${path} has no transform function`);
+	}
+	return transformer;
+}
+function loadMetroBabelTransformer(path) {
+	return asTransformer((0, import_node_module.createRequire)(path)(path), path);
+}
+async function compileWithUserBabel(transformerPath, args) {
+	const transformer = loadMetroBabelTransformer(transformerPath);
+	const result = await transformer.transform(args);
+	if (!result?.ast) {
+		throw new Error(`Metro Babel transformer ${transformerPath} returned no AST`);
+	}
+	const requireFromTransformer = (0, import_node_module.createRequire)(transformerPath);
+	const generatorModule = requireFromTransformer("@babel/generator");
+	const generate = generatorModule.default ?? generatorModule;
+	const generated = generate(result.ast, {
+		comments: true,
+		compact: false,
+		retainLines: true,
+		sourceFileName: args.filename,
+		sourceMaps: true
+	}, args.src);
+	if (!generated || typeof generated.code !== "string") {
+		throw new Error(`Babel generator for ${transformerPath} returned no code`);
+	}
+	if (!generated.map) {
+		throw new Error(`Babel generator for ${transformerPath} returned no source map`);
+	}
+	return {
+		code: generated.code,
+		map: generated.map,
+		result
+	};
+}
+function userBabelCacheKey(transformerPath) {
+	const transformer = loadMetroBabelTransformer(transformerPath);
+	return (0, import_node_crypto.createHash)("sha256").update(transformerPath).update("\0").update(transformer.getCacheKey?.() ?? "").digest("hex");
+}
+function transformerDirectory(transformerPath) {
+	return (0, import_node_path.dirname)(transformerPath);
+}

package/dist/cjs/compilerCache.cjs

@@ -0,0 +1,237 @@
+
+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 compilerCache_exports = {};
+__export(compilerCache_exports, {
+	METRO_COMPILER_CACHE_VERSION: () => METRO_COMPILER_CACHE_VERSION,
+	MetroCompilerCache: () => MetroCompilerCache,
+	MetroCompilerCacheError: () => MetroCompilerCacheError,
+	defaultMetroCompilerCacheRoot: () => defaultMetroCompilerCacheRoot
+});
+module.exports = __toCommonJS(compilerCache_exports);
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_diagnostics = require("./diagnostics.cjs");
+const METRO_COMPILER_CACHE_VERSION = 6;
+var MetroCompilerCacheError = class extends Error {
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		this.diagnostic = diagnostic;
+		this.name = "MetroCompilerCacheError";
+	}
+	diagnostic;
+};
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function stableEntries(record) {
+	return Object.entries(record).sort(([left], [right]) => compareCodeUnits(left, right));
+}
+function cacheCorrupt(message, moduleId) {
+	return new MetroCompilerCacheError((0, import_diagnostics.metroDiagnostic)("metro/cache-corrupt", message, { moduleId }));
+}
+function parseJson(source, description, moduleId) {
+	try {
+		return JSON.parse(source);
+	} catch (error) {
+		throw cacheCorrupt(`${description} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`, moduleId);
+	}
+}
+function defaultMetroCompilerCacheRoot(projectRoot) {
+	return (0, import_node_path.join)((0, import_compiler_core.tamaguiCacheRoot)(projectRoot), "metro-compiler");
+}
+var MetroCompilerCache = class {
+	constructor(root) {
+		this.root = root;
+		this.#blobsDirectory = (0, import_node_path.join)(root, `v${METRO_COMPILER_CACHE_VERSION}`, "blobs");
+		this.#manifestPath = (0, import_node_path.join)(root, `v${METRO_COMPILER_CACHE_VERSION}`, "manifest.json");
+	}
+	root;
+	#blobsDirectory;
+	#manifestPath;
+	async publish(platform, entries, optionsHash) {
+		await (0, import_promises.mkdir)(this.#blobsDirectory, { recursive: true });
+		const descriptors = {};
+		for (const entry of [...entries].sort((left, right) => compareCodeUnits(left.moduleId, right.moduleId))) {
+			if (entry.schemaVersion !== METRO_COMPILER_CACHE_VERSION) {
+				throw new Error(`Cannot publish cache schema ${entry.schemaVersion}`);
+			}
+			const serialized = `${(0, import_compiler_core.stableStringify)(entry)}
+`;
+			const blobHash = (0, import_compiler_core.contentHash)(serialized);
+			const blobPath = (0, import_node_path.join)(this.#blobsDirectory, `${blobHash}.json`);
+			try {
+				await (0, import_promises.writeFile)(blobPath, serialized, {
+					encoding: "utf8",
+					flag: "wx"
+				});
+			} catch (error) {
+				if (error.code !== "EEXIST") throw error;
+				const existing = await (0, import_promises.readFile)(blobPath, "utf8");
+				if ((0, import_compiler_core.contentHash)(existing) !== blobHash) {
+					const temporaryBlobPath = `${blobPath}.${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}.tmp`;
+					await (0, import_promises.writeFile)(temporaryBlobPath, serialized, "utf8");
+					await (0, import_promises.rename)(temporaryBlobPath, blobPath);
+				}
+			}
+			descriptors[entry.moduleId] = {
+				blobHash,
+				sourceHash: entry.sourceHash
+			};
+		}
+		const generation = (0, import_compiler_core.contentHash)((0, import_compiler_core.stableStringify)(descriptors));
+		const manifest = {
+			schemaVersion: METRO_COMPILER_CACHE_VERSION,
+			generation,
+			optionsHash,
+			platform,
+			entries: descriptors
+		};
+		const manifestDirectory = (0, import_node_path.join)(this.root, `v${METRO_COMPILER_CACHE_VERSION}`);
+		const temporaryPath = (0, import_node_path.join)(manifestDirectory, `.manifest-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}.json`);
+		await (0, import_promises.writeFile)(temporaryPath, `${(0, import_compiler_core.stableStringify)(manifest)}
+`, "utf8");
+		await (0, import_promises.rename)(temporaryPath, this.#manifestPath);
+		return generation;
+	}
+	async read(moduleId, rawSource, onMiss) {
+		const manifest = await this.#readManifest();
+		if (!manifest) return null;
+		const descriptor = manifest.entries[moduleId];
+		if (!descriptor) {
+			onMiss?.("no-entry");
+			return null;
+		}
+		const sourceHash = (0, import_compiler_core.contentHash)(rawSource);
+		if (sourceHash !== descriptor.sourceHash) {
+			onMiss?.("source-hash-mismatch", `worker ${sourceHash.slice(0, 12)} vs plan ${descriptor.sourceHash.slice(0, 12)}`);
+			return null;
+		}
+		return await this.#readBlob(moduleId, descriptor);
+	}
+	async validate() {
+		const diagnostics = [];
+		try {
+			const manifest = await this.#readManifest();
+			if (!manifest) {
+				return {
+					valid: false,
+					diagnostics,
+					generation: null,
+					moduleIds: [],
+					sourceHashes: {},
+					optionsHash: null
+				};
+			}
+			const sourceHashes = {};
+			for (const [moduleId, descriptor] of stableEntries(manifest.entries)) {
+				await this.#readBlob(moduleId, descriptor);
+				sourceHashes[moduleId] = descriptor.sourceHash;
+			}
+			return {
+				valid: true,
+				diagnostics,
+				generation: manifest.generation,
+				moduleIds: Object.keys(manifest.entries).sort(compareCodeUnits),
+				sourceHashes,
+				optionsHash: manifest.optionsHash
+			};
+		} catch (error) {
+			if (error instanceof MetroCompilerCacheError) {
+				diagnostics.push(error.diagnostic);
+				return {
+					valid: false,
+					diagnostics,
+					generation: null,
+					moduleIds: [],
+					sourceHashes: {},
+					optionsHash: null
+				};
+			}
+			throw error;
+		}
+	}
+	async discardManifest() {
+		await (0, import_promises.rm)(this.#manifestPath, { force: true });
+	}
+	#zeroSidecarPath(generation) {
+		return (0, import_node_path.join)(this.root, `v${METRO_COMPILER_CACHE_VERSION}`, `zero-${generation.slice(0, 32)}.json`);
+	}
+	async publishZeroCSS(sidecar) {
+		await (0, import_promises.mkdir)((0, import_node_path.join)(this.root, `v${METRO_COMPILER_CACHE_VERSION}`), { recursive: true });
+		const file = this.#zeroSidecarPath(sidecar.generation);
+		const temporaryPath = `${file}.${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}.tmp`;
+		await (0, import_promises.writeFile)(temporaryPath, `${(0, import_compiler_core.stableStringify)(sidecar)}
+`, "utf8");
+		await (0, import_promises.rename)(temporaryPath, file);
+	}
+	/** Null whenever the sidecar is absent or does not describe this generation. */
+	async readZeroCSS(generation) {
+		let source;
+		try {
+			source = await (0, import_promises.readFile)(this.#zeroSidecarPath(generation), "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+		const sidecar = parseJson(source, "Zero CSS sidecar");
+		if (sidecar.schemaVersion !== METRO_COMPILER_CACHE_VERSION || sidecar.generation !== generation || typeof sidecar.configCSS !== "string" || !sidecar.zeroModuleCSS || typeof sidecar.zeroModuleCSS !== "object" || !sidecar.bridgeCSS || typeof sidecar.bridgeCSS !== "object" || !sidecar.bridges || typeof sidecar.bridges !== "object") {
+			return null;
+		}
+		return sidecar;
+	}
+	async #readManifest() {
+		let source;
+		try {
+			source = await (0, import_promises.readFile)(this.#manifestPath, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		}
+		const manifest = parseJson(source, "Cache manifest");
+		if (manifest.schemaVersion !== METRO_COMPILER_CACHE_VERSION || typeof manifest.generation !== "string" || typeof manifest.optionsHash !== "string" || !manifest.entries || typeof manifest.entries !== "object") {
+			throw cacheCorrupt("Cache manifest has an unsupported schema");
+		}
+		return manifest;
+	}
+	async #readBlob(moduleId, descriptor) {
+		const blobPath = (0, import_node_path.join)(this.#blobsDirectory, `${descriptor.blobHash}.json`);
+		let source;
+		try {
+			source = await (0, import_promises.readFile)(blobPath, "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				throw cacheCorrupt(`Cache blob ${descriptor.blobHash} is missing`, moduleId);
+			}
+			throw error;
+		}
+		if ((0, import_compiler_core.contentHash)(source) !== descriptor.blobHash) {
+			throw cacheCorrupt(`Cache blob ${descriptor.blobHash} failed its hash`, moduleId);
+		}
+		const entry = parseJson(source, `Cache blob ${descriptor.blobHash}`, moduleId);
+		if (entry.schemaVersion !== METRO_COMPILER_CACHE_VERSION || entry.moduleId !== moduleId || typeof entry.sourceHash !== "string" || entry.sourceHash !== descriptor.sourceHash || !entry.plan || entry.plan.version !== import_compiler_core.LOWERED_MODULE_PLAN_VERSION || entry.plan.id !== moduleId || entry.plan.sourceHash !== entry.sourceHash || !Array.isArray(entry.plan.edits) || !Array.isArray(entry.plan.diagnostics) || !Array.isArray(entry.diagnostics)) {
+			throw cacheCorrupt(`Cache blob ${descriptor.blobHash} has invalid contents`, moduleId);
+		}
+		return entry;
+	}
+};

package/dist/cjs/diagnostics.cjs

@@ -0,0 +1,41 @@
+
+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 diagnostics_exports = {};
+__export(diagnostics_exports, {
+	formatMetroCompilerDiagnostic: () => formatMetroCompilerDiagnostic,
+	metroDiagnostic: () => metroDiagnostic
+});
+module.exports = __toCommonJS(diagnostics_exports);
+var import_node_path = require("node:path");
+function metroDiagnostic(code, message, details = {}) {
+	return {
+		code,
+		message,
+		...details
+	};
+}
+function formatMetroCompilerDiagnostic(diagnostic, projectRoot) {
+	const sourceId = diagnostic.span?.id ?? diagnostic.moduleId;
+	const file = sourceId ? (0, import_node_path.isAbsolute)(sourceId) ? (0, import_node_path.relative)(projectRoot, sourceId) || "." : sourceId : null;
+	const location = file && diagnostic.line != null && diagnostic.column != null ? `${file}:${diagnostic.line}:${diagnostic.column}: ` : "";
+	return `[@tamagui/metro-plugin] ${location}${diagnostic.code}: ${diagnostic.message}`;
+}