@tamagui/static 2.7.7 → 3.0.0-beta.1093.1

package/dist/cjs/zero/options.cjs

@@ -0,0 +1,162 @@
+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 options_exports = {};
+__export(options_exports, {
+	ZERO_INTEGRATION_SUPPORT: () => ZERO_INTEGRATION_SUPPORT,
+	ZERO_OUT_DIRNAME: () => ZERO_OUT_DIRNAME,
+	assertZeroConfigDrivers: () => assertZeroConfigDrivers,
+	assertZeroIntegrationSupport: () => assertZeroIntegrationSupport,
+	islandIdFor: () => islandIdFor,
+	resolveZeroRuntime: () => resolveZeroRuntime,
+	resolveZeroRuntimeSync: () => resolveZeroRuntimeSync
+});
+module.exports = __toCommonJS(options_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const ZERO_OUT_DIRNAME = ".tamagui/zero";
+function islandIdFor(moduleId) {
+	return import_node_path.default.basename(moduleId).replace(/\.[jt]sx?$/, "");
+}
+async function resolveZeroRuntime(options, root) {
+	const early = resolveZeroRuntimeEarly(options, root);
+	if (early.done) return early.resolved;
+	return finishZeroRuntime(options, root, early.islandGlobs, early.islandGlobs.length ? await (0, import_fast_glob.default)(early.islandGlobs, {
+		cwd: root,
+		absolute: true,
+		dot: false
+	}) : []);
+}
+function resolveZeroRuntimeSync(options, root) {
+	const early = resolveZeroRuntimeEarly(options, root);
+	if (early.done) return early.resolved;
+	return finishZeroRuntime(options, root, early.islandGlobs, early.islandGlobs.length ? import_fast_glob.default.sync(early.islandGlobs, {
+		cwd: root,
+		absolute: true,
+		dot: false
+	}) : []);
+}
+function resolveZeroRuntimeEarly(options, root) {
+	const requested = options.experimental?.zeroRuntime;
+	const outDir = import_node_path.default.join(root, ZERO_OUT_DIRNAME);
+	const off = {
+		mode: "off",
+		root,
+		islandGlobs: [],
+		islands: [],
+		outDir,
+		cssPath: ""
+	};
+	if (!requested) return {
+		done: true,
+		resolved: off
+	};
+	if (options.platform === "native" && requested === "report") {
+		return {
+			done: true,
+			resolved: {
+				...off,
+				mode: "report"
+			}
+		};
+	}
+	if (options.platform === "native") {
+		throw new Error(`[tamagui zero-runtime] experimental.zeroRuntime is web only. A native build always receives TAMAGUI_RUNTIME="full".`);
+	}
+	if (requested !== "report" && !options.outputCSS) {
+		throw new Error(`[tamagui zero-runtime] experimental.zeroRuntime requires outputCSS. The bundler owns one generated CSS artifact and derives TAMAGUI_DID_OUTPUT_CSS from it.`);
+	}
+	if (requested !== "report" && process.env.TAMAGUI_DOES_SSR_CSS === "mutates-themes") {
+		throw new Error(`[tamagui zero-runtime] Rule 4: TAMAGUI_DOES_SSR_CSS="mutates-themes" declares runtime theme mutation. Zero-runtime themes are build-time data. Remove runtime mutation or move that surface to a full-runtime island.`);
+	}
+	return {
+		done: false,
+		islandGlobs: requested === true || requested === "report" ? [] : requested.islands
+	};
+}
+function finishZeroRuntime(options, root, islandGlobs, matches) {
+	const outDir = import_node_path.default.join(root, ZERO_OUT_DIRNAME);
+	const outputCSS = options.outputCSS ?? "";
+	const islands = [...new Set(matches.map((match) => import_node_path.default.normalize(match)))].sort().map((module2) => {
+		const id = islandIdFor(module2);
+		return {
+			id,
+			module: module2,
+			loader: import_node_path.default.join(outDir, `${id}.loader.js`),
+			entry: import_node_path.default.join(outDir, `${id}.entry.js`)
+		};
+	});
+	const seen = /* @__PURE__ */ new Set();
+	for (const island of islands) {
+		if (seen.has(island.id)) {
+			throw new Error(`[tamagui zero-runtime] two declared islands share the basename "${island.id}". Island ids are their module basename because that is also the generated loader's filename.`);
+		}
+		seen.add(island.id);
+	}
+	if (islandGlobs.length && islands.length === 0) {
+		throw new Error(`[tamagui zero-runtime] experimental.zeroRuntime.islands matched no module for ${JSON.stringify(islandGlobs)}`);
+	}
+	return {
+		mode: options.experimental?.zeroRuntime === "report" ? "report" : "enforce",
+		root,
+		islandGlobs,
+		islands,
+		outDir,
+		cssPath: !outputCSS ? "" : import_node_path.default.isAbsolute(outputCSS) ? outputCSS : import_node_path.default.resolve(root, outputCSS)
+	};
+}
+function assertZeroConfigDrivers(config) {
+	const drivers = config.animationDrivers ? Object.entries(config.animationDrivers) : [["default", config.animations]];
+	for (const [name, driver] of drivers) {
+		if (!driver || driver.outputStyle === "css") continue;
+		throw new Error((0, import_compiler_core.zeroConfigDriverMessage)(name, driver.outputStyle));
+	}
+}
+const ZERO_INTEGRATION_SUPPORT = {
+	vite: {
+		base: true,
+		islands: true
+	},
+	"next-webpack": {
+		base: true,
+		islands: true
+	},
+	"metro-web": {
+		base: true,
+		islands: true
+	}
+};
+function assertZeroIntegrationSupport(integration, resolved) {
+	if (resolved.mode !== "enforce") return;
+	const support = ZERO_INTEGRATION_SUPPORT[integration];
+	if (!support.base) {
+		throw new Error(`[tamagui zero-runtime] ${integration} has not qualified for zero-runtime output in this version. Use zeroRuntime: "report" or choose a qualified integration.`);
+	}
+	if (resolved.islands.length && !support.islands) {
+		throw new Error(`[tamagui zero-runtime] ${integration} does not support experimental.zeroRuntime islands in this version. Use zeroRuntime: true without islands or choose an integration with island support.`);
+	}
+}

package/dist/cjs/zero/ownership.cjs

@@ -0,0 +1,78 @@
+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 ownership_exports = {};
+__export(ownership_exports, {
+	checkGlobalCSSArtifact: () => checkGlobalCSSArtifact,
+	declaresRuntimeThemeMutation: () => declaresRuntimeThemeMutation,
+	hashCSS: () => hashCSS,
+	resolveGlobalCSSOwnership: () => resolveGlobalCSSOwnership
+});
+module.exports = __toCommonJS(ownership_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_options = require("./options.cjs");
+const hashCSS = (css) => (0, import_node_crypto.createHash)("sha256").update(css).digest("hex").slice(0, 16);
+const normalize = (value) => value.split(/[?#]/, 1)[0].replace(/\\/g, "/");
+const declaresRuntimeThemeMutation = () => process.env.TAMAGUI_DOES_SSR_CSS === "mutates-themes";
+function resolveGlobalCSSOwnership(options, root) {
+	if (options.disable) return null;
+	if (options.platform === "native") return null;
+	if (!options.outputCSS) return null;
+	if (declaresRuntimeThemeMutation()) return null;
+	if ((0, import_options.resolveZeroRuntimeSync)(options, root).mode === "enforce") return null;
+	return { cssPath: import_node_path.default.isAbsolute(options.outputCSS) ? options.outputCSS : import_node_path.default.resolve(root, options.outputCSS) };
+}
+function checkGlobalCSSArtifact(input) {
+	const { cssPath, expectedCSS } = input;
+	let onDisk;
+	try {
+		onDisk = (0, import_node_fs.readFileSync)(cssPath, "utf8");
+	} catch {
+		return {
+			kind: "missing",
+			cssPath,
+			message: `[tamagui] the generated CSS artifact ${cssPath} does not exist, so this build cannot claim TAMAGUI_DID_OUTPUT_CSS. The design-system, :root, font and theme rules would be stripped from JavaScript and put nowhere.`
+		};
+	}
+	if (onDisk !== expectedCSS) {
+		return {
+			kind: "stale",
+			cssPath,
+			message: `[tamagui] the generated CSS artifact ${cssPath} is stale: it hashes ${hashCSS(onDisk)} but this build's config generates ${hashCSS(expectedCSS)}. Deriving TAMAGUI_DID_OUTPUT_CSS from it would ship rules that do not match the build.`
+		};
+	}
+	const wanted = normalize(cssPath);
+	for (const id of input.loadedModuleIds) {
+		if (normalize(id) === wanted) return null;
+	}
+	return {
+		kind: "unimported",
+		cssPath,
+		message: `[tamagui] the generated CSS artifact ${cssPath} exists but the entry graph never loads it. ${input.importHint}`
+	};
+}

package/dist/cjs/zero/theme.cjs

@@ -0,0 +1,337 @@
+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 theme_exports = {};
+__export(theme_exports, {
+	foldBranches: () => foldBranches,
+	lowerStaticTheme: () => lowerStaticTheme,
+	readStaticTheme: () => readStaticTheme,
+	resolveThemeChain: () => resolveThemeChain
+});
+module.exports = __toCommonJS(theme_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_helpers = require("@tamagui/helpers");
+var import_web = require("@tamagui/web");
+var import_theme_update = require("@tamagui/web/theme-update");
+const MAX_THEME_BRANCHES = 8;
+const LOWERABLE_RESERVED_PROPS = /* @__PURE__ */ new Set(["name", "contain"]);
+function jsxAttributeName(attribute) {
+	const name = (0, import_compiler_core.childNode)(attribute, "name");
+	return name && typeof name.name === "string" ? name.name : null;
+}
+function literalOf(node) {
+	if (!node) return void 0;
+	if (node.type === "Literal" && typeof node.value !== "object") {
+		return node.value;
+	}
+	return void 0;
+}
+function hasSideEffects(node) {
+	let found = false;
+	(0, import_compiler_core.walkAst)(node, (child) => {
+		if (child.type === "CallExpression" || child.type === "OptionalCallExpression" || child.type === "NewExpression" || child.type === "AwaitExpression" || child.type === "YieldExpression" || child.type === "AssignmentExpression" || child.type === "UpdateExpression" || child.type === "TaggedTemplateExpression") {
+			found = true;
+		}
+	});
+	return found;
+}
+function readNameOptions(value, source, guards) {
+	const literal = literalOf(value);
+	if (typeof literal === "string") {
+		return [{
+			test: guards.length ? guards.join(" && ") : null,
+			name: literal
+		}];
+	}
+	if (value.type === "ConditionalExpression") {
+		const test = (0, import_compiler_core.childNode)(value, "test");
+		const consequent = (0, import_compiler_core.childNode)(value, "consequent");
+		const alternate = (0, import_compiler_core.childNode)(value, "alternate");
+		if (!test || !consequent || !alternate) return null;
+		if (hasSideEffects(test)) return null;
+		const testText = source.slice(test.start, test.end).replace(/\s+/g, " ").trim();
+		const left = readNameOptions(consequent, source, [...guards, `(${testText})`]);
+		const right = readNameOptions(alternate, source, [...guards, `!(${testText})`]);
+		if (!left || !right) return null;
+		return [...left, ...right];
+	}
+	return null;
+}
+function foldBranches(branches) {
+	const last = branches[branches.length - 1];
+	if (new Set(branches.map((branch) => branch.value)).size === 1) return last.value;
+	let expression = last.value;
+	for (let index = branches.length - 2; index >= 0; index--) {
+		const branch = branches[index];
+		expression = branch.test === null ? branch.value : `${branch.test} ? ${branch.value} : ${expression}`;
+	}
+	return expression;
+}
+function resolveThemeChain(chain, rootThemeName, config) {
+	let branches = [{
+		test: null,
+		name: rootThemeName,
+		isNew: false,
+		schemeAuthored: false
+	}];
+	for (const node of chain) {
+		const next = [];
+		for (const parent of branches) {
+			for (const option of node.options) {
+				const resolved = (0, import_web.resolveThemeName)(parent.name, option.name, config.themes);
+				const schemeAuthored = parent.schemeAuthored || Boolean(option.name && (0, import_helpers.getThemeScheme)(option.name) && option.name in config.themes);
+				const tests = [parent.test, option.test].filter(Boolean);
+				next.push({
+					test: tests.length ? tests.join(" && ") : null,
+					name: resolved ?? parent.name,
+					isNew: resolved !== null || schemeAuthored !== parent.schemeAuthored,
+					schemeAuthored
+				});
+			}
+		}
+		branches = next;
+	}
+	return branches;
+}
+function readStaticTheme(element, id, source, config, kind = "Theme") {
+	const moduleId = (0, import_compiler_core.resolvedModuleId)(id);
+	const violations = [];
+	const css = /* @__PURE__ */ new Map();
+	const opening = (0, import_compiler_core.childNode)(element, "openingElement");
+	const closing = (0, import_compiler_core.childNode)(element, "closingElement");
+	const span = (node) => ({
+		id: moduleId,
+		start: node.start,
+		end: node.end
+	});
+	let options = [{
+		test: null,
+		name: void 0
+	}];
+	let contain = false;
+	const themeKeyProps = {};
+	for (const attribute of (0, import_compiler_core.childNodes)(opening, "attributes")) {
+		if (attribute.type !== "JSXAttribute") {
+			violations.push({
+				rule: 1,
+				code: "local/unsafe-style-spread",
+				span: span(attribute),
+				component: kind,
+				message: (0, import_compiler_core.zeroRuleMessage)(1, { component: kind })
+			});
+			continue;
+		}
+		const key = jsxAttributeName(attribute);
+		if (!key) continue;
+		const rawValue = (0, import_compiler_core.childNode)(attribute, "value");
+		const value = rawValue && rawValue.type === "JSXExpressionContainer" ? (0, import_compiler_core.childNode)(rawValue, "expression") : rawValue;
+		if (kind === "ThemeUpdate" && import_helpers.reservedThemeProps[key]) {
+			violations.push({
+				rule: 4,
+				code: "local/unsupported-target",
+				span: span(attribute),
+				component: kind,
+				message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `the <ThemeUpdate ${key}> prop, which belongs on <Theme>,` })
+			});
+			continue;
+		}
+		if (kind === "Theme" && key === "name") {
+			const read = value ? readNameOptions(value, source, []) : null;
+			if (!read) {
+				violations.push({
+					rule: 4,
+					code: "local/unsupported-target",
+					span: span(attribute),
+					component: "Theme",
+					message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `the <Theme name> value ${source.slice(attribute.start, attribute.end).replace(/\s+/g, " ").trim()}, which is not a literal theme name or a conditional over literal theme names,` })
+				});
+				continue;
+			}
+			options = read;
+			continue;
+		}
+		if (kind === "Theme" && import_helpers.reservedThemeProps[key]) {
+			if (!LOWERABLE_RESERVED_PROPS.has(key)) {
+				violations.push({
+					rule: 4,
+					code: "local/unsupported-target",
+					span: span(attribute),
+					component: "Theme",
+					message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `the <Theme ${key}> prop, which has no compiled form,` })
+				});
+				continue;
+			}
+			const literal2 = value ? literalOf(value) : true;
+			if (typeof literal2 !== "boolean") {
+				violations.push({
+					rule: 4,
+					code: "local/unsupported-target",
+					span: span(attribute),
+					component: "Theme",
+					message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `a non-literal <Theme ${key}> value,` })
+				});
+				continue;
+			}
+			if (key === "contain") contain = literal2;
+			continue;
+		}
+		if (kind === "Theme") {
+			violations.push({
+				rule: 4,
+				code: "local/unsupported-target",
+				span: span(attribute),
+				component: "Theme",
+				message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `the removed <Theme ${key}> inline-value spelling. Use <ThemeUpdate ${key}> around the subtree instead,` })
+			});
+			continue;
+		}
+		const literal = value ? literalOf(value) : void 0;
+		if (typeof literal !== "string" && typeof literal !== "number") {
+			violations.push({
+				rule: 3,
+				code: "local/dynamic-style-value",
+				span: span(attribute),
+				component: kind,
+				message: (0, import_compiler_core.zeroRuleMessage)(3, {
+					prop: key,
+					component: kind,
+					detail: value ? "a theme value must be a string or number literal at build time" : "a theme key needs a value"
+				})
+			});
+			continue;
+		}
+		themeKeyProps[key] = literal;
+	}
+	if (!closing) {
+		violations.push({
+			rule: 4,
+			code: "local/unsupported-target",
+			span: span(element),
+			component: "Theme",
+			message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `a self-closing <${kind}>, which has no subtree to theme,` })
+		});
+	}
+	const issues = [];
+	const themeUpdateConfig = config;
+	const inlineValues = kind === "ThemeUpdate" && Object.keys(themeKeyProps).length ? (0, import_theme_update.getInlineValuesFromProps)(themeKeyProps, themeUpdateConfig, (issue) => issues.push(issue)) : null;
+	for (const issue of issues) {
+		violations.push({
+			rule: 3,
+			code: "local/dynamic-style-value",
+			span: span(opening),
+			component: kind,
+			message: (0, import_compiler_core.zeroRuleMessage)(3, {
+				prop: issue.key,
+				component: kind,
+				detail: issue.message
+			})
+		});
+	}
+	const inlineCSS = inlineValues ? (0, import_theme_update.getVariablesCSSRules)(inlineValues, themeUpdateConfig) : null;
+	if (inlineCSS) css.set(inlineCSS.identifier, inlineCSS.rules.join(""));
+	if (violations.length) return {
+		node: null,
+		violations,
+		css
+	};
+	return {
+		node: {
+			kind,
+			element,
+			opening,
+			closing,
+			options,
+			contain,
+			layer: inlineValues && inlineCSS ? {
+				inlineValues,
+				inlineClassName: inlineCSS.identifier
+			} : null
+		},
+		violations,
+		css
+	};
+}
+function lowerStaticTheme(node, chain, rootThemeName, config, id) {
+	const moduleId = (0, import_compiler_core.resolvedModuleId)(id);
+	const branches = resolveThemeChain(chain, rootThemeName, config);
+	if (branches.length > MAX_THEME_BRANCHES) {
+		return {
+			edits: [],
+			violations: [{
+				rule: 4,
+				code: "local/unsupported-target",
+				span: {
+					id: moduleId,
+					start: node.element.start,
+					end: node.element.end
+				},
+				component: "Theme",
+				message: (0, import_compiler_core.zeroRuleMessage)(4, { detail: `a <Theme> chain that enumerates ${branches.length} theme names, past the ${MAX_THEME_BRANCHES} this lowers,` })
+			}]
+		};
+	}
+	const inlineClass = node.layer?.inlineClassName ?? "";
+	const classBranches = branches.map((branch) => ({
+		test: branch.test,
+		value: JSON.stringify([
+			branch.isNew ? (0, import_helpers.getThemeClassNames)(branch.name, false, branch.schemeAuthored) : "",
+			"is_Theme",
+			inlineClass
+		].filter(Boolean).join(" ").replace(/\s+/g, " ").trim())
+	}));
+	const baseStyle = node.contain ? `display:"contents",contain:"strict"` : `display:"contents"`;
+	const styleBranches = branches.map((branch) => {
+		const theme = config.themes[branch.name];
+		const color = branch.isNew && theme ? (0, import_web.variableToString)(theme.color) : "";
+		return {
+			test: branch.test,
+			value: color ? `{color:${JSON.stringify(color)},${baseStyle}}` : `{${baseStyle}}`
+		};
+	});
+	const className = foldBranches(classBranches);
+	const style = foldBranches(styleBranches);
+	const classAttribute = className.startsWith("\"") ? `className=${className}` : `className={${className}}`;
+	const edits = [{
+		start: node.opening.start,
+		end: node.opening.end,
+		content: `<span ${classAttribute} style={${style}}>`,
+		origin: {
+			id: moduleId,
+			start: node.opening.start,
+			end: node.opening.end
+		}
+	}];
+	if (node.closing) {
+		edits.push({
+			start: node.closing.start,
+			end: node.closing.end,
+			content: `</span>`,
+			origin: {
+				id: moduleId,
+				start: node.closing.start,
+				end: node.closing.end
+			}
+		});
+	}
+	return {
+		edits,
+		violations: []
+	};
+}