@tamagui/static 2.7.7 → 3.0.0-beta.1093.1

package/dist/cjs/extractor/loadTamagui.cjs

@@ -0,0 +1,394 @@
+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 loadTamagui_exports = {};
+__export(loadTamagui_exports, {
+	esbuildWatchFiles: () => esbuildWatchFiles,
+	generateThemesAndLog: () => generateThemesAndLog,
+	getOptions: () => getOptions,
+	getTamaguiBuildConfigDependencies: () => getTamaguiBuildConfigDependencies,
+	loadTamagui: () => loadTamagui,
+	loadTamaguiBuildConfigAsync: () => loadTamaguiBuildConfigAsync,
+	loadTamaguiBuildConfigSync: () => loadTamaguiBuildConfigSync,
+	loadTamaguiFromModules: () => loadTamaguiFromModules,
+	loadTamaguiSync: () => loadTamaguiSync,
+	resolveWebOrNativeSpecificEntry: () => resolveWebOrNativeSpecificEntry
+});
+module.exports = __toCommonJS(loadTamagui_exports);
+var import_node_path = require("node:path");
+var import_node_module = require("node:module");
+var import_cli_color = require("@tamagui/cli-color");
+var import_esbuild = __toESM(require("esbuild"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_requireTamaguiCore = require("../helpers/requireTamaguiCore.cjs");
+var import_registerRequire = require("../registerRequire.cjs");
+var import_bundleConfig = require("./bundleConfig.cjs");
+var import_getTamaguiConfigPathFromOptionsConfig = require("./getTamaguiConfigPathFromOptionsConfig.cjs");
+var import_regenerateConfig = require("./regenerateConfig.cjs");
+const import_meta = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const getFilledOptions = (propsIn) => ({
+	platform: process.env.TAMAGUI_TARGET || "web",
+	config: "tamagui.config.ts",
+	components: ["tamagui"],
+	...propsIn
+});
+let isLoadingPromise;
+async function loadTamagui(propsIn, rebuild = false) {
+	if (isLoadingPromise) return await isLoadingPromise;
+	isLoadingPromise = (async () => {
+		const props = getFilledOptions(propsIn);
+		const bundleInfo = await (0, import_bundleConfig.getBundledConfig)(props, rebuild);
+		if (!bundleInfo) {
+			throw new Error(`[tamagui] The config and component bundle completed without a project result`);
+		}
+		await generateThemesAndLog(props, rebuild);
+		const maybeTamaguiConfig = bundleInfo.tamaguiConfig;
+		if (maybeTamaguiConfig && !maybeTamaguiConfig.parsed) {
+			const { createTamagui } = (0, import_requireTamaguiCore.requireTamaguiCore)(props.platform || "web");
+			bundleInfo.tamaguiConfig = createTamagui(bundleInfo.tamaguiConfig);
+		}
+		if (!(0, import_bundleConfig.hasBundledConfigChanged)()) {
+			return bundleInfo;
+		}
+		await (0, import_regenerateConfig.regenerateConfig)(props, bundleInfo);
+		return bundleInfo;
+	})();
+	try {
+		return await isLoadingPromise;
+	} finally {
+		isLoadingPromise = null;
+	}
+}
+async function loadTamaguiFromModules(propsIn, evaluated) {
+	const props = getFilledOptions(propsIn);
+	await generateThemesAndLog(props);
+	const configModule = evaluated.config;
+	let tamaguiConfig = configModule.default || configModule.config || configModule;
+	if ("config" in tamaguiConfig && tamaguiConfig.config && !("tokens" in tamaguiConfig)) {
+		tamaguiConfig = tamaguiConfig.config;
+	}
+	if (!tamaguiConfig) {
+		throw new Error(`The Vite module runner did not return a valid Tamagui config`);
+	}
+	const hostCore = (0, import_requireTamaguiCore.requireTamaguiCore)(props.platform || "web");
+	if (!tamaguiConfig.parsed) {
+		tamaguiConfig = hostCore.createTamagui(tamaguiConfig);
+	} else {
+		hostCore.installTamaguiConfig(tamaguiConfig);
+	}
+	(0, import_bundleConfig.setLoadedConfig)(tamaguiConfig);
+	const components = evaluated.components.map(({ moduleName, module: module2 }) => {
+		(0, import_registerRequire.setRequireResult)(moduleName, module2);
+		return {
+			moduleName,
+			nameToInfo: (0, import_bundleConfig.getComponentStaticConfigByName)(moduleName, module2.default ?? module2)
+		};
+	});
+	const projectInfo = {
+		components,
+		nameToPaths: {},
+		tamaguiConfig,
+		stampSources: evaluated.stampSources
+	};
+	if (props.outputCSS) {
+		await (0, import_bundleConfig.writeTamaguiCSS)(props.outputCSS, projectInfo.tamaguiConfig);
+	}
+	return projectInfo;
+}
+let waiting = false;
+const generateThemesAndLog = async (options, force = false) => {
+	if (waiting) return;
+	if (!options.themeBuilder) return;
+	try {
+		waiting = true;
+		await new Promise((res) => setTimeout(res, 30));
+		const didGenerate = await (0, import_regenerateConfig.generateTamaguiThemes)(options, force);
+		if (didGenerate) {
+			const whitespaceBefore = `  `;
+			(0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `${whitespaceBefore}\u27A1 [tamagui] generated themes: ${(0, import_node_path.relative)(options.root || process.cwd(), options.themeBuilder.output)}`);
+			if (options.outputCSS) {
+				const loadedConfig = (0, import_bundleConfig.getLoadedConfig)();
+				if (loadedConfig) {
+					await (0, import_bundleConfig.writeTamaguiCSS)(options.outputCSS, loadedConfig);
+				}
+			}
+		}
+	} finally {
+		waiting = false;
+	}
+};
+const last = {};
+const lastVersion = {};
+const buildConfigDependencies = /* @__PURE__ */ new WeakMap();
+function getTamaguiBuildConfigDependencies(options) {
+	return buildConfigDependencies.get(options) ?? [];
+}
+async function loadTamaguiBuildConfigAsync(tamaguiOptions) {
+	const buildFilePath = tamaguiOptions?.buildFile ?? "./tamagui.build.ts";
+	const root = tamaguiOptions?.root || process.cwd();
+	const absolutePath = (0, import_node_path.resolve)(root, buildFilePath);
+	if (import_fs_extra.default.existsSync(absolutePath)) {
+		try {
+			const result = await import_esbuild.default.build({
+				entryPoints: [absolutePath],
+				absWorkingDir: root,
+				bundle: true,
+				packages: "external",
+				platform: "node",
+				format: "cjs",
+				target: "node18",
+				write: false,
+				metafile: true
+			});
+			const module2 = { exports: {} };
+			const projectRequire = (0, import_node_module.createRequire)(absolutePath);
+			const code = result.outputFiles[0]?.text;
+			if (!code) throw new Error(`No output generated for ${buildFilePath}`);
+			const fn = new Function("module", "exports", "require", "process", code);
+			fn(module2, module2.exports, projectRequire, process);
+			const out = module2.exports.default || module2.exports;
+			if (!out || typeof out !== "object") {
+				throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+			}
+			const loadedOptions = {
+				...tamaguiOptions,
+				...out
+			};
+			const dependencies2 = Object.keys(result.metafile.inputs).map((input) => (0, import_node_path.resolve)(root, input));
+			buildConfigDependencies.set(loadedOptions, dependencies2);
+			tamaguiOptions = loadedOptions;
+		} catch (err) {
+			console.error(`[tamagui] Error loading ${buildFilePath}:`, err);
+			throw err;
+		}
+	}
+	if (!tamaguiOptions) {
+		throw new Error(`No tamagui build options found either via input props or at tamagui.build.ts`);
+	}
+	const options = {
+		config: "tamagui.config.ts",
+		components: ["tamagui", "@tamagui/core"],
+		...tamaguiOptions
+	};
+	const dependencies = buildConfigDependencies.get(tamaguiOptions);
+	if (dependencies) buildConfigDependencies.set(options, dependencies);
+	return options;
+}
+function loadTamaguiBuildConfigSync(tamaguiOptions) {
+	const buildFilePath = tamaguiOptions?.buildFile ?? "./tamagui.build.ts";
+	const root = tamaguiOptions?.root || process.cwd();
+	const absolutePath = (0, import_node_path.resolve)(root, buildFilePath);
+	if (import_fs_extra.default.existsSync(absolutePath)) {
+		const registered = (0, import_registerRequire.registerRequire)("web", { ignoredModules: tamaguiOptions?.dangerouslyIgnoreStaticEvaluationModules });
+		try {
+			const out = nodeRequire(absolutePath).default;
+			if (!out) {
+				throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+			}
+			tamaguiOptions = {
+				...tamaguiOptions,
+				...out
+			};
+		} finally {
+			registered.unregister();
+		}
+	}
+	if (!tamaguiOptions) {
+		throw new Error(`No tamagui build options found either via input props or at tamagui.build.ts`);
+	}
+	return {
+		config: "tamagui.config.ts",
+		components: ["tamagui", "@tamagui/core"],
+		...tamaguiOptions
+	};
+}
+function loadTamaguiSync({ forceExports, cacheKey, ...propsIn }) {
+	const key = JSON.stringify(propsIn);
+	if (last[key] && !(0, import_bundleConfig.hasBundledConfigChanged)()) {
+		if (!lastVersion[key] || lastVersion[key] === cacheKey) {
+			return last[key];
+		}
+	}
+	lastVersion[key] = cacheKey || "";
+	const props = getFilledOptions(propsIn);
+	const previousIsStatic = process.env.IS_STATIC;
+	const previousIsServer = process.env.TAMAGUI_IS_SERVER;
+	const previousDev = globalThis["__DEV__"];
+	process.env.IS_STATIC = "is_static";
+	process.env.TAMAGUI_IS_SERVER = "true";
+	const { unregister } = (0, import_registerRequire.registerRequire)(props.platform || "web", { ignoredModules: props.dangerouslyIgnoreStaticEvaluationModules });
+	try {
+		globalThis["__DEV__"] = process.env.NODE_ENV === "development";
+		let tamaguiConfig = null;
+		if (propsIn.config) {
+			const configPath = (0, import_getTamaguiConfigPathFromOptionsConfig.getTamaguiConfigPathFromOptionsConfig)(propsIn.config, propsIn.root);
+			const exp = nodeRequire(configPath);
+			if (!exp) {
+				throw new Error(`The Tamagui config module did not export a value`);
+			}
+			tamaguiConfig = exp["default"] || exp["config"] || exp;
+			if (!tamaguiConfig || !tamaguiConfig.parsed) {
+				const confPath = nodeRequire.resolve(configPath);
+				throw new Error(`Can't find valid config in ${confPath}:
+          
+  Be sure you "export default" or "export const config" the config.`);
+			}
+			if (tamaguiConfig) {
+				const { createTamagui } = (0, import_requireTamaguiCore.requireTamaguiCore)(props.platform || "web");
+				createTamagui(tamaguiConfig);
+			}
+		}
+		const components = (0, import_bundleConfig.loadComponentsSync)(props, forceExports);
+		if (!components) {
+			throw new Error(`No components loaded`);
+		}
+		if (process.env.DEBUG === "tamagui") {
+			console.info(`components`, components);
+		}
+		const info = {
+			components,
+			tamaguiConfig,
+			nameToPaths: (0, import_registerRequire.getNameToPaths)()
+		};
+		if (tamaguiConfig) {
+			const { outputCSS } = props;
+			if (outputCSS) {
+				(0, import_bundleConfig.writeTamaguiCSS)(outputCSS, tamaguiConfig);
+			}
+			(0, import_regenerateConfig.regenerateConfigSync)(props, info);
+		}
+		last[key] = {
+			...info,
+			cached: true
+		};
+		return info;
+	} finally {
+		if (previousIsStatic === void 0) delete process.env.IS_STATIC;
+		else process.env.IS_STATIC = previousIsStatic;
+		if (previousIsServer === void 0) delete process.env.TAMAGUI_IS_SERVER;
+		else process.env.TAMAGUI_IS_SERVER = previousIsServer;
+		globalThis["__DEV__"] = previousDev;
+		unregister();
+	}
+}
+async function getOptions({ root = process.cwd(), tsconfigPath = "tsconfig.json", tamaguiOptions, host, debug } = {}) {
+	const dotDir = (0, import_node_path.join)(root, ".tamagui");
+	let pkgJson = {};
+	try {
+		pkgJson = await import_fs_extra.default.readJSON((0, import_node_path.join)(root, "package.json"));
+	} catch (err) {}
+	return {
+		mode: process.env.NODE_ENV === "production" ? "production" : "development",
+		root,
+		host: host || "127.0.0.1",
+		pkgJson,
+		debug,
+		tsconfigPath,
+		tamaguiOptions: {
+			platform: process.env.TAMAGUI_TARGET || "web",
+			components: ["tamagui"],
+			...tamaguiOptions,
+			config: tamaguiOptions?.config ?? await getDefaultTamaguiConfigPath(root, tamaguiOptions?.config)
+		},
+		paths: {
+			root,
+			dotDir,
+			conf: (0, import_node_path.join)(dotDir, "tamagui.config.json"),
+			types: (0, import_node_path.join)(dotDir, "types.json")
+		}
+	};
+}
+function resolveWebOrNativeSpecificEntry(entry, platform) {
+	const workspaceRoot = (0, import_node_path.resolve)();
+	const resolved = nodeRequire.resolve(entry, { paths: [workspaceRoot] });
+	const ext = (0, import_node_path.extname)(resolved);
+	const fileName = (0, import_node_path.basename)(resolved).replace(ext, "");
+	const target = platform || process.env.TAMAGUI_TARGET || "web";
+	const specificExt = target === "web" ? "web" : "native";
+	const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + "." + specificExt + ext);
+	if (import_fs_extra.default.existsSync(specificFile)) {
+		return specificFile;
+	}
+	return entry;
+}
+const defaultPaths = ["tamagui.config.ts", (0, import_node_path.join)("src", "tamagui.config.ts")];
+let hasWarnedOnce = false;
+async function getDefaultTamaguiConfigPath(root, configPath) {
+	const searchPaths = [...new Set([configPath, ...defaultPaths].filter(Boolean).map((p) => (0, import_node_path.join)(root, p)))];
+	for (const path of searchPaths) {
+		if (await import_fs_extra.default.pathExists(path)) {
+			return path;
+		}
+	}
+	if (!hasWarnedOnce) {
+		hasWarnedOnce = true;
+		console.warn(`Warning: couldn't find tamagui.config.ts in the following paths given configuration "${configPath}":
+    ${searchPaths.join(`
+  `)}
+  `);
+	}
+}
+async function esbuildWatchFiles(entry, onChanged) {
+	let hasRunOnce = false;
+	const context = await import_esbuild.default.context({
+		bundle: true,
+		entryPoints: [entry],
+		resolveExtensions: [
+			".ts",
+			".tsx",
+			".js",
+			".mjs"
+		],
+		logLevel: "silent",
+		write: false,
+		alias: {
+			"react-native-web": "@tamagui/react-native-web-lite",
+			"react-native": "@tamagui/react-native-web-lite"
+		},
+		plugins: [{
+			name: `on-rebuild`,
+			setup({ onEnd, onResolve }) {
+				let filter = /^[^./]|^\.[^./]|^\.\.[^/]/;
+				onResolve({ filter }, (args) => ({
+					path: args.path,
+					external: true
+				}));
+				onEnd(() => {
+					if (!hasRunOnce) {
+						hasRunOnce = true;
+					} else {
+						onChanged();
+					}
+				});
+			}
+		}]
+	});
+	void context.watch();
+	return () => {
+		context.dispose();
+	};
+}

package/dist/cjs/extractor/regenerateConfig.cjs

@@ -0,0 +1,160 @@
+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 regenerateConfig_exports = {};
+__export(regenerateConfig_exports, {
+	generateTamaguiThemes: () => generateTamaguiThemes,
+	regenerateConfig: () => regenerateConfig,
+	regenerateConfigSync: () => regenerateConfigSync
+});
+module.exports = __toCommonJS(regenerateConfig_exports);
+var import_node_path = require("node:path");
+var import_node_module = require("node:module");
+var import_generate_themes = require("@tamagui/generate-themes");
+var import_helpers = require("@tamagui/helpers");
+var import_tooling = require("@tamagui/style-grammar/tooling");
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_requireTamaguiCore = require("../helpers/requireTamaguiCore.cjs");
+var import_bundleConfig = require("./bundleConfig.cjs");
+async function regenerateConfig(tamaguiOptions, configIn, rebuild = false) {
+	try {
+		const config = configIn ?? await (0, import_bundleConfig.getBundledConfig)(tamaguiOptions, rebuild);
+		if (!config) return;
+		const out = transformConfig(config, tamaguiOptions.platform || "web");
+		const confFile = getConfigFile(tamaguiOptions);
+		await import_fs_extra.default.ensureDir((0, import_node_path.dirname)(confFile));
+		await import_fs_extra.default.writeJSON(confFile, out, { spaces: 2 });
+	} catch (err) {
+		if (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) {
+			console.warn("regenerateConfig error", err);
+		}
+	}
+}
+function regenerateConfigSync(tamaguiOptions, config) {
+	try {
+		const confFile = getConfigFile(tamaguiOptions);
+		import_fs_extra.default.ensureDirSync((0, import_node_path.dirname)(confFile));
+		import_fs_extra.default.writeJSONSync(confFile, transformConfig(config, tamaguiOptions.platform || "web"), { spaces: 2 });
+	} catch (err) {
+		if (process.env.DEBUG?.includes("tamagui") || process.env.IS_TAMAGUI_DEV) {
+			console.warn("regenerateConfig error", err);
+		}
+	}
+}
+async function generateTamaguiThemes(tamaguiOptions, force = false) {
+	if (!tamaguiOptions.themeBuilder) {
+		return;
+	}
+	const { input, output } = tamaguiOptions.themeBuilder;
+	const root = tamaguiOptions.root || process.cwd();
+	const tamaguiDir = (0, import_node_path.join)(root, ".tamagui");
+	const projectRequire = (0, import_node_module.createRequire)((0, import_node_path.join)(root, "package.json"));
+	const inPath = resolveRelativePath(input, root, projectRequire);
+	const outPath = resolveRelativePath(output, root, projectRequire);
+	const generatedOutput = await (0, import_generate_themes.generateThemes)(inPath);
+	const hasChanged = force || await (async () => {
+		try {
+			if (!generatedOutput) return false;
+			const next = generatedOutput.generated;
+			const current = await import_fs_extra.default.readFile(outPath, "utf-8");
+			return next !== current;
+		} catch (err) {}
+		return true;
+	})();
+	if (hasChanged) {
+		await (0, import_generate_themes.writeGeneratedThemes)(tamaguiDir, outPath, generatedOutput);
+	}
+	return hasChanged;
+}
+const getConfigFile = (options) => (0, import_node_path.join)(options.root || process.cwd(), ".tamagui", "tamagui.config.json");
+const resolveRelativePath = (inputPath, root, projectRequire) => inputPath.startsWith(".") ? (0, import_node_path.join)(root, inputPath) : projectRequire.resolve(inputPath);
+function cloneDeepSafe(x, excludeKeys = {}) {
+	if (!x) return x;
+	if (Array.isArray(x)) return x.map((_) => cloneDeepSafe(_));
+	if (typeof x === "function") return `Function`;
+	if (typeof x !== "object") return x;
+	if ("$$typeof" in x) return "Component";
+	return Object.fromEntries(Object.entries(x).flatMap(([k, v]) => excludeKeys[k] ? [] : [[k, cloneDeepSafe(v)]]));
+}
+function buildPropCategories() {
+	const out = {};
+	const byPrefix = {};
+	for (const entry of import_tooling.grammarEntries) {
+		if (entry.tokenCategory) out[entry.prop] = entry.tokenCategory;
+		if (entry.prefix) (byPrefix[entry.prefix] ||= /* @__PURE__ */ new Set()).add(entry.tokenCategory);
+	}
+	for (const [prefix, categories] of Object.entries(byPrefix)) {
+		if (categories.size !== 1) continue;
+		const [only] = categories;
+		if (only) out[prefix] = only;
+	}
+	return out;
+}
+function transformConfig(config, platform) {
+	if (!config) {
+		return null;
+	}
+	const { getVariableValue } = (0, import_requireTamaguiCore.requireTamaguiCore)(platform);
+	const next = cloneDeepSafe(config, { validStyles: true });
+	const { components, nameToPaths, tamaguiConfig } = next;
+	const { themes, tokens } = tamaguiConfig;
+	for (const key in themes) {
+		const theme = themes[key];
+		for (const tkey in theme) {
+			theme[tkey] = getVariableValue(theme[tkey]);
+		}
+	}
+	for (const key in tokens) {
+		const token = { ...tokens[key] };
+		for (const tkey in token) {
+			token[tkey] = getVariableValue(token[tkey]);
+		}
+	}
+	for (const component of components) {
+		for (const _ in component.nameToInfo) {
+			const compDefinition = { ...component.nameToInfo[_] };
+			component.nameToInfo[_] = compDefinition;
+			const { parentStaticConfig, ...rest } = compDefinition.staticConfig;
+			compDefinition.staticConfig = rest;
+		}
+	}
+	next.nameToPaths = {};
+	for (const key in nameToPaths) {
+		next.nameToPaths[key] = [...nameToPaths[key]];
+	}
+	const { fontsParsed, getCSS, tokensParsed, themeConfig, shorthands: _shorthands, userShorthands, ...cleanedConfig } = next.tamaguiConfig;
+	return {
+		components,
+		nameToPaths,
+		tamaguiConfigMetadata: { themeFields: "values-only" },
+		tamaguiConfig: {
+			...cleanedConfig,
+			shorthands: userShorthands,
+			propCategories: buildPropCategories(),
+			styleProps: Object.keys(import_helpers.stylePropsAll)
+		}
+	};
+}

package/dist/cjs/extractor/watchTamaguiConfig.cjs

@@ -0,0 +1,63 @@
+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 watchTamaguiConfig_exports = {};
+__export(watchTamaguiConfig_exports, { watchTamaguiConfig: () => watchTamaguiConfig });
+module.exports = __toCommonJS(watchTamaguiConfig_exports);
+var import_node_module = require("node:module");
+var import_loadTamagui = require("./loadTamagui.cjs");
+var import_regenerateConfig = require("./regenerateConfig.cjs");
+const import_meta = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+let isWatching = false;
+async function watchTamaguiConfig(tamaguiOptions) {
+	if (process.env.NODE_ENV === "production" || tamaguiOptions.disable) {
+		return { dispose() {} };
+	}
+	if (isWatching) {
+		return;
+	}
+	isWatching = true;
+	const options = await (0, import_loadTamagui.getOptions)({ tamaguiOptions });
+	if (!options.tamaguiOptions.config) {
+		isWatching = false;
+		throw new Error(`No config`);
+	}
+	const disposeConfigWatcher = await (0, import_loadTamagui.esbuildWatchFiles)(options.tamaguiOptions.config, async () => {
+		await (0, import_loadTamagui.generateThemesAndLog)(options.tamaguiOptions);
+		await (0, import_regenerateConfig.regenerateConfig)(options.tamaguiOptions, null, true);
+	});
+	const themeBuilderInput = options.tamaguiOptions.themeBuilder?.input;
+	let disposeThemesWatcher;
+	if (themeBuilderInput) {
+		let inputPath = themeBuilderInput;
+		try {
+			inputPath = nodeRequire.resolve(themeBuilderInput);
+		} catch {}
+		disposeThemesWatcher = await (0, import_loadTamagui.esbuildWatchFiles)(inputPath, async () => {
+			await (0, import_loadTamagui.generateThemesAndLog)(options.tamaguiOptions);
+		});
+	}
+	return { dispose() {
+		isWatching = false;
+		disposeConfigWatcher();
+		disposeThemesWatcher?.();
+	} };
+}

package/dist/cjs/getPragmaOptions.cjs

@@ -0,0 +1,66 @@
+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 getPragmaOptions_exports = {};
+__export(getPragmaOptions_exports, { getPragmaOptions: () => getPragmaOptions });
+module.exports = __toCommonJS(getPragmaOptions_exports);
+function getPragmaOptions({ source, path }) {
+	let shouldPrintDebug = false;
+	let shouldDisable = false;
+	const firstLines = source.slice(0, 800);
+	let pragma = "";
+	for (const line of firstLines.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed && !trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
+			break;
+		}
+		pragma = trimmed.match(/(\/\/|\/\*)\s?!?\s?(tamagui-ignore|debug|debug-verbose)(\n|\s|$).*/)?.[2].trim() || "";
+		if (pragma) {
+			pragma = pragma.replace("!", "").trim();
+			break;
+		}
+	}
+	switch (pragma) {
+		case "tamagui-ignore":
+			shouldDisable = true;
+			break;
+		case "debug":
+			shouldPrintDebug = true;
+			break;
+		case "debug-verbose":
+			shouldPrintDebug = "verbose";
+			break;
+	}
+	if (process.env.TAMAGUI_DEBUG_FILE) {
+		if (path.includes(process.env.TAMAGUI_DEBUG_FILE)) {
+			shouldPrintDebug = "verbose";
+		}
+	}
+	if (process.env.DEBUG?.includes("tamagui")) {
+		shouldPrintDebug ||= true;
+	}
+	if (process.env.DEBUG?.includes("tamagui-verbose")) {
+		shouldPrintDebug = "verbose";
+	}
+	return {
+		shouldPrintDebug,
+		shouldDisable
+	};
+}