@tamagui/vite-plugin 2.7.7 → 3.0.0-0.canary.1791056644527

package/dist/cjs/compilerStats.cjs

@@ -0,0 +1,126 @@
+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 compilerStats_exports = {};
+__export(compilerStats_exports, {
+	createCompilerStatsReport: () => createCompilerStatsReport,
+	formatCompilerStatsReport: () => formatCompilerStatsReport
+});
+module.exports = __toCommonJS(compilerStats_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+const normalizePath = (value) => value.replace(/\\/g, "/");
+function normalizeDiagnostic(diagnostic) {
+	const unsupportedComponentSuffix = diagnostic.component && `#${diagnostic.component} does not accept className`;
+	const message = unsupportedComponentSuffix && diagnostic.message.endsWith(unsupportedComponentSuffix) ? `${diagnostic.component} does not accept className` : diagnostic.message;
+	return {
+		code: diagnostic.code,
+		message,
+		...diagnostic.component && { component: diagnostic.component }
+	};
+}
+function createCompilerStatsReport(root, reports) {
+	const totals = {
+		modules: 0,
+		found: 0,
+		lowered: 0,
+		flattened: 0,
+		partial: 0,
+		styled: 0,
+		bailed: 0,
+		notFlattened: 0,
+		flattenRate: 0
+	};
+	const bailoutCodes = /* @__PURE__ */ new Map();
+	const bailoutReasons = /* @__PURE__ */ new Map();
+	const modules = [];
+	for (const [id, report] of [...reports].sort(([left], [right]) => left.localeCompare(right))) {
+		if (report.stats.found === 0) continue;
+		const partial = report.stats.lowered - report.stats.flattened;
+		const notFlattened = report.stats.found - report.stats.flattened;
+		totals.modules++;
+		totals.found += report.stats.found;
+		totals.lowered += report.stats.lowered;
+		totals.flattened += report.stats.flattened;
+		totals.partial += partial;
+		totals.styled += report.stats.styled;
+		totals.bailed += report.stats.bailed;
+		totals.notFlattened += notFlattened;
+		const diagnostics = report.diagnostics.map(normalizeDiagnostic);
+		for (const diagnostic of diagnostics) {
+			bailoutCodes.set(diagnostic.code, (bailoutCodes.get(diagnostic.code) ?? 0) + 1);
+			const key = JSON.stringify([
+				diagnostic.code,
+				diagnostic.message,
+				diagnostic.component
+			]);
+			const reason = bailoutReasons.get(key);
+			if (reason) {
+				reason.count++;
+			} else {
+				bailoutReasons.set(key, {
+					...diagnostic,
+					count: 1
+				});
+			}
+		}
+		modules.push({
+			id: normalizePath(import_node_path.default.relative(root, id)),
+			stats: {
+				...report.stats,
+				partial,
+				notFlattened
+			},
+			diagnostics
+		});
+	}
+	totals.flattenRate = totals.found ? totals.flattened / totals.found : 0;
+	return {
+		schemaVersion: 1,
+		selector: {
+			id: "all",
+			include: ["**"]
+		},
+		totals,
+		bailoutCodes: Object.fromEntries([...bailoutCodes].sort(([leftCode, leftCount], [rightCode, rightCount]) => rightCount - leftCount || leftCode.localeCompare(rightCode))),
+		bailoutReasons: [...bailoutReasons.values()].sort((left, right) => right.count - left.count || left.code.localeCompare(right.code) || left.message.localeCompare(right.message) || (left.component ?? "").localeCompare(right.component ?? "")),
+		modules
+	};
+}
+function formatCompilerStatsReport(report, verbose) {
+	const moduleLines = report.modules.map(({ id, stats, diagnostics }) => {
+		const codes = [...new Set(diagnostics.map(({ code }) => code))];
+		return `  ${id}: found ${stats.found} lowered ${stats.lowered} flattened ${stats.flattened} bailed ${stats.bailed}` + (codes.length ? ` (${codes.join(", ")})` : "");
+	});
+	const summary = `
+[tamagui] compiler stats: ${report.totals.modules} modules with candidates
+  found ${report.totals.found} \xB7 lowered ${report.totals.lowered} (flattened ${report.totals.flattened}, partial ${report.totals.partial}, styled ${report.totals.styled}) \xB7 bailed ${report.totals.bailed}`;
+	const bailouts = Object.entries(report.bailoutCodes).map(([code, count]) => `  bailout ${code}: ${count}`).join("\n");
+	return [
+		summary,
+		bailouts,
+		verbose ? moduleLines.join("\n") : ""
+	].filter(Boolean).join("\n");
+}

package/dist/cjs/extensions.cjs

@@ -3,26 +3,33 @@ 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
-  });
+	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;
+	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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var extensions_exports = {};
-__export(extensions_exports, {
-  extensions: () => extensions
-});
+__export(extensions_exports, { extensions: () => extensions });
 module.exports = __toCommonJS(extensions_exports);
-const extensions = [".ios.js", ".native.js", ".native.ts", ".native.tsx", ".js", ".jsx", ".json", ".ts", ".tsx", ".mjs"];
+const extensions = [
+	".ios.js",
+	".native.js",
+	".native.ts",
+	".native.tsx",
+	".js",
+	".jsx",
+	".json",
+	".ts",
+	".tsx",
+	".mjs"
+];

package/dist/cjs/index.cjs

@@ -3,18 +3,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 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;
+	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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./plugin.cjs"), module.exports);
+__reExport(index_exports, require("./plugin.cjs"), module.exports);

package/dist/cjs/internal.cjs

@@ -0,0 +1,24 @@
+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 internal_exports = {};
+__export(internal_exports, { createTamaguiPlugins: () => import_plugin.createTamaguiPlugins });
+module.exports = __toCommonJS(internal_exports);
+var import_plugin = require("./plugin.cjs");

package/dist/cjs/loadTamagui.cjs

@@ -5,97 +5,262 @@ 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
-  });
+	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;
+	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(
-// If the importer is in node compatibility mode or this is not an ESM
-// file that has been converted to a CommonJS file using a Babel-
-// compatible transform (i.e. "__esModule" has not been set), then set
-// "default" to the CommonJS "module.exports" for node compatibility.
-isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loadTamagui_exports = {};
 __export(loadTamagui_exports, {
-  cleanup: () => cleanup,
-  ensureFullConfigLoaded: () => ensureFullConfigLoaded,
-  getLoadPromise: () => getLoadPromise,
-  getTamaguiOptions: () => getTamaguiOptions,
-  loadTamaguiBuildConfig: () => loadTamaguiBuildConfig
+	TAMAGUI_EVALUATION_ENVIRONMENT: () => TAMAGUI_EVALUATION_ENVIRONMENT,
+	createViteTamaguiLoader: () => createViteTamaguiLoader,
+	viteBuildConfigLoader: () => viteBuildConfigLoader
 });
 module.exports = __toCommonJS(loadTamagui_exports);
-var StaticWorker = __toESM(require("@tamagui/static-worker"), 1);
-const LOAD_STATE_KEY = "__tamagui_load_state__";
-function getLoadState() {
-  if (!globalThis[LOAD_STATE_KEY]) {
-    ;
-    globalThis[LOAD_STATE_KEY] = {
-      loadPromise: null,
-      loadedOptions: null,
-      fullConfigLoaded: false,
-      fullConfigLoadPromise: null
-    };
-  }
-  return globalThis[LOAD_STATE_KEY];
-}
-function getTamaguiOptions() {
-  return getLoadState().loadedOptions;
-}
-function getLoadPromise() {
-  return getLoadState().loadPromise;
-}
-async function loadTamaguiBuildConfig(optionsIn) {
-  const state = getLoadState();
-  if (state.loadedOptions) return state.loadedOptions;
-  if (state.loadPromise) return state.loadPromise;
-  state.loadPromise = (async () => {
-    const options = await StaticWorker.loadTamaguiBuildConfig({
-      ...optionsIn,
-      platform: "web"
-    });
-    state.loadedOptions = options;
-    return options;
-  })();
-  return state.loadPromise;
-}
-async function ensureFullConfigLoaded() {
-  const state = getLoadState();
-  if (state.fullConfigLoaded) return;
-  if (state.fullConfigLoadPromise) return state.fullConfigLoadPromise;
-  state.fullConfigLoadPromise = (async () => {
-    const options = await loadTamaguiBuildConfig();
-    if (!options.disableWatchTamaguiConfig && !options.disable) {
-      await StaticWorker.loadTamagui({
-        components: ["tamagui"],
-        platform: "web",
-        ...options
-      });
-    }
-    state.fullConfigLoaded = true;
-  })();
-  return state.fullConfigLoadPromise;
+var import_static = __toESM(require("@tamagui/static"), 1);
+var import_node_module = require("node:module");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vite = require("vite");
+const import_meta = {};
+const TAMAGUI_EVALUATION_ENVIRONMENT = "tamagui";
+const viteBuildConfigLoader = async (absolutePath, root) => {
+	const { module: module2, dependencies } = await (0, import_vite.runnerImport)(absolutePath, { root });
+	return {
+		exports: module2,
+		dependencies: [absolutePath, ...dependencies]
+	};
+};
+const requireFromLoader = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const vitePluginVersions = [`@tamagui/vite-plugin@${requireFromLoader("@tamagui/vite-plugin/package.json").version}`];
+function createViteTamaguiLoader(optionsIn = {}) {
+	let environment = null;
+	let ownsEnvironment = false;
+	let loadPromise = null;
+	let loadedOptions = null;
+	let projectPromise = null;
+	let loadingProject = null;
+	const invalidatedFiles = /* @__PURE__ */ new Set();
+	const evaluationDependencies = /* @__PURE__ */ new Set();
+	const stampSources = /* @__PURE__ */ new Set();
+	let generation = 0;
+	const normalizeDependency = (id) => id.split("?")[0];
+	const captureEvaluationDependencies = (modules) => {
+		evaluationDependencies.clear();
+		stampSources.clear();
+		for (const { id } of modules) {
+			const dependency = normalizeDependency(id);
+			if (import_node_path.default.isAbsolute(dependency)) {
+				evaluationDependencies.add(dependency);
+				stampSources.add(dependency);
+			}
+		}
+		if (environment) {
+			for (const module2 of environment.runner.evaluatedModules.urlToIdModuleMap.values()) {
+				const dependency = normalizeDependency(module2.file);
+				if (!import_node_path.default.isAbsolute(dependency)) continue;
+				stampSources.add(dependency);
+				if (!dependency.includes("/node_modules/")) {
+					evaluationDependencies.add(dependency);
+				}
+			}
+		}
+	};
+	const loadTamaguiBuildConfig = async () => {
+		if (loadedOptions) return loadedOptions;
+		if (loadPromise) return loadPromise;
+		const pending = import_static.default.loadTamaguiBuildConfigAsync({
+			...optionsIn,
+			platform: "web"
+		}, viteBuildConfigLoader).then((options) => {
+			loadedOptions = options;
+			return options;
+		}, (error) => {
+			if (loadPromise === pending) loadPromise = null;
+			throw error;
+		});
+		loadPromise = pending;
+		return pending;
+	};
+	const resolveAndImport = async (moduleName, root, kind) => {
+		if (!environment) {
+			throw new Error(`The Tamagui Vite evaluation environment is not ready. Config and component evaluation requires Vite's ModuleRunner.`);
+		}
+		const source = import_node_path.default.isAbsolute(moduleName) ? moduleName : kind === "config" || moduleName.startsWith(".") ? import_node_path.default.resolve(root, moduleName) : moduleName;
+		let environmentResolution = await environment.pluginContainer.resolveId(source);
+		if (!environmentResolution && kind === "config" && source !== moduleName) {
+			environmentResolution = await environment.pluginContainer.resolveId(moduleName);
+		}
+		const resolvedId = environmentResolution?.id;
+		if (!resolvedId) {
+			throw new Error(`Unable to resolve ${moduleName} in the Tamagui Vite environment (plugins: ${environment.plugins.map((plugin) => plugin.name).join(", ")})`);
+		}
+		return {
+			moduleName,
+			id: resolvedId,
+			module: await environment.runner.import(resolvedId)
+		};
+	};
+	const evaluateProjectModules = async (options) => {
+		if (!environment) {
+			throw new Error(`Cannot evaluate Tamagui without the ${TAMAGUI_EVALUATION_ENVIRONMENT} Vite environment`);
+		}
+		const root = environment.config.root;
+		const config = await resolveAndImport(options.config || "tamagui.config.ts", root, "config");
+		const components = await Promise.all((options.components || []).map((name) => resolveAndImport(name, root, "component")));
+		captureEvaluationDependencies([config, ...components]);
+		return {
+			config,
+			components
+		};
+	};
+	const loadProject = async (options) => {
+		if (projectPromise) return projectPromise;
+		const previous = loadingProject;
+		const projectGeneration = generation;
+		const changedFiles = [...invalidatedFiles];
+		invalidatedFiles.clear();
+		projectPromise = (async () => {
+			try {
+				await previous;
+			} catch {}
+			if (!environment) {
+				throw new Error(`Cannot load Tamagui without the ${TAMAGUI_EVALUATION_ENVIRONMENT} Vite environment`);
+			}
+			for (const file of changedFiles) {
+				const evaluated2 = environment.runner.evaluatedModules;
+				const affected = new Set(evaluated2.getModulesByFile(file));
+				for (const module2 of affected) {
+					for (const importer of module2.importers) {
+						const parent = evaluated2.getModuleById(importer);
+						if (parent) affected.add(parent);
+					}
+					evaluated2.invalidateModule(module2);
+				}
+			}
+			let evaluated = null;
+			return import_static.default.loadCompilerProject({
+				root: environment.config.root,
+				target: "web",
+				options,
+				generation: `vite:${projectGeneration}`,
+				hostVersions: vitePluginVersions,
+				async load(normalizedOptions) {
+					evaluated = await evaluateProjectModules(normalizedOptions);
+					return import_static.default.loadTamaguiFromModules(normalizedOptions, {
+						config: evaluated.config.module,
+						components: evaluated.components.map(({ moduleName, module: module2 }) => ({
+							moduleName,
+							module: module2
+						})),
+						stampSources: [...stampSources]
+					});
+				},
+				async resolveComponents(moduleNames) {
+					if (!evaluated) {
+						throw new Error("The Tamagui compiler project modules were not evaluated");
+					}
+					const byName = new Map(evaluated.components.map(({ moduleName, id }) => [moduleName, id]));
+					return moduleNames.map((moduleName) => {
+						const id = byName.get(moduleName);
+						if (!id) throw new Error(`Unable to resolve compiler component ${moduleName}`);
+						return {
+							moduleName,
+							id
+						};
+					});
+				}
+			});
+		})();
+		loadingProject = projectPromise;
+		const pending = projectPromise;
+		try {
+			return await pending;
+		} catch (error) {
+			if (projectPromise === pending) projectPromise = null;
+			throw error;
+		} finally {
+			if (loadingProject === pending) loadingProject = null;
+		}
+	};
+	return {
+		getEnvironment: () => environment,
+		getGeneration: () => generation,
+		getLoadPromise: () => loadPromise,
+		getTamaguiOptions: () => loadedOptions,
+		async getTamaguiConfig() {
+			const options = await loadTamaguiBuildConfig();
+			if (options.disable) return null;
+			return (await loadProject(options)).projectInfo.tamaguiConfig;
+		},
+		async getCompilerProject() {
+			const options = await loadTamaguiBuildConfig();
+			return loadProject(options);
+		},
+		getEvaluationDependencies: () => [...evaluationDependencies],
+		isEvaluationDependency: (id) => evaluationDependencies.has(normalizeDependency(id)),
+		evaluateProjectModules,
+		async evaluateModule(id) {
+			if (!environment) return null;
+			try {
+				return await environment.runner.import(id);
+			} catch (error) {
+				if (process.env.DEBUG === "tamagui") {
+					console.info(`[tamagui] component discovery skipped ${id}:`, error);
+				}
+				return null;
+			}
+		},
+		loadTamaguiBuildConfig,
+		setEnvironment(next, options) {
+			if (environment === next) return;
+			environment = next;
+			ownsEnvironment = options?.owned === true;
+			generation++;
+			projectPromise = null;
+		},
+		invalidate(file) {
+			if (file) invalidatedFiles.add(normalizeDependency(file));
+			generation++;
+			projectPromise = null;
+		},
+		async ensureFullConfigLoaded() {
+			const options = await loadTamaguiBuildConfig();
+			if (!options.disable) {
+				await loadProject(options);
+			}
+			return [...evaluationDependencies];
+		},
+		async cleanup() {
+			try {
+				await loadingProject?.catch(() => {});
+				if (ownsEnvironment && environment) {
+					await environment.close();
+				}
+			} finally {
+				environment = null;
+				ownsEnvironment = false;
+				loadPromise = null;
+				loadedOptions = null;
+				projectPromise = null;
+				loadingProject = null;
+				invalidatedFiles.clear();
+				evaluationDependencies.clear();
+				stampSources.clear();
+			}
+		}
+	};
 }
-async function cleanup() {
-  await StaticWorker.destroyPool();
-  const state = getLoadState();
-  state.loadPromise = null;
-  state.loadedOptions = null;
-  state.fullConfigLoaded = false;
-  state.fullConfigLoadPromise = null;
-}