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

package/dist/esm/transformer.mjs

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { compileWithUserBabel, userBabelCacheKey } from "./babel.mjs";
+import { METRO_COMPILER_CACHE_VERSION, MetroCompilerCache, MetroCompilerCacheError } from "./compilerCache.mjs";
+import { formatMetroCompilerDiagnostic, metroDiagnostic } from "./diagnostics.mjs";
+import { isCompilerSourceFile } from "./metroResolver.mjs";
+import { applyMetroCompilerPlan } from "./lowering.mjs";
+
+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 = isAbsolute(filename) ? filename : resolve(config.projectRoot, filename);
+			try {
+				id = realpathSync(absolute);
+			} catch {
+				id = absolute;
+			}
+			moduleIdCache.set(filename, id);
+		}
+		return id;
+	}
+	function planEligible(moduleId) {
+		return isCompilerSourceFile(moduleId) && !moduleId.includes(`${join("node_modules")}`) && 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 MetroCompilerCache(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 = metroDiagnostic("metro/plan-miss", `Lowering plan lookup missed for ${moduleId} (${reason}${detail ? `: ${detail}` : ""}); module ships unlowered`, { moduleId });
+					tamagui.diagnostics.push(diagnostic);
+					console.warn(formatMetroCompilerDiagnostic(diagnostic, config.projectRoot));
+				});
+				if (entry) {
+					try {
+						const lowered = await 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 = 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(formatMetroCompilerDiagnostic(diagnostic, config.projectRoot));
+					}
+				}
+			} catch (error) {
+				if (!(error instanceof MetroCompilerCacheError)) throw error;
+				tamagui.diagnostics.push(error.diagnostic);
+				console.warn(formatMetroCompilerDiagnostic(error.diagnostic, config.projectRoot));
+			}
+			const compiled = await compileWithUserBabel(config.originalBabelTransformerPath, args);
+			return {
+				...compiled.result,
+				metadata: {
+					...compiled.result.metadata,
+					tamagui
+				}
+			};
+		},
+		getCacheKey() {
+			return createHash("sha256").update(`tamagui-metro-compiler-v${METRO_COMPILER_CACHE_VERSION}`).update("\0").update(runtimeLiteral).update("\0").update(userBabelCacheKey(config.originalBabelTransformerPath)).digest("hex");
+		}
+	};
+}
+function writeMetroCompilerTransformerBridge(transformerFactoryPath, config) {
+	const serializedConfig = JSON.stringify(config);
+	const bridgeHash = createHash("sha256").update(transformerFactoryPath).update("\0").update(serializedConfig).digest("hex");
+	const directory = join(config.cacheBaseRoot, "bridge");
+	const bridgePath = join(directory, `${bridgeHash}.cjs`);
+	const temporaryPath = `${bridgePath}.${process.pid}.tmp`;
+	const source = `'use strict'
+module.exports = require(${JSON.stringify(transformerFactoryPath)}).createMetroCompilerTransformer(${serializedConfig})
+`;
+	mkdirSync(directory, { recursive: true });
+	writeFileSync(temporaryPath, source, "utf8");
+	renameSync(temporaryPath, bridgePath);
+	return bridgePath;
+}
+
+export { createMetroCompilerTransformer, writeMetroCompilerTransformerBridge };
+//# sourceMappingURL=transformer.mjs.map

package/dist/esm/transformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.js","names":[],"sources":["esm/transformer.js"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { existsSync, mkdirSync, realpathSync, renameSync, writeFileSync } from \"node:fs\";\nimport { isAbsolute, join, resolve } from \"node:path\";\nimport {\n  compileWithUserBabel,\n  userBabelCacheKey\n} from \"./babel\";\nimport {\n  METRO_COMPILER_CACHE_VERSION,\n  MetroCompilerCache,\n  MetroCompilerCacheError\n} from \"./compilerCache\";\nimport {\n  formatMetroCompilerDiagnostic,\n  metroDiagnostic\n} from \"./diagnostics\";\nimport { isCompilerSourceFile } from \"./metroResolver\";\nimport { applyMetroCompilerPlan } from \"./lowering\";\nfunction createMetroCompilerTransformer(config) {\n  const moduleIdCache = /* @__PURE__ */ new Map();\n  const missWarned = /* @__PURE__ */ new Set();\n  function cacheModuleId(filename) {\n    let id = moduleIdCache.get(filename);\n    if (!id) {\n      const absolute = isAbsolute(filename) ? filename : resolve(config.projectRoot, filename);\n      try {\n        id = realpathSync(absolute);\n      } catch {\n        id = absolute;\n      }\n      moduleIdCache.set(filename, id);\n    }\n    return id;\n  }\n  function planEligible(moduleId) {\n    return isCompilerSourceFile(moduleId) && !moduleId.includes(`${join(\"node_modules\")}`) && existsSync(moduleId);\n  }\n  const runtimeLiteral = config.runtimeLiteral ?? \"full\";\n  const inlineRuntimeLiteral = ({ types }) => ({\n    visitor: {\n      MemberExpression(nodePath) {\n        const node = nodePath.node;\n        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\" })) {\n          return;\n        }\n        nodePath.replaceWith(types.stringLiteral(runtimeLiteral));\n      }\n    }\n  });\n  return {\n    async transform(argsIn) {\n      const args = {\n        ...argsIn,\n        plugins: [...argsIn.plugins ?? [], inlineRuntimeLiteral]\n      };\n      const platform = typeof args.options.platform === \"string\" ? args.options.platform : \"default\";\n      const cache = new MetroCompilerCache(join(config.cacheBaseRoot, platform));\n      let tamagui = {\n        cacheHit: false,\n        diagnostics: []\n      };\n      const moduleId = cacheModuleId(args.filename);\n      try {\n        const entry = await cache.read(moduleId, args.src, (reason, detail) => {\n          if (missWarned.has(moduleId) || !planEligible(moduleId)) return;\n          missWarned.add(moduleId);\n          const diagnostic = metroDiagnostic(\n            \"metro/plan-miss\",\n            `Lowering plan lookup missed for ${moduleId} (${reason}${detail ? `: ${detail}` : \"\"}); module ships unlowered`,\n            { moduleId }\n          );\n          tamagui.diagnostics.push(diagnostic);\n          console.warn(formatMetroCompilerDiagnostic(diagnostic, config.projectRoot));\n        });\n        if (entry) {\n          try {\n            const lowered = await applyMetroCompilerPlan(\n              { ...args, filename: moduleId },\n              entry.plan,\n              config.originalBabelTransformerPath\n            );\n            return {\n              ...lowered.compiled.result,\n              metadata: {\n                ...lowered.compiled.result.metadata,\n                tamagui: {\n                  cacheHit: true,\n                  diagnostics: entry.diagnostics,\n                  lowering: lowered.lowering\n                }\n              }\n            };\n          } catch (error) {\n            const diagnostic = metroDiagnostic(\n              \"metro/cache-corrupt\",\n              `Cached lowering plan for ${args.filename} could not be applied: ${error instanceof Error ? error.message : String(error)}`,\n              { moduleId }\n            );\n            tamagui = {\n              cacheHit: true,\n              diagnostics: [...entry.diagnostics, diagnostic]\n            };\n            console.warn(formatMetroCompilerDiagnostic(diagnostic, config.projectRoot));\n          }\n        }\n      } catch (error) {\n        if (!(error instanceof MetroCompilerCacheError)) throw error;\n        tamagui.diagnostics.push(error.diagnostic);\n        console.warn(formatMetroCompilerDiagnostic(error.diagnostic, config.projectRoot));\n      }\n      const compiled = await compileWithUserBabel(\n        config.originalBabelTransformerPath,\n        args\n      );\n      return {\n        ...compiled.result,\n        metadata: {\n          ...compiled.result.metadata,\n          tamagui\n        }\n      };\n    },\n    getCacheKey() {\n      return createHash(\"sha256\").update(`tamagui-metro-compiler-v${METRO_COMPILER_CACHE_VERSION}`).update(\"\\0\").update(runtimeLiteral).update(\"\\0\").update(userBabelCacheKey(config.originalBabelTransformerPath)).digest(\"hex\");\n    }\n  };\n}\nfunction writeMetroCompilerTransformerBridge(transformerFactoryPath, config) {\n  const serializedConfig = JSON.stringify(config);\n  const bridgeHash = createHash(\"sha256\").update(transformerFactoryPath).update(\"\\0\").update(serializedConfig).digest(\"hex\");\n  const directory = join(config.cacheBaseRoot, \"bridge\");\n  const bridgePath = join(directory, `${bridgeHash}.cjs`);\n  const temporaryPath = `${bridgePath}.${process.pid}.tmp`;\n  const source = `'use strict'\nmodule.exports = require(${JSON.stringify(\n    transformerFactoryPath\n  )}).createMetroCompilerTransformer(${serializedConfig})\n`;\n  mkdirSync(directory, { recursive: true });\n  writeFileSync(temporaryPath, source, \"utf8\");\n  renameSync(temporaryPath, bridgePath);\n  return bridgePath;\n}\nexport {\n  createMetroCompilerTransformer,\n  writeMetroCompilerTransformerBridge\n};\n//# sourceMappingURL=transformer.js.map\n"],"mappings":"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"}

package/dist/esm/zeroRuntime.mjs

@@ -0,0 +1,105 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import Static from "@tamagui/static";
+
+const ZERO_CSS_FILENAME = "tamagui-zero.css";
+const ZERO_ISLAND_DIRNAME = "tamagui-islands";
+const normalizePath = (value) => value.replace(/\\/g, "/");
+const zeroModuleKey = (value) => normalizePath(value).replace(/\.(?:js|jsx|ts|tsx|mjs|cjs)$/, "");
+function islandFragmentPath(outDir, islandId) {
+	return path.join(outDir, ZERO_ISLAND_DIRNAME, `${islandId}.css`);
+}
+function islandBundleHashPath(outDir, islandId) {
+	return path.join(outDir, ZERO_ISLAND_DIRNAME, `${islandId}.hash`);
+}
+function createMetroZeroController(options, root, islandBuild, publicDirName) {
+	const resolved = Static.resolveZeroRuntimeSync(options, root);
+	if (resolved.mode === "off") return null;
+	Static.assertZeroIntegrationSupport("metro-web", resolved);
+	const cssHref = `/${ZERO_CSS_FILENAME}`;
+	const artifact = new Static.ZeroCSSArtifact(resolved.cssPath);
+	artifact.expectIslands(resolved.islands.map((island) => island.id));
+	const configPath = path.isAbsolute(options.config || "") ? options.config : path.resolve(root, options.config || "tamagui.config.ts");
+	for (const island of resolved.islands) {
+		Static.writeIslandModules({
+			island,
+			integration: "metro-web",
+			configPath,
+			scriptUrl: `/${ZERO_ISLAND_DIRNAME}/${island.id}.js`,
+			cssHref
+		});
+	}
+	return {
+		resolved,
+		artifact,
+		cssHref,
+		root,
+		publicDir: path.join(root, publicDirName),
+		islandBuild,
+		bridges: /* @__PURE__ */ new Map(),
+		violations: [],
+		transformed: /* @__PURE__ */ new Set(),
+		erasedExports: /* @__PURE__ */ new Map(),
+		isEnforcing: resolved.mode === "enforce",
+		loaderIds: new Map(resolved.islands.map((island) => [zeroModuleKey(island.loader), island.id])),
+		islandModuleIds: new Map(resolved.islands.map((island) => [zeroModuleKey(island.module), island.id])),
+		configCSS: "",
+		plansRestoredFromCache: false
+	};
+}
+function writeIslandRuntimeShims(outDir) {
+	const directory = path.join(outDir, "runtime-shim");
+	mkdirSync(directory, { recursive: true });
+	const shims = {};
+	for (const [specifier, segments] of Object.entries(Static.ISLAND_EXTERNAL_GLOBAL_PATHS)) {
+		const file = path.join(directory, `${specifier.replace(/[^a-zA-Z0-9]+/g, "_")}.js`);
+		const source = `// generated by @tamagui/metro-plugin zero-runtime. do not edit.
+module.exports = globalThis.${segments.join(".")}
+`;
+		if (!existsSync(file) || readFileSync(file, "utf8") !== source) {
+			writeFileSync(file, source);
+		}
+		shims[specifier] = file;
+	}
+	return shims;
+}
+function finalizeMetroZero(input) {
+	const { controller } = input;
+	const outDir = controller.resolved.outDir;
+	if (controller.islandBuild) {
+		const fragment = [...controller.artifact.islandCSS(controller.islandBuild)].join("");
+		const file = islandFragmentPath(outDir, controller.islandBuild);
+		mkdirSync(path.dirname(file), { recursive: true });
+		writeFileSync(file, fragment);
+		writeFileSync(islandBundleHashPath(outDir, controller.islandBuild), createHash("sha256").update(input.bundleCode).digest("hex").slice(0, 16));
+		return {
+			cssPath: file,
+			hash: "",
+			islandOutputHashes: {}
+		};
+	}
+	controller.artifact.setConfigCSS(controller.configCSS);
+	const islandOutputHashes = {};
+	for (const island of controller.resolved.islands) {
+		const fragment = islandFragmentPath(outDir, island.id);
+		if (!existsSync(fragment)) {
+			throw new Error(`[tamagui zero-runtime] island "${island.id}" has not been built. Build every declared island bundle before the zero entry so the one CSS artifact can be finalized.`);
+		}
+		controller.artifact.setIslandModuleCSS(island.id, island.module, readFileSync(fragment, "utf8"));
+		const hashFile = islandBundleHashPath(outDir, island.id);
+		islandOutputHashes[island.id] = existsSync(hashFile) ? readFileSync(hashFile, "utf8") : "";
+	}
+	const written = controller.artifact.write();
+	if (!written.complete) {
+		throw new Error(`[tamagui zero-runtime] cannot derive TAMAGUI_DID_OUTPUT_CSS: the generated CSS artifact is missing ${written.missing.join(", ")}`);
+	}
+	return {
+		cssPath: written.path,
+		hash: written.hash,
+		islandOutputHashes
+	};
+}
+
+export { ZERO_CSS_FILENAME, ZERO_ISLAND_DIRNAME, createMetroZeroController, finalizeMetroZero, islandBundleHashPath, islandFragmentPath, writeIslandRuntimeShims, zeroModuleKey };
+//# sourceMappingURL=zeroRuntime.mjs.map

package/dist/esm/zeroRuntime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zeroRuntime.js","names":[],"sources":["esm/zeroRuntime.js"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { existsSync, mkdirSync, readFileSync, writeFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport Static from \"@tamagui/static\";\nconst ZERO_CSS_FILENAME = \"tamagui-zero.css\";\nconst ZERO_ISLAND_DIRNAME = \"tamagui-islands\";\nconst normalizePath = (value) => value.replace(/\\\\/g, \"/\");\nconst zeroModuleKey = (value) => normalizePath(value).replace(/\\.(?:js|jsx|ts|tsx|mjs|cjs)$/, \"\");\nfunction islandFragmentPath(outDir, islandId) {\n  return path.join(outDir, ZERO_ISLAND_DIRNAME, `${islandId}.css`);\n}\nfunction islandBundleHashPath(outDir, islandId) {\n  return path.join(outDir, ZERO_ISLAND_DIRNAME, `${islandId}.hash`);\n}\nfunction createMetroZeroController(options, root, islandBuild, publicDirName) {\n  const resolved = Static.resolveZeroRuntimeSync(options, root);\n  if (resolved.mode === \"off\") return null;\n  Static.assertZeroIntegrationSupport(\"metro-web\", resolved);\n  const cssHref = `/${ZERO_CSS_FILENAME}`;\n  const artifact = new Static.ZeroCSSArtifact(resolved.cssPath);\n  artifact.expectIslands(resolved.islands.map((island) => island.id));\n  const configPath = path.isAbsolute(options.config || \"\") ? options.config : path.resolve(root, options.config || \"tamagui.config.ts\");\n  for (const island of resolved.islands) {\n    Static.writeIslandModules({\n      island,\n      integration: \"metro-web\",\n      configPath,\n      scriptUrl: `/${ZERO_ISLAND_DIRNAME}/${island.id}.js`,\n      cssHref\n    });\n  }\n  return {\n    resolved,\n    artifact,\n    cssHref,\n    root,\n    publicDir: path.join(root, publicDirName),\n    islandBuild,\n    bridges: /* @__PURE__ */ new Map(),\n    violations: [],\n    transformed: /* @__PURE__ */ new Set(),\n    erasedExports: /* @__PURE__ */ new Map(),\n    isEnforcing: resolved.mode === \"enforce\",\n    loaderIds: new Map(\n      resolved.islands.map((island) => [zeroModuleKey(island.loader), island.id])\n    ),\n    islandModuleIds: new Map(\n      resolved.islands.map((island) => [zeroModuleKey(island.module), island.id])\n    ),\n    configCSS: \"\",\n    plansRestoredFromCache: false\n  };\n}\nfunction writeIslandRuntimeShims(outDir) {\n  const directory = path.join(outDir, \"runtime-shim\");\n  mkdirSync(directory, { recursive: true });\n  const shims = {};\n  for (const [specifier, segments] of Object.entries(\n    Static.ISLAND_EXTERNAL_GLOBAL_PATHS\n  )) {\n    const file = path.join(directory, `${specifier.replace(/[^a-zA-Z0-9]+/g, \"_\")}.js`);\n    const source = `// generated by @tamagui/metro-plugin zero-runtime. do not edit.\nmodule.exports = globalThis.${segments.join(\n      \".\"\n    )}\n`;\n    if (!existsSync(file) || readFileSync(file, \"utf8\") !== source) {\n      writeFileSync(file, source);\n    }\n    shims[specifier] = file;\n  }\n  return shims;\n}\nfunction finalizeMetroZero(input) {\n  const { controller } = input;\n  const outDir = controller.resolved.outDir;\n  if (controller.islandBuild) {\n    const fragment = [...controller.artifact.islandCSS(controller.islandBuild)].join(\"\");\n    const file = islandFragmentPath(outDir, controller.islandBuild);\n    mkdirSync(path.dirname(file), { recursive: true });\n    writeFileSync(file, fragment);\n    writeFileSync(\n      islandBundleHashPath(outDir, controller.islandBuild),\n      createHash(\"sha256\").update(input.bundleCode).digest(\"hex\").slice(0, 16)\n    );\n    return { cssPath: file, hash: \"\", islandOutputHashes: {} };\n  }\n  controller.artifact.setConfigCSS(controller.configCSS);\n  const islandOutputHashes = {};\n  for (const island of controller.resolved.islands) {\n    const fragment = islandFragmentPath(outDir, island.id);\n    if (!existsSync(fragment)) {\n      throw new Error(\n        `[tamagui zero-runtime] island \"${island.id}\" has not been built. Build every declared island bundle before the zero entry so the one CSS artifact can be finalized.`\n      );\n    }\n    controller.artifact.setIslandModuleCSS(\n      island.id,\n      island.module,\n      readFileSync(fragment, \"utf8\")\n    );\n    const hashFile = islandBundleHashPath(outDir, island.id);\n    islandOutputHashes[island.id] = existsSync(hashFile) ? readFileSync(hashFile, \"utf8\") : \"\";\n  }\n  const written = controller.artifact.write();\n  if (!written.complete) {\n    throw new Error(\n      `[tamagui zero-runtime] cannot derive TAMAGUI_DID_OUTPUT_CSS: the generated CSS artifact is missing ${written.missing.join(\n        \", \"\n      )}`\n    );\n  }\n  return { cssPath: written.path, hash: written.hash, islandOutputHashes };\n}\nexport {\n  ZERO_CSS_FILENAME,\n  ZERO_ISLAND_DIRNAME,\n  createMetroZeroController,\n  finalizeMetroZero,\n  islandBundleHashPath,\n  islandFragmentPath,\n  writeIslandRuntimeShims,\n  zeroModuleKey\n};\n//# sourceMappingURL=zeroRuntime.js.map\n"],"mappings":"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"}

package/dist/esm/zeroSerializer.mjs

@@ -0,0 +1,123 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+import Static from "@tamagui/static";
+import { ZERO_CSS_FILENAME, finalizeMetroZero, writeIslandRuntimeShims } from "./zeroRuntime.mjs";
+
+const requireFromPlugin = createRequire(typeof __filename === "string" ? __filename : import.meta.url);
+const baseJSBundle = requireFromPlugin("metro/private/DeltaBundler/Serializers/baseJSBundle").default;
+const bundleToString = requireFromPlugin("metro/private/lib/bundleToString").default;
+function applyMetroZeroRuntime(metroConfig, zero) {
+	if (zero.islandBuild) {
+		const shims = writeIslandRuntimeShims(zero.resolved.outDir);
+		const userResolveRequest = metroConfig.resolver?.resolveRequest;
+		metroConfig.resolver = {
+			...metroConfig.resolver,
+			resolveRequest(context, moduleName, platform) {
+				const shim = shims[moduleName];
+				if (shim) return {
+					type: "sourceFile",
+					filePath: shim
+				};
+				return userResolveRequest ? userResolveRequest(context, moduleName, platform) : context.resolveRequest(context, moduleName, platform);
+			}
+		};
+	}
+	const userSerializer = metroConfig.serializer?.customSerializer;
+	metroConfig.serializer = {
+		...metroConfig.serializer,
+		async customSerializer(entryPoint, preModules, graph, opts) {
+			const receipt = checkGraph(zero, entryPoint, graph);
+			const output = userSerializer ? await userSerializer(entryPoint, preModules, graph, opts) : bundleToString(baseJSBundle(entryPoint, preModules, graph, opts)).code;
+			const finalized = finalizeMetroZero({
+				controller: zero,
+				bundleCode: typeof output === "string" ? output : ""
+			});
+			if (!zero.islandBuild) {
+				mkdirSync(zero.publicDir, { recursive: true });
+				const css = zero.artifact.css();
+				const published = path.join(zero.publicDir, ZERO_CSS_FILENAME);
+				writeFileSync(published, css);
+				const publishFailure = Static.checkGlobalCSSArtifact({
+					cssPath: published,
+					expectedCSS: css,
+					loadedModuleIds: [published],
+					importHint: ""
+				});
+				if (publishFailure) throw new Error(publishFailure.message);
+				receipt.cssArtifact = {
+					path: zero.cssHref,
+					hash: finalized.hash
+				};
+				receipt.gzip = {
+					[ZERO_CSS_FILENAME]: gzipSync(Buffer.from(css), { level: 9 }).length,
+					bundle: gzipSync(Buffer.from(typeof output === "string" ? output : ""), { level: 9 }).length
+				};
+				const bridgeManifest = Static.canonicalizeBridgeManifest(Object.fromEntries([...zero.bridges.entries()].sort(([left], [right]) => left < right ? -1 : 1)));
+				const identityInputs = {
+					runtimeLiteral: "zero",
+					target: "web",
+					configGeneration: Static.hashBridgeManifest(zero.configCSS),
+					cssHash: finalized.hash,
+					compilerVersion: Static.ZERO_COMPILER_VERSION,
+					islandEntries: zero.resolved.islands.map((island) => island.module),
+					bridgeManifestHash: Static.hashBridgeManifest(bridgeManifest),
+					islandOutputHashes: finalized.islandOutputHashes
+				};
+				receipt.identity = Static.hashZeroIdentity(identityInputs);
+				receipt.plansRestoredFromCache = zero.plansRestoredFromCache;
+				Static.writeZeroGraphReceipt(zero.resolved.outDir, "metro-zero", receipt);
+				writeFileSync(path.join(zero.resolved.outDir, "metro-zero.bridges.json"), `${JSON.stringify({
+					identity: receipt.identity,
+					identityInputs,
+					bridges: bridgeManifest
+				}, null, 2)}
+`);
+				if (receipt.forbidden.length) {
+					throw new Error(Static.formatZeroGraphFailure(receipt));
+				}
+				console.info(`  \u27A1 [tamagui zero-runtime] ${receipt.moduleCount} modules, 0 forbidden, css ${receipt.gzip[ZERO_CSS_FILENAME]} gzip, islands: ${zero.resolved.islands.map((island) => island.id).join(", ") || "none"}`);
+			}
+			return output;
+		}
+	};
+}
+function checkGraph(zero, entryPoint, graph) {
+	const modules = [];
+	const importerEdges = /* @__PURE__ */ new Map();
+	for (const [id, module] of graph.dependencies) {
+		const importers = [...module.inverseDependencies ?? []];
+		importerEdges.set(id, importers);
+		modules.push({
+			id,
+			importers
+		});
+	}
+	const escape = Static.erasedExportEscape({
+		integration: "metro-web",
+		transformed: zero.transformed,
+		erasedExports: zero.erasedExports,
+		importersOf: importerEdges
+	});
+	if (escape) throw new Error(escape);
+	const checked = Static.checkZeroGraph({
+		entries: [entryPoint],
+		modules,
+		importerEdges,
+		root: zero.resolved.root
+	});
+	return {
+		integration: "metro-web",
+		graph: zero.islandBuild ? "island" : "zero",
+		entries: [entryPoint],
+		moduleCount: modules.length,
+		tamaguiModules: checked.tamaguiModules,
+		forbidden: checked.forbidden,
+		cssArtifact: null,
+		identity: ""
+	};
+}
+
+export { applyMetroZeroRuntime };
+//# sourceMappingURL=zeroSerializer.mjs.map

package/dist/esm/zeroSerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zeroSerializer.js","names":[],"sources":["esm/zeroSerializer.js"],"sourcesContent":["import { mkdirSync, writeFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport path from \"node:path\";\nimport { gzipSync } from \"node:zlib\";\nimport Static from \"@tamagui/static\";\nimport {\n  finalizeMetroZero,\n  writeIslandRuntimeShims,\n  ZERO_CSS_FILENAME\n} from \"./zeroRuntime\";\nconst requireFromPlugin = createRequire(\n  typeof __filename === \"string\" ? __filename : import.meta.url\n);\nconst baseJSBundle = requireFromPlugin(\n  \"metro/private/DeltaBundler/Serializers/baseJSBundle\"\n).default;\nconst bundleToString = requireFromPlugin(\"metro/private/lib/bundleToString\").default;\nfunction applyMetroZeroRuntime(metroConfig, zero) {\n  if (zero.islandBuild) {\n    const shims = writeIslandRuntimeShims(zero.resolved.outDir);\n    const userResolveRequest = metroConfig.resolver?.resolveRequest;\n    metroConfig.resolver = {\n      ...metroConfig.resolver,\n      resolveRequest(context, moduleName, platform) {\n        const shim = shims[moduleName];\n        if (shim) return { type: \"sourceFile\", filePath: shim };\n        return userResolveRequest ? userResolveRequest(context, moduleName, platform) : context.resolveRequest(context, moduleName, platform);\n      }\n    };\n  }\n  const userSerializer = metroConfig.serializer?.customSerializer;\n  metroConfig.serializer = {\n    ...metroConfig.serializer,\n    async customSerializer(entryPoint, preModules, graph, opts) {\n      const receipt = checkGraph(zero, entryPoint, graph);\n      const output = userSerializer ? await userSerializer(entryPoint, preModules, graph, opts) : bundleToString(baseJSBundle(entryPoint, preModules, graph, opts)).code;\n      const finalized = finalizeMetroZero({\n        controller: zero,\n        bundleCode: typeof output === \"string\" ? output : \"\"\n      });\n      if (!zero.islandBuild) {\n        mkdirSync(zero.publicDir, { recursive: true });\n        const css = zero.artifact.css();\n        const published = path.join(zero.publicDir, ZERO_CSS_FILENAME);\n        writeFileSync(published, css);\n        const publishFailure = Static.checkGlobalCSSArtifact({\n          cssPath: published,\n          expectedCSS: css,\n          loadedModuleIds: [published],\n          importHint: \"\"\n        });\n        if (publishFailure) throw new Error(publishFailure.message);\n        receipt.cssArtifact = { path: zero.cssHref, hash: finalized.hash };\n        receipt.gzip = {\n          [ZERO_CSS_FILENAME]: gzipSync(Buffer.from(css), { level: 9 }).length,\n          bundle: gzipSync(Buffer.from(typeof output === \"string\" ? output : \"\"), {\n            level: 9\n          }).length\n        };\n        const bridgeManifest = Static.canonicalizeBridgeManifest(\n          Object.fromEntries(\n            [...zero.bridges.entries()].sort(([left], [right]) => left < right ? -1 : 1)\n          )\n        );\n        const identityInputs = {\n          runtimeLiteral: \"zero\",\n          target: \"web\",\n          configGeneration: Static.hashBridgeManifest(zero.configCSS),\n          cssHash: finalized.hash,\n          compilerVersion: Static.ZERO_COMPILER_VERSION,\n          islandEntries: zero.resolved.islands.map((island) => island.module),\n          bridgeManifestHash: Static.hashBridgeManifest(bridgeManifest),\n          islandOutputHashes: finalized.islandOutputHashes\n        };\n        receipt.identity = Static.hashZeroIdentity(identityInputs);\n        receipt.plansRestoredFromCache = zero.plansRestoredFromCache;\n        Static.writeZeroGraphReceipt(zero.resolved.outDir, \"metro-zero\", receipt);\n        writeFileSync(\n          path.join(zero.resolved.outDir, \"metro-zero.bridges.json\"),\n          `${JSON.stringify(\n            { identity: receipt.identity, identityInputs, bridges: bridgeManifest },\n            null,\n            2\n          )}\n`\n        );\n        if (receipt.forbidden.length) {\n          throw new Error(Static.formatZeroGraphFailure(receipt));\n        }\n        console.info(\n          `  \\u27A1 [tamagui zero-runtime] ${receipt.moduleCount} modules, 0 forbidden, css ${receipt.gzip[ZERO_CSS_FILENAME]} gzip, islands: ${zero.resolved.islands.map((island) => island.id).join(\", \") || \"none\"}`\n        );\n      }\n      return output;\n    }\n  };\n}\nfunction checkGraph(zero, entryPoint, graph) {\n  const modules = [];\n  const importerEdges = /* @__PURE__ */ new Map();\n  for (const [id, module] of graph.dependencies) {\n    const importers = [...module.inverseDependencies ?? []];\n    importerEdges.set(id, importers);\n    modules.push({ id, importers });\n  }\n  const escape = Static.erasedExportEscape({\n    integration: \"metro-web\",\n    transformed: zero.transformed,\n    erasedExports: zero.erasedExports,\n    importersOf: importerEdges\n  });\n  if (escape) throw new Error(escape);\n  const checked = Static.checkZeroGraph({\n    entries: [entryPoint],\n    modules,\n    importerEdges,\n    root: zero.resolved.root\n  });\n  return {\n    integration: \"metro-web\",\n    graph: zero.islandBuild ? \"island\" : \"zero\",\n    entries: [entryPoint],\n    moduleCount: modules.length,\n    tamaguiModules: checked.tamaguiModules,\n    forbidden: checked.forbidden,\n    cssArtifact: null,\n    identity: \"\"\n  };\n}\nexport {\n  applyMetroZeroRuntime\n};\n//# sourceMappingURL=zeroSerializer.js.map\n"],"mappings":"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"}

package/package.json

@@ -1,30 +1,58 @@
 {
   "name": "@tamagui/metro-plugin",
-  "version": "2.7.7",
+  "version": "3.0.0-beta.643.1",
   "license": "MIT",
+  "type": "module",
   "source": "src/index.ts",
   "files": [
     "src",
     "types",
     "dist"
   ],
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
   "types": "./types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./types/index.d.ts",
+      "browser": "./dist/esm/index.mjs",
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "./transformer": {
+      "types": "./types/transformer.d.ts",
+      "import": "./dist/esm/transformer.mjs",
+      "require": "./dist/cjs/transformer.cjs",
+      "default": "./dist/cjs/transformer.cjs"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build": "tamagui-build --skip-native",
+    "test:web": "vitest --run --config vitest.config.ts",
     "watch": "tamagui-build --skip-native --watch",
     "clean": "tamagui-build clean",
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/static": "2.7.7"
+    "@jridgewell/trace-mapping": "0.3.31",
+    "@tamagui/compiler-core": "3.0.0-beta.643.1",
+    "@tamagui/static": "3.0.0-beta.643.1",
+    "ignore": "^5.3.2"
   },
   "devDependencies": {
-    "@tamagui/build": "2.7.7"
+    "@tamagui/build": "3.0.0-beta.643.1",
+    "metro": "0.84.4",
+    "metro-resolver": "0.84.4"
+  },
+  "peerDependencies": {
+    "metro": "^0.84.4",
+    "metro-resolver": "^0.84.4"
   },
   "repository": {
     "type": "git",

package/src/babel.ts

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto'
+import { createRequire } from 'node:module'
+import { dirname } from 'node:path'
+
+export interface MetroBabelTransformArgs {
+  filename: string
+  src: string
+  options: Record<string, any>
+  plugins: unknown[]
+}
+
+export interface MetroBabelTransformResult {
+  ast: Record<string, any>
+  metadata?: Record<string, any>
+  functionMap?: unknown
+  [key: string]: unknown
+}
+
+export interface CompiledMetroModule {
+  code: string
+  map: Record<string, any>
+  result: MetroBabelTransformResult
+}
+
+type BabelTransformer = {
+  transform(
+    args: MetroBabelTransformArgs
+  ): MetroBabelTransformResult | Promise<MetroBabelTransformResult>
+  getCacheKey?(): string
+}
+
+function asTransformer(module: any, path: string): BabelTransformer {
+  const transformer = module?.default?.transform ? module.default : module
+  if (!transformer || typeof transformer.transform !== 'function') {
+    throw new Error(`Metro Babel transformer ${path} has no transform function`)
+  }
+  return transformer
+}
+
+export function loadMetroBabelTransformer(path: string): BabelTransformer {
+  return asTransformer(createRequire(path)(path), path)
+}
+
+export async function compileWithUserBabel(
+  transformerPath: string,
+  args: MetroBabelTransformArgs
+): Promise<CompiledMetroModule> {
+  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 = 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 }
+}
+
+export function userBabelCacheKey(transformerPath: string): string {
+  const transformer = loadMetroBabelTransformer(transformerPath)
+  return createHash('sha256')
+    .update(transformerPath)
+    .update('\0')
+    .update(transformer.getCacheKey?.() ?? '')
+    .digest('hex')
+}
+
+export function transformerDirectory(transformerPath: string): string {
+  return dirname(transformerPath)
+}