@tamagui/static 2.7.7 → 3.0.0-beta.1093.1

package/dist/cjs/compiler.cjs

@@ -0,0 +1,349 @@
+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 compiler_exports = {};
+__export(compiler_exports, {
+	CompilerFrontend: () => CompilerFrontend,
+	compilerProjectStamp: () => compilerProjectStamp,
+	loadCompilerProject: () => loadCompilerProject
+});
+module.exports = __toCommonJS(compiler_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_node_fs = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_componentDiscovery = require("./componentDiscovery.cjs");
+var import_compilerHost = require("./compilerHost.cjs");
+var import_domStructuralPass = require("./domStructuralPass.cjs");
+var import_loadTamagui = require("./extractor/loadTamagui.cjs");
+var import_options = require("./zero/options.cjs");
+const import_meta = {};
+async function loadCompilerProject({ root, target, options: optionsIn, generation, rebuild = false, hostVersions = [], missingProjectMessage = "Unable to load the Tamagui compiler project", load = import_loadTamagui.loadTamagui, resolveComponents }) {
+	const components = [.../* @__PURE__ */ new Set(["@tamagui/core", ...optionsIn.components || ["tamagui"]])];
+	const options = {
+		...optionsIn,
+		root,
+		platform: target,
+		components
+	};
+	const zeroRuntime = (0, import_options.resolveZeroRuntimeSync)(options, root).mode;
+	if (zeroRuntime === "enforce") options.outputCSS = void 0;
+	const projectInfo = await load(options, rebuild);
+	if (!projectInfo?.tamaguiConfig || !projectInfo.components) {
+		throw new Error(missingProjectMessage);
+	}
+	const componentModules = resolveComponents ? await resolveComponents(components, projectInfo, options) : [];
+	const disablePartialExtraction = !!options.disablePartialExtraction;
+	const experimentalNativeFastPath = target === "native" && options.experimental?.nativeFastPath === true;
+	return {
+		projectInfo,
+		componentModules,
+		generation: typeof generation === "function" ? generation(projectInfo, componentModules, options) : generation,
+		disablePartialExtraction,
+		experimentalNativeFastPath,
+		zeroRuntime: zeroRuntime !== "off",
+		cacheStamp: compilerProjectStamp({
+			stampSources: projectInfo.stampSources ?? [],
+			hostVersions,
+			target,
+			componentModules,
+			disablePartialExtraction,
+			experimentalNativeFastPath,
+			zeroRuntime: zeroRuntime !== "off",
+			development: process.env.NODE_ENV === "development"
+		})
+	};
+}
+const requireFromCompiler = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const compilerPackageVersions = ["@tamagui/compiler-core", "@tamagui/static"].map((name) => `${name}@${requireFromCompiler(`${name}/package.json`).version}`);
+function compilerProjectStamp(input) {
+	if (!input.stampSources.length) return null;
+	const sources = [];
+	for (const file of [...new Set(input.stampSources)].sort()) {
+		try {
+			sources.push([file, (0, import_compiler_core.contentHash)((0, import_node_fs.readFileSync)(file))]);
+		} catch {
+			return null;
+		}
+	}
+	return (0, import_compiler_core.contentHash)((0, import_compiler_core.stableStringify)({
+		schema: import_compiler_core.PLAN_CACHE_SCHEMA_VERSION,
+		plan: import_compiler_core.LOWERED_MODULE_PLAN_VERSION,
+		packages: [...compilerPackageVersions, ...input.hostVersions].sort(),
+		target: input.target,
+		development: input.development,
+		componentModules: input.componentModules.map(({ moduleName, id }) => [moduleName, cleanId(id)]),
+		disablePartialExtraction: input.disablePartialExtraction,
+		experimentalNativeFastPath: input.experimentalNativeFastPath,
+		zeroRuntime: input.zeroRuntime,
+		sources
+	}));
+}
+function cleanId(id) {
+	return id.split(/[?#]/, 1)[0];
+}
+function externalId(specifier) {
+	return (0, import_compiler_core.resolvedModuleId)(`external://${encodeURIComponent(specifier)}`);
+}
+function compilerContext(input) {
+	return `${input.root}\0${input.target}\0${input.environment ?? ""}\0${input.project.generation}`;
+}
+function sourceCanBeLinked(root, id) {
+	const clean = cleanId(id);
+	const normalized = clean.replace(/\\/g, "/");
+	if (!import_node_path.default.isAbsolute(clean) || normalized.includes("/node_modules/")) return false;
+	const relative = import_node_path.default.relative(root, clean);
+	return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`);
+}
+var CompilerFrontend = class {
+	session = new import_compiler_core.CompilerSession();
+	queue = Promise.resolve();
+	planCaches = /* @__PURE__ */ new Map();
+	moduleRecords = /* @__PURE__ */ new Map();
+	moduleContext = null;
+	discovery = new import_componentDiscovery.ComponentDiscovery();
+	/**
+	* One cache per project root and platform. Absent when the project produced
+	* no content stamp, in which case plans are never persisted rather than
+	* persisted under an identity that cannot see a config change.
+	*/
+	planCacheFor(input) {
+		const stamp = input.project.cacheStamp;
+		if (!stamp) return void 0;
+		const root = (0, import_compiler_core.defaultPlanCacheRoot)(input.root, input.target);
+		let store = this.planCaches.get(root);
+		if (!store) {
+			store = new import_compiler_core.ModulePlanCache(root);
+			this.planCaches.set(root, store);
+		}
+		return {
+			store,
+			stamp
+		};
+	}
+	/** Hits, misses and writes across every plan cache this frontend has used. */
+	get planCacheStats() {
+		const total = {
+			hits: 0,
+			misses: 0,
+			writes: 0
+		};
+		for (const store of this.planCaches.values()) {
+			total.hits += store.stats.hits;
+			total.misses += store.stats.misses;
+			total.writes += store.stats.writes;
+		}
+		return total;
+	}
+	compile(input) {
+		const operation = this.queue.then(async () => {
+			const previousTarget = process.env.TAMAGUI_TARGET;
+			const previousStatic = process.env.IS_STATIC;
+			try {
+				return await this.compileNow(input);
+			} finally {
+				if (previousTarget === void 0) delete process.env.TAMAGUI_TARGET;
+				else process.env.TAMAGUI_TARGET = previousTarget;
+				if (previousStatic === void 0) delete process.env.IS_STATIC;
+				else process.env.IS_STATIC = previousStatic;
+			}
+		});
+		this.queue = operation.catch(() => void 0);
+		return operation;
+	}
+	update(input) {
+		const operation = this.queue.then(async () => {
+			const { modules } = await this.buildTree(input);
+			const invalidated = /* @__PURE__ */ new Set();
+			for (const module2 of modules.values()) {
+				for (const id of await this.session.update(module2)) invalidated.add(id);
+				this.moduleRecords.set(module2.id, module2);
+			}
+			return [...invalidated].sort();
+		});
+		this.queue = operation.catch(() => void 0);
+		return operation;
+	}
+	has(id) {
+		return this.session.has((0, import_compiler_core.resolvedModuleId)(cleanId(id)));
+	}
+	dependentsOf(id) {
+		return this.session.dependentsOf((0, import_compiler_core.resolvedModuleId)(cleanId(id)));
+	}
+	remove(id) {
+		const operation = this.queue.then(async () => {
+			const result = await this.session.remove((0, import_compiler_core.resolvedModuleId)(cleanId(id)));
+			for (const invalidatedId of result.invalidatedIds) {
+				this.moduleRecords.delete(invalidatedId);
+			}
+			return result;
+		});
+		this.queue = operation.catch(() => void 0);
+		return operation;
+	}
+	parseCount(id) {
+		return this.session.parseCount((0, import_compiler_core.resolvedModuleId)(cleanId(id)));
+	}
+	async compileNow(input) {
+		const { rootModule, modules } = await this.buildTree(input);
+		const invalidated = /* @__PURE__ */ new Set();
+		for (const module2 of modules.values()) {
+			for (const id of await this.session.update(module2)) invalidated.add(id);
+			this.moduleRecords.set(module2.id, module2);
+		}
+		const projectInfo = input.project.projectInfo;
+		if (!projectInfo.tamaguiConfig || !projectInfo.components) {
+			throw new Error("The compiler requires evaluated Tamagui config and components");
+		}
+		const componentModules = input.project.componentModules.map((component) => ({
+			moduleName: component.moduleName,
+			resolvedId: cleanId(component.id)
+		}));
+		const registry = (0, import_compilerHost.createComponentRegistry)(projectInfo.components, componentModules);
+		this.discovery.seed(registry);
+		const host = (0, import_compilerHost.createTamaguiCompilerHost)({
+			target: input.target,
+			tamaguiConfig: projectInfo.tamaguiConfig,
+			components: projectInfo.components,
+			componentModules,
+			registry,
+			disablePartialExtraction: input.project.disablePartialExtraction,
+			experimentalNativeFastPath: input.project.experimentalNativeFastPath,
+			zeroRuntime: input.project.zeroRuntime
+		});
+		const result = await this.session.compile({
+			module: rootModule,
+			adapter: {
+				target: input.target,
+				projectGeneration: input.project.generation,
+				host,
+				planCache: this.planCacheFor(input),
+				async load(id) {
+					return modules.get(id) ?? null;
+				},
+				prepare: (module2) => this.discovery.prepare(module2, registry, input.evaluate)
+			},
+			structuralPass: import_domStructuralPass.domStructuralPass
+		});
+		for (const id of result.invalidatedIds) invalidated.add(id);
+		return {
+			plan: result.plan,
+			output: result.output,
+			invalidatedIds: [...invalidated].sort()
+		};
+	}
+	/** host-resolved ids of every module discovery found components in */
+	discoveredModuleIds() {
+		return this.discovery.ids();
+	}
+	async buildTree(input) {
+		const moduleContext = compilerContext(input);
+		if (this.moduleContext !== moduleContext) {
+			this.moduleRecords.clear();
+			this.discovery.clear();
+			this.moduleContext = moduleContext;
+		}
+		const componentBySpecifier = new Map(input.project.componentModules.map((component) => [component.moduleName, (0, import_compiler_core.resolvedModuleId)(cleanId(component.id))]));
+		const modules = /* @__PURE__ */ new Map();
+		const loading = /* @__PURE__ */ new Set();
+		const addInstalledClosure = (module2) => {
+			if (modules.has(module2.id) || loading.has(module2.id)) return;
+			loading.add(module2.id);
+			for (const dependency of module2.imports) {
+				if (dependency.external) continue;
+				const installedDependency = this.moduleRecords.get(dependency.resolvedId);
+				if (installedDependency && this.session.has(dependency.resolvedId)) {
+					addInstalledClosure(installedDependency);
+				}
+			}
+			modules.set(module2.id, module2);
+			loading.delete(module2.id);
+		};
+		const loadModule = async (rawId, source) => {
+			const id = (0, import_compiler_core.resolvedModuleId)(cleanId(rawId));
+			const existing = modules.get(id);
+			if (existing) return existing;
+			const installed = this.moduleRecords.get(id);
+			if (installed?.source === source && this.session.has(id)) {
+				addInstalledClosure(installed);
+				return installed;
+			}
+			if (loading.has(id)) {
+				return {
+					id,
+					source,
+					imports: []
+				};
+			}
+			loading.add(id);
+			const imports = [];
+			for (const specifier of import_compiler_core.yukuFactory.scanImports(id, source)) {
+				const configuredComponent = componentBySpecifier.get(specifier);
+				if (configuredComponent) {
+					imports.push({
+						specifier,
+						resolvedId: configuredComponent,
+						external: true
+					});
+					continue;
+				}
+				const resolution = await input.resolve(specifier, id);
+				if (!resolution) continue;
+				const canLink = !resolution.external && sourceCanBeLinked(input.root, resolution.id);
+				const resolvedId = canLink ? (0, import_compiler_core.resolvedModuleId)(cleanId(resolution.id)) : import_node_path.default.isAbsolute(cleanId(resolution.id)) ? (0, import_compiler_core.resolvedModuleId)(cleanId(resolution.id)) : externalId(specifier);
+				imports.push({
+					specifier,
+					resolvedId,
+					external: !canLink
+				});
+				if (canLink && !modules.has(resolvedId) && !loading.has(resolvedId)) {
+					const installedDependency = this.moduleRecords.get(resolvedId);
+					if (installedDependency && this.session.has(resolvedId)) {
+						addInstalledClosure(installedDependency);
+					} else {
+						const dependencySource = await input.load(resolution.id);
+						if (dependencySource !== null) {
+							await loadModule(resolution.id, dependencySource);
+						}
+					}
+				}
+			}
+			const module2 = {
+				id,
+				source,
+				imports
+			};
+			modules.set(id, module2);
+			loading.delete(id);
+			return module2;
+		};
+		const rootModule = await loadModule(input.id, input.source);
+		return {
+			rootModule,
+			modules
+		};
+	}
+};