@tamagui/static 2.7.7-1788328229285 → 3.0.0-beta.1093.1

package/dist/cjs/check-dep-versions.cjs

@@ -0,0 +1,354 @@
+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 check_dep_versions_exports = {};
+__export(check_dep_versions_exports, { CDVC: () => CDVC });
+module.exports = __toCommonJS(check_dep_versions_exports);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_js_yaml = require("js-yaml");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+function calculateVersionsForEachDependency(packages, depType = DEFAULT_DEP_TYPES) {
+	const dependenciesToVersionsSeen = /* @__PURE__ */ new Map();
+	for (const package_ of packages) {
+		recordDependencyVersionsForPackageJson(dependenciesToVersionsSeen, package_, depType);
+	}
+	return dependenciesToVersionsSeen;
+}
+function recordDependencyVersionsForPackageJson(dependenciesToVersionsSeen, package_, depType) {
+	if (package_.packageJson.name && package_.packageJson.version) {
+		recordDependencyVersion(dependenciesToVersionsSeen, package_.packageJson.name, package_.packageJson.version, package_, true);
+	}
+	if (depType.includes("dependencies") && package_.packageJson.dependencies) {
+		for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.dependencies)) {
+			if (dependencyVersion) {
+				recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+			}
+		}
+	}
+	if (depType.includes("devDependencies") && package_.packageJson.devDependencies) {
+		for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.devDependencies)) {
+			if (dependencyVersion) {
+				recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+			}
+		}
+	}
+	if (depType.includes("optionalDependencies") && package_.packageJson.optionalDependencies) {
+		for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.optionalDependencies)) {
+			if (dependencyVersion) {
+				recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+			}
+		}
+	}
+	if (depType.includes("peerDependencies") && package_.packageJson.peerDependencies) {
+		for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.peerDependencies)) {
+			if (dependencyVersion) {
+				recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+			}
+		}
+	}
+	if (depType.includes("resolutions") && package_.packageJson.resolutions) {
+		for (const [dependency, dependencyVersion] of Object.entries(package_.packageJson.resolutions)) {
+			if (dependencyVersion) {
+				recordDependencyVersion(dependenciesToVersionsSeen, dependency, dependencyVersion, package_);
+			}
+		}
+	}
+}
+function recordDependencyVersion(dependenciesToVersionsSeen, dependency, version, package_, isLocalPackageVersion = false) {
+	if (!dependenciesToVersionsSeen.has(dependency)) {
+		dependenciesToVersionsSeen.set(dependency, []);
+	}
+	const list = dependenciesToVersionsSeen.get(dependency);
+	if (list) {
+		list.push({
+			package: package_,
+			version,
+			isLocalPackageVersion
+		});
+	}
+}
+function calculateDependenciesAndVersions(dependencyVersions) {
+	return [...dependencyVersions.entries()].sort((a, b) => a[0].localeCompare(b[0])).flatMap(([dependency, versionObjectsForDep]) => {
+		if (!versionObjectsForDep) {
+			return [];
+		}
+		let versions = versionObjectsForDep.filter((versionObject) => !versionObject.isLocalPackageVersion).map((versionObject) => versionObject.version);
+		const localPackageVersions = versionObjectsForDep.filter((versionObject) => versionObject.isLocalPackageVersion).map((versionObject) => versionObject.version);
+		const allVersionsHaveWorkspacePrefix = versions.every((version) => version.startsWith("workspace:"));
+		const hasIncompatibilityWithLocalPackageVersion = versions.some((version) => localPackageVersions[0] !== version);
+		if (localPackageVersions.length === 1 && !allVersionsHaveWorkspacePrefix && hasIncompatibilityWithLocalPackageVersion) {
+			versions = [...versions, ...localPackageVersions];
+		}
+		const uniqueVersions = [...new Set(versions)];
+		const uniqueVersionsWithInfo = versionsObjectsWithSortedPackages(uniqueVersions, versionObjectsForDep);
+		return {
+			dependency,
+			versions: uniqueVersionsWithInfo
+		};
+	});
+}
+function versionsObjectsWithSortedPackages(versions, versionObjects) {
+	return versions.map((version) => {
+		const matchingVersionObjects = versionObjects.filter((versionObject) => versionObject.version === version);
+		return {
+			version,
+			packages: matchingVersionObjects.map((object) => object.package).sort((a, b) => Package.comparator(a, b))
+		};
+	});
+}
+const HARDCODED_IGNORED_DEPENDENCIES = /* @__PURE__ */ new Set(["//"]);
+function filterOutIgnoredDependencies(mismatchingVersions, ignoredDependencies, includedDependencyPatterns) {
+	for (const ignoreDependency of ignoredDependencies) {
+		if (!mismatchingVersions.some((mismatchingVersion) => mismatchingVersion.dependency === ignoreDependency)) {
+			throw new Error(`Specified option '--ignore-dep ${ignoreDependency}', but no version mismatches detected for this dependency.`);
+		}
+	}
+	if (ignoredDependencies.length > 0 || includedDependencyPatterns.length > 0 || mismatchingVersions.some((mismatchingVersion) => HARDCODED_IGNORED_DEPENDENCIES.has(mismatchingVersion.dependency))) {
+		return mismatchingVersions.filter((mismatchingVersion) => !ignoredDependencies.includes(mismatchingVersion.dependency) && includedDependencyPatterns.some((ignoreDependencyPattern) => mismatchingVersion.dependency.match(ignoreDependencyPattern)) && !HARDCODED_IGNORED_DEPENDENCIES.has(mismatchingVersion.dependency));
+	}
+	return mismatchingVersions;
+}
+function getPackages(root, ignorePackages, ignorePackagePatterns, ignorePaths, ignorePathPatterns) {
+	if (!Package.exists(root)) {
+		throw new Error("No package.json found at provided path.");
+	}
+	const packages = accumulatePackages(root, ["."]);
+	for (const ignoredPackage of ignorePackages) {
+		if (!Package.some(packages, (package_) => package_.name === ignoredPackage)) {
+			throw new Error(`Specified option '--ignore-package ${ignoredPackage}', but no such package detected in workspace.`);
+		}
+	}
+	for (const ignoredPackagePattern of ignorePackagePatterns) {
+		if (!Package.some(packages, (package_) => ignoredPackagePattern.test(package_.name))) {
+			throw new Error(`Specified option '--ignore-package-pattern ${String(ignoredPackagePattern)}', but no matching packages detected in workspace.`);
+		}
+	}
+	for (const ignoredPath of ignorePaths) {
+		if (!Package.some(packages, (package_) => package_.pathRelative.includes(ignoredPath))) {
+			throw new Error(`Specified option '--ignore-path ${ignoredPath}', but no matching paths detected in workspace.`);
+		}
+	}
+	for (const ignoredPathPattern of ignorePathPatterns) {
+		if (!Package.some(packages, (package_) => ignoredPathPattern.test(package_.pathRelative))) {
+			throw new Error(`Specified option '--ignore-path-pattern ${String(ignoredPathPattern)}', but no matching paths detected in workspace.`);
+		}
+	}
+	if (ignorePackages.length > 0 || ignorePackagePatterns.length > 0 || ignorePaths.length > 0 || ignorePathPatterns.length > 0) {
+		return packages.filter((package_) => !ignorePackages.includes(package_.name) && !ignorePackagePatterns.some((ignorePackagePattern) => package_.name.match(ignorePackagePattern)) && !ignorePaths.some((ignorePath) => package_.pathRelative.includes(ignorePath)) && !ignorePathPatterns.some((ignorePathPattern) => package_.pathRelative.match(ignorePathPattern)));
+	}
+	return packages;
+}
+function expandWorkspaces(root, workspacePatterns) {
+	return workspacePatterns.flatMap((workspace) => {
+		if (!workspace.includes("*")) {
+			return [workspace];
+		}
+		return import_fast_glob.default.globSync(workspace, {
+			onlyDirectories: true,
+			cwd: root,
+			ignore: ["**/node_modules"]
+		});
+	});
+}
+function accumulatePackages(root, paths) {
+	const results = [];
+	for (const relativePath of paths) {
+		const path = (0, import_node_path.join)(root, relativePath);
+		if (Package.exists(path)) {
+			const package_ = new Package(path, root);
+			results.push(package_, ...accumulatePackages(path, expandWorkspaces(path, package_.workspacePatterns)));
+		}
+	}
+	return results;
+}
+var Package = class {
+	/** Absolute path to package */
+	path;
+	/** Absolute path to workspace.*/
+	pathWorkspace;
+	/** Absolute path to package.json. */
+	pathPackageJson;
+	packageJson;
+	packageJsonEndsInNewline;
+	pnpmWorkspacePackages;
+	constructor(path, pathWorkspace) {
+		this.path = path;
+		this.pathWorkspace = pathWorkspace;
+		this.pathPackageJson = (0, import_node_path.join)(path, "package.json");
+		const packageJsonContents = (0, import_node_fs.readFileSync)(this.pathPackageJson, "utf8");
+		this.packageJsonEndsInNewline = packageJsonContents.endsWith("\n");
+		this.packageJson = JSON.parse(packageJsonContents);
+		const pnpmWorkspacePath = (0, import_node_path.join)(path, "pnpm-workspace.yaml");
+		if ((0, import_node_fs.existsSync)(pnpmWorkspacePath)) {
+			const pnpmWorkspaceContents = (0, import_node_fs.readFileSync)(pnpmWorkspacePath, "utf8");
+			const pnpmWorkspaceYaml = (0, import_js_yaml.load)(pnpmWorkspaceContents);
+			this.pnpmWorkspacePackages = pnpmWorkspaceYaml.packages;
+		}
+	}
+	get name() {
+		if (this.workspacePatterns.length > 0 && !this.packageJson.name) {
+			return "(Root)";
+		}
+		if (!this.packageJson.name) {
+			throw new Error(`${this.pathPackageJson} missing \`name\``);
+		}
+		return this.packageJson.name;
+	}
+	/** Relative to workspace root. */
+	get pathRelative() {
+		return (0, import_node_path.relative)(this.pathWorkspace, this.path);
+	}
+	get workspacePatterns() {
+		if (this.packageJson.workspaces) {
+			if (Array.isArray(this.packageJson.workspaces)) {
+				return this.packageJson.workspaces;
+			} else if (this.packageJson.workspaces.packages) {
+				if (!Array.isArray(this.packageJson.workspaces.packages)) {
+					throw new TypeError("package.json `workspaces.packages` is not a string array.");
+				}
+				return this.packageJson.workspaces.packages;
+			} else {
+				throw new TypeError("package.json `workspaces` is not a string array.");
+			}
+		}
+		if (this.pnpmWorkspacePackages) {
+			if (!Array.isArray(this.pnpmWorkspacePackages)) {
+				throw new TypeError("pnpm-workspace.yaml `packages` is not a string array.");
+			}
+			return this.pnpmWorkspacePackages;
+		}
+		return [];
+	}
+	static exists(path) {
+		const packageJsonPath = (0, import_node_path.join)(path, "package.json");
+		return (0, import_node_fs.existsSync)(packageJsonPath);
+	}
+	static some(packages, callback) {
+		return packages.some((package_) => callback(package_));
+	}
+	static comparator(package1, package2) {
+		return package1.name.localeCompare(package2.name);
+	}
+};
+var DEPENDENCY_TYPE = /* @__PURE__ */ ((DEPENDENCY_TYPE2) => {
+	DEPENDENCY_TYPE2["dependencies"] = "dependencies";
+	DEPENDENCY_TYPE2["devDependencies"] = "devDependencies";
+	DEPENDENCY_TYPE2["optionalDependencies"] = "optionalDependencies";
+	DEPENDENCY_TYPE2["peerDependencies"] = "peerDependencies";
+	DEPENDENCY_TYPE2["resolutions"] = "resolutions";
+	return DEPENDENCY_TYPE2;
+})(DEPENDENCY_TYPE || {});
+const DEFAULT_DEP_TYPES = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"resolutions"
+];
+function check(path) {
+	const options = { includeDepPattern: [
+		"tamagui",
+		"react-native-web-lite",
+		"react-native-web-internals"
+	] };
+	if (options && options.depType && options.depType.some((dt) => !Object.keys(DEPENDENCY_TYPE).includes(dt))) {
+		throw new Error(`Invalid depType provided. Choices are: ${Object.keys(DEPENDENCY_TYPE).join(", ")}.`);
+	}
+	const optionsWithDefaults = {
+		fix: false,
+		ignoreDep: [],
+		includeDepPattern: [],
+		ignorePackage: [],
+		ignorePackagePattern: [],
+		ignorePath: [],
+		ignorePathPattern: [],
+		...options,
+		depType: options && options.depType && options.depType.length > 0 ? options.depType : DEFAULT_DEP_TYPES
+	};
+	const packages = getPackages(path, optionsWithDefaults.ignorePackage, optionsWithDefaults.ignorePackagePattern.map((s) => new RegExp(s)), optionsWithDefaults.ignorePath, optionsWithDefaults.ignorePathPattern.map((s) => new RegExp(s)));
+	const dependencies = calculateVersionsForEachDependency(packages, optionsWithDefaults.depType.map((dt) => DEPENDENCY_TYPE[dt]));
+	const dependenciesAndVersions = calculateDependenciesAndVersions(dependencies);
+	const dependenciesAndVersionsWithMismatches = dependenciesAndVersions.filter(({ versions }) => versions.length > 1);
+	const dependenciesAndVersionsWithoutIgnored = filterOutIgnoredDependencies(dependenciesAndVersions, optionsWithDefaults.ignoreDep, optionsWithDefaults.includeDepPattern.map((s) => new RegExp(s)));
+	const dependenciesAndVersionsMismatchesWithoutIgnored = filterOutIgnoredDependencies(dependenciesAndVersionsWithMismatches, optionsWithDefaults.ignoreDep, optionsWithDefaults.includeDepPattern.map((s) => new RegExp(s)));
+	return { dependencies: Object.fromEntries(dependenciesAndVersionsWithoutIgnored.map(({ dependency, versions }) => {
+		return [dependency, {
+			isMismatching: dependenciesAndVersionsMismatchesWithoutIgnored.some((dep) => dep.dependency === dependency),
+			versions
+		}];
+	})) };
+}
+var CDVC = class {
+	/** An object mapping each dependency in the workspace to information including the versions found of it. */
+	dependencies;
+	/**
+	* @param path - path to the workspace root
+	* @param options
+	* @param options.fix - Whether to autofix inconsistencies (using latest version present)
+	* @param options.ignoreDep - Dependency(s) to ignore mismatches for
+	* @param options.includeDepPattern - RegExp(s) of dependency names to ignore mismatches for
+	* @param options.ignorePackage - Workspace package(s) to ignore mismatches for
+	* @param options.ignorePackagePattern - RegExp(s) of package names to ignore mismatches for
+	* @param options.ignorePath - Workspace-relative path(s) of packages to ignore mismatches for
+	* @param options.ignorePathPattern - RegExp(s) of workspace-relative path of packages to ignore mismatches for
+	*/
+	constructor(path) {
+		const { dependencies } = check(path);
+		this.dependencies = dependencies;
+	}
+	toMismatchSummary() {
+		return dependenciesToMismatchSummary(this.dependencies);
+	}
+	getDependencies() {
+		return Object.keys(this.dependencies).map((dependency) => this.getDependency(dependency));
+	}
+	getDependency(name) {
+		return {
+			name,
+			isMismatching: this.dependencies[name].isMismatching,
+			versions: this.dependencies[name].versions.map((version) => ({
+				version: version.version,
+				packages: version.packages.map((package_) => ({ pathRelative: package_.pathRelative }))
+			}))
+		};
+	}
+	get hasMismatchingDependencies() {
+		return Object.values(this.dependencies).some((dep) => dep.isMismatching);
+	}
+};
+function dependenciesToMismatchSummary(dependencies) {
+	const mismatchingDependencyVersions = Object.entries(dependencies).filter(([, value]) => value.isMismatching).map(([dependency, value]) => ({
+		dependency,
+		versions: value.versions
+	}));
+	if (mismatchingDependencyVersions.length === 0) {
+		return "";
+	}
+	const tables = mismatchingDependencyVersions.map((object) => {
+		return `${object.dependency} - ${object.versions.map((v) => `${v.version}`).join(", ")}`;
+	}).join("");
+	return [`Found ${mismatchingDependencyVersions.length} ${mismatchingDependencyVersions.length === 1 ? "dependency" : "dependencies"} with mismatching versions across the workspace.`, tables].join("\n");
+}

package/dist/cjs/checkDeps.cjs

@@ -0,0 +1,301 @@
+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 checkDeps_exports = {};
+__export(checkDeps_exports, {
+	DEPENDENCY_TYPE: () => DEPENDENCY_TYPE,
+	checkDeps: () => checkDeps
+});
+module.exports = __toCommonJS(checkDeps_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_check_dep_versions = require("./check-dep-versions.cjs");
+var DEPENDENCY_TYPE = /* @__PURE__ */ ((DEPENDENCY_TYPE2) => {
+	DEPENDENCY_TYPE2["dependencies"] = "dependencies";
+	DEPENDENCY_TYPE2["devDependencies"] = "devDependencies";
+	DEPENDENCY_TYPE2["optionalDependencies"] = "optionalDependencies";
+	DEPENDENCY_TYPE2["peerDependencies"] = "peerDependencies";
+	DEPENDENCY_TYPE2["resolutions"] = "resolutions";
+	return DEPENDENCY_TYPE2;
+})(DEPENDENCY_TYPE || {});
+const CRITICAL_PACKAGES = [
+	"@tamagui/web",
+	"@tamagui/core",
+	"tamagui"
+];
+function checkDuplicateInstalls(root) {
+	const nodeModules = (0, import_node_path.join)(root, "node_modules");
+	if (!(0, import_node_fs.existsSync)(nodeModules)) return "";
+	const duplicates = /* @__PURE__ */ new Map();
+	for (const pkg of CRITICAL_PACKAGES) {
+		const locations = findAllInstances(nodeModules, pkg);
+		if (locations.length > 1) {
+			const realPaths = /* @__PURE__ */ new Set();
+			const distinctLocations = [];
+			for (const loc of locations) {
+				try {
+					const real = (0, import_node_fs.realpathSync)(loc);
+					if (!realPaths.has(real)) {
+						realPaths.add(real);
+						distinctLocations.push((0, import_node_path.relative)(root, loc));
+					}
+				} catch {
+					distinctLocations.push((0, import_node_path.relative)(root, loc));
+				}
+			}
+			if (distinctLocations.length > 1) {
+				duplicates.set(pkg, distinctLocations);
+			}
+		}
+	}
+	if (duplicates.size === 0) return "";
+	const lines = [
+		"Found duplicate tamagui installations in node_modules:",
+		"",
+		"This causes multiple runtime instances, which breaks theme/config detection.",
+		""
+	];
+	for (const [pkg, locations] of duplicates) {
+		lines.push(`  ${pkg}:`);
+		for (const loc of locations) {
+			const pkgJsonPath = (0, import_node_path.join)(root, loc, "package.json");
+			let version = "?";
+			try {
+				version = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf8")).version;
+			} catch {}
+			lines.push(`    ${version} at ${loc}`);
+		}
+		lines.push("");
+	}
+	lines.push("Fix: run your package manager's dedupe command:");
+	lines.push("  bun install  (bun auto-dedupes)");
+	lines.push("  npx yarn-deduplicate && yarn install");
+	lines.push("  npm dedupe");
+	lines.push("");
+	lines.push("If that doesn't help, delete node_modules and lockfile, then reinstall.");
+	return lines.join("\n");
+}
+function findAllInstances(nodeModulesDir, packageName, found = [], depth = 0) {
+	if (depth > 4 || !(0, import_node_fs.existsSync)(nodeModulesDir)) return found;
+	const pkgDir = (0, import_node_path.join)(nodeModulesDir, ...packageName.split("/"));
+	if ((0, import_node_fs.existsSync)((0, import_node_path.join)(pkgDir, "package.json"))) {
+		found.push(pkgDir);
+	}
+	try {
+		const entries = (0, import_node_fs.readdirSync)(nodeModulesDir);
+		for (const entry of entries) {
+			if (entry.startsWith(".")) continue;
+			if (entry.startsWith("@")) {
+				const scopeDir = (0, import_node_path.join)(nodeModulesDir, entry);
+				try {
+					const scopeEntries = (0, import_node_fs.readdirSync)(scopeDir);
+					for (const scopeEntry of scopeEntries) {
+						const nested = (0, import_node_path.join)(scopeDir, scopeEntry, "node_modules");
+						if ((0, import_node_fs.existsSync)(nested)) {
+							findAllInstances(nested, packageName, found, depth + 1);
+						}
+					}
+				} catch {}
+			} else {
+				const nested = (0, import_node_path.join)(nodeModulesDir, entry, "node_modules");
+				if ((0, import_node_fs.existsSync)(nested)) {
+					findAllInstances(nested, packageName, found, depth + 1);
+				}
+			}
+		}
+	} catch {}
+	return found;
+}
+function checkLockfileDuplicates(root) {
+	const bunLock = (0, import_node_path.join)(root, "bun.lock");
+	const yarnLock = (0, import_node_path.join)(root, "yarn.lock");
+	const npmLock = (0, import_node_path.join)(root, "package-lock.json");
+	if ((0, import_node_fs.existsSync)(bunLock)) return checkBunLockDuplicates(bunLock);
+	if ((0, import_node_fs.existsSync)(yarnLock)) return checkYarnLockDuplicates(yarnLock);
+	if ((0, import_node_fs.existsSync)(npmLock)) return checkNpmLockDuplicates(npmLock);
+	return "";
+}
+function checkBunLockDuplicates(lockPath) {
+	try {
+		const content = (0, import_node_fs.readFileSync)(lockPath, "utf8");
+		const duplicates = /* @__PURE__ */ new Map();
+		const criticalSet = new Set(CRITICAL_PACKAGES);
+		const packagePattern = /["'](@tamagui\/[\w-]+|tamagui)@([^"'\s,]+)["']/g;
+		let match;
+		while ((match = packagePattern.exec(content)) !== null) {
+			const name = match[1];
+			const version = match[2];
+			if (version.startsWith("workspace:")) continue;
+			if (!criticalSet.has(name)) continue;
+			if (!duplicates.has(name)) duplicates.set(name, /* @__PURE__ */ new Set());
+			duplicates.get(name).add(version);
+		}
+		return formatLockfileDuplicates(duplicates, "bun.lock");
+	} catch {
+		return "";
+	}
+}
+function checkYarnLockDuplicates(lockPath) {
+	try {
+		const content = (0, import_node_fs.readFileSync)(lockPath, "utf8");
+		const duplicates = /* @__PURE__ */ new Map();
+		const criticalSet = new Set(CRITICAL_PACKAGES);
+		const entryPattern = /^"?(@tamagui\/[\w-]+|tamagui)@[^":\n]+[":]?\s*$/gm;
+		const versionPattern = /^\s+version\s+"([^"]+)"/gm;
+		let entryMatch;
+		while ((entryMatch = entryPattern.exec(content)) !== null) {
+			const name = entryMatch[1];
+			if (!criticalSet.has(name)) continue;
+			versionPattern.lastIndex = entryMatch.index;
+			const verMatch = versionPattern.exec(content);
+			if (verMatch) {
+				if (!duplicates.has(name)) duplicates.set(name, /* @__PURE__ */ new Set());
+				duplicates.get(name).add(verMatch[1]);
+			}
+		}
+		return formatLockfileDuplicates(duplicates, "yarn.lock");
+	} catch {
+		return "";
+	}
+}
+function checkNpmLockDuplicates(lockPath) {
+	try {
+		const lock = JSON.parse((0, import_node_fs.readFileSync)(lockPath, "utf8"));
+		const duplicates = /* @__PURE__ */ new Map();
+		const criticalSet = new Set(CRITICAL_PACKAGES);
+		const packages = lock.packages || {};
+		for (const [path, info] of Object.entries(packages)) {
+			if (!path) continue;
+			const name = info.name || path.split("node_modules/").pop();
+			if (!name) continue;
+			if (!criticalSet.has(name)) continue;
+			const version = info.version;
+			if (version) {
+				if (!duplicates.has(name)) duplicates.set(name, /* @__PURE__ */ new Set());
+				duplicates.get(name).add(version);
+			}
+		}
+		return formatLockfileDuplicates(duplicates, "package-lock.json");
+	} catch {
+		return "";
+	}
+}
+function formatLockfileDuplicates(duplicates, lockfileName) {
+	const multiVersion = /* @__PURE__ */ new Map();
+	for (const [name, versions] of duplicates) {
+		if (versions.size > 1) {
+			multiVersion.set(name, [...versions].sort());
+		}
+	}
+	if (multiVersion.size === 0) return "";
+	const lines = [`Found multiple resolved versions in ${lockfileName}:`, ""];
+	for (const [name, versions] of multiVersion) {
+		lines.push(`  ${name}: ${versions.join(", ")}`);
+	}
+	lines.push("");
+	lines.push("Multiple versions cause duplicate runtime instances, breaking config/theme detection.");
+	lines.push("Fix: ensure all tamagui packages use the same version range, then dedupe.");
+	return lines.join("\n");
+}
+function checkConfigExists(root) {
+	const configNames = [
+		"tamagui.config.ts",
+		"tamagui.config.tsx",
+		"tamagui.config.js",
+		"tamagui.config.mjs",
+		"tamagui.config.cjs"
+	];
+	const searchDirs = [
+		root,
+		(0, import_node_path.join)(root, "src"),
+		(0, import_node_path.join)(root, "app"),
+		(0, import_node_path.join)(root, "config")
+	];
+	for (const dir of searchDirs) {
+		for (const name of configNames) {
+			if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, name))) {
+				return "";
+			}
+		}
+	}
+	const buildConfigNames = [
+		"tamagui.build.ts",
+		"tamagui.build.js",
+		"tamagui.build.mjs",
+		"tamagui.build.cjs"
+	];
+	for (const name of buildConfigNames) {
+		const buildPath = (0, import_node_path.join)(root, name);
+		if ((0, import_node_fs.existsSync)(buildPath)) {
+			try {
+				const content = (0, import_node_fs.readFileSync)(buildPath, "utf8");
+				const match = content.match(/config\s*:\s*['"`]([^'"`]+)['"`]/);
+				if (match) {
+					const configPath = (0, import_node_path.join)(root, match[1]);
+					if ((0, import_node_fs.existsSync)(configPath)) return "";
+				}
+			} catch {}
+		}
+	}
+	const pkgJsonPath = (0, import_node_path.join)(root, "package.json");
+	if ((0, import_node_fs.existsSync)(pkgJsonPath)) {
+		try {
+			const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf8"));
+			if (pkg.tamagui?.config) {
+				const configPath = (0, import_node_path.join)(root, pkg.tamagui.config);
+				if ((0, import_node_fs.existsSync)(configPath)) return "";
+			}
+		} catch {}
+	}
+	if ((0, import_node_fs.existsSync)(pkgJsonPath)) {
+		try {
+			const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf8"));
+			if (pkg.workspaces) return "";
+		} catch {}
+	}
+	return [
+		"No tamagui.config file found.",
+		"",
+		"Tamagui requires a config file (e.g. tamagui.config.ts) that calls createTamagui().",
+		`Without it, components will throw "Can't find Tamagui configuration" at runtime.`,
+		"",
+		"See: https://tamagui.dev/docs/core/configuration"
+	].join("\n");
+}
+async function checkDeps(root) {
+	const issues = [];
+	const workspaceMismatchSummary = new import_check_dep_versions.CDVC(root).toMismatchSummary();
+	if (workspaceMismatchSummary) issues.push(workspaceMismatchSummary);
+	const lockfileSummary = checkLockfileDuplicates(root);
+	if (lockfileSummary) issues.push(lockfileSummary);
+	const duplicatesSummary = checkDuplicateInstalls(root);
+	if (duplicatesSummary) issues.push(duplicatesSummary);
+	const configSummary = checkConfigExists(root);
+	if (configSummary) issues.push(configSummary);
+	if (issues.length === 0) {
+		console.info(`Tamagui dependencies look good \u2705`);
+		return;
+	}
+	for (let i = 0; i < issues.length; i++) {
+		if (i > 0) console.error("");
+		console.error(issues[i]);
+	}
+	process.exitCode = 1;
+}