stim 1.19.0 → 1.20.0

package/dist/react-native-build-oAw6gQeW.mjs

@@ -0,0 +1,239 @@
+import { r as register } from "./cache-manifest-qA3dT2x2.mjs";
+import { g as sharedCompilationCache } from "./workspace-state-CSIFuuDa.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { S as resolvePackageJson } from "./project-B8_duAzW.mjs";
+import { p as resolveOptimizations } from "./errors-DzkMYh8Q.mjs";
+import { a as buildGradle, i as assembleTaskFor, n as BUILD_ERROR, o as parseProductFlavors, s as variantNameOf, t as ASSEMBLE_TASK } from "./gradle-C2OEKCCI.mjs";
+import { C as compilationCacheSettings, N as swiftPrefixMappingSupported, O as pickXcodeProject, T as detectXcodeMajor, b as SWIFT_PREFIX_MAPPING_MIN_SWIFT, w as detectSwiftVersion, x as buildXcode } from "./toolchain-DqyDXs30.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import chalk from "chalk";
+/** The ABI name a build for every ABI has to fit; `stim android` narrows a build to the device's. */
+const LONGEST_ANDROID_ABI = "armeabi-v7a";
+function androidPathRoom(root, { abi = null, variant = null, platform = process.platform } = {}) {
+	if (platform !== "win32") return null;
+	const abiName = abi ?? LONGEST_ANDROID_ABI;
+	const tail = 198 + (/release$/i.test(variant ?? "") ? 14 : 5) - 5 + abiName.length;
+	const longest = root.length + tail;
+	if (longest < 240) return null;
+	return {
+		root,
+		abi: abiName,
+		longest,
+		maxRootLength: 239 - tail
+	};
+}
+function androidPathRoomMessage({ root, abi, longest, maxRootLength }) {
+	return `The project root ${root} is ${root.length} characters, so the longest known Android native object path (react_codegen_safeareacontext for ${abi}) reaches ${longest} characters, past the 239 the NDK's ninja can be given on Windows; the root can be at most ${maxRootLength} characters.`;
+}
+function androidPathRoomRemedy({ root }) {
+	return `Map the project to a drive letter (\`subst X: "${root}"\`) and run Stim from X:\\, or move it under a shorter root.`;
+}
+//#endregion
+//#region src/integrations/react-native-build.ts
+function gradlewPath(layout) {
+	return join(layout.gradleRoot, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+}
+function apkOutputsDir(layout) {
+	return join(layout.moduleDir, "build", "outputs", "apk");
+}
+function discoverAndroidProject(root, layout) {
+	const dir = layout.gradleRoot;
+	if (!existsSync(dir)) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `No ${relative(root, dir) || "."}/ directory in ${root}.`,
+		remedy: "Generate it (`npx expo prebuild -p android`, which `stim android` runs itself on an Expo project) or check out the native sources."
+	};
+	const gradlew = gradlewPath(layout);
+	if (!existsSync(gradlew)) return {
+		failed: true,
+		code: BUILD_ERROR,
+		reason: `${gradlew} does not exist, so there is no gradle wrapper to build with.`,
+		remedy: `Restore the wrapper (\`gradle wrapper\` in ${relative(root, dir) || "."}/, or regenerate the project with \`npx expo prebuild -p android --clean\`).`
+	};
+	return {
+		androidDir: dir,
+		gradlew
+	};
+}
+function readProductFlavors(layout) {
+	return parseProductFlavors(readOrNull(join(layout.moduleDir, "build.gradle")));
+}
+function productFlavorRefusal({ flavors, variant }) {
+	if (variant) return null;
+	if (!flavors.known || flavors.dimensions.length === 0) return null;
+	let combinations = [[]];
+	for (const group of flavors.dimensions) combinations = combinations.flatMap((combination) => group.map((flavor) => combination.concat(flavor)));
+	if (combinations.length < 2) return null;
+	const count = flavors.dimensions.reduce((total, group) => total + group.length, 0);
+	const variants = combinations.map((combination) => variantNameOf(combination.concat("debug")));
+	return {
+		code: "STIM_BAD_ARG",
+		reason: `android/app/build.gradle declares ${count} product flavors, so \`./gradlew ${ASSEMBLE_TASK}\` builds an APK for each of them and nothing says which flavor to install.`,
+		remedy: `Pass \`--variant ${variants[0]}\` or set the android.variant setting -- e.g. {"android": {"variant": "${variants[0]}"}} in .stim.json. The debug variants are: ${variants.join(", ")}.`
+	};
+}
+function readOrNull(path) {
+	try {
+		return readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function buildAndroid({ root, layout, logWriter, variant = null, abi = null }, options = {}) {
+	const project = discoverAndroidProject(root, layout);
+	if (project.failed) return {
+		ok: false,
+		code: project.code,
+		reason: project.reason,
+		remedy: project.remedy,
+		diagnostics: [],
+		truncated: 0,
+		lastLines: [],
+		durationMs: 0
+	};
+	const room = androidPathRoom(root, {
+		abi,
+		variant,
+		platform: options.platform ?? process.platform
+	});
+	return buildGradle({
+		root,
+		logWriter,
+		variant,
+		project: {
+			directory: project.androidDir,
+			gradlew: project.gradlew,
+			module: layout.module,
+			outputsDir: apkOutputsDir(layout)
+		},
+		task: layout.custom ? `${layout.module}:${assembleTaskFor(variant)}` : assembleTaskFor(variant),
+		projectArgs: abi ? [`-PreactNativeArchitectures=${abi}`] : [],
+		preflightFailure: room ? {
+			code: "STIM_PATH_TOO_LONG",
+			reason: androidPathRoomMessage(room),
+			remedy: androidPathRoomRemedy(room)
+		} : null
+	}, options);
+}
+const PREBUILD_REMEDY = "Generate it with `npx expo prebuild -p ios` (stim ios does this automatically for an Expo project with no ios/ directory), or commit the native project.";
+function buildFailure(message, remedy) {
+	return { error: {
+		code: "STIM_BUILD_FAILED",
+		message,
+		remedy
+	} };
+}
+function discoverXcodeProject(root, dir) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return buildFailure(`No ${relative(root, dir) || "."}/ directory in ${root}.`, PREBUILD_REMEDY);
+	}
+	const picked = pickXcodeProject(entries);
+	if (!picked) return buildFailure(`${dir} contains no .xcworkspace and no .xcodeproj.`, PREBUILD_REMEDY);
+	return {
+		...picked,
+		dir,
+		appRoot: root,
+		path: join(dir, picked.file)
+	};
+}
+function ccacheEnabled(podfileProperties) {
+	if (!podfileProperties || typeof podfileProperties !== "object") return false;
+	return podfileProperties["apple.ccacheEnabled"] === "true";
+}
+function readPodfileProperties(iosDir) {
+	try {
+		const parsed = JSON.parse(readFileSync(join(iosDir, "Podfile.properties.json"), "utf-8"));
+		return parsed && typeof parsed === "object" ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+const SWIFT_CACHE_MIN_REACT_NATIVE = {
+	major: 0,
+	minor: 87
+};
+function reactNativeSupportsSwiftCache(version) {
+	if (!version) return false;
+	const min = SWIFT_CACHE_MIN_REACT_NATIVE;
+	return version.major > min.major || version.major === min.major && version.minor >= min.minor;
+}
+function parseReactNativeVersion(packageJson) {
+	if (!packageJson || typeof packageJson !== "object") return null;
+	const raw = packageJson.version;
+	const m = typeof raw === "string" ? /^(\d+)\.(\d+)\./.exec(raw) : null;
+	if (!m || m[1] === void 0 || m[2] === void 0) return null;
+	return {
+		major: parseInt(m[1], 10),
+		minor: parseInt(m[2], 10)
+	};
+}
+function detectReactNativeVersion(root) {
+	const file = resolvePackageJson(root, "react-native");
+	if (!file) return null;
+	try {
+		return parseReactNativeVersion(JSON.parse(readFileSync(file, "utf-8")));
+	} catch {
+		return null;
+	}
+}
+function reactNativeCompilationCacheSettings({ reactNativeVersion = null, ...options }) {
+	return compilationCacheSettings({
+		...options,
+		swiftCacheCompatible: reactNativeSupportsSwiftCache(reactNativeVersion)
+	});
+}
+function resolveCompilationCacheSettings({ root, iosDir, derivedDataPath, exec = null, casPath = sharedCompilationCache(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
+	const xcodeMajor = detectXcodeMajor(exec);
+	const ccache = ccacheEnabled(readPodfileProperties(iosDir));
+	const probe = xcodeMajor !== null && xcodeMajor >= 26 && !ccache && optimizations.compilationCache && optimizations.swiftCompilationCache !== false;
+	const swiftVersion = probe ? detectSwiftVersion(exec) : null;
+	const reactNativeVersion = probe ? detectReactNativeVersion(root) : null;
+	const settings = reactNativeCompilationCacheSettings({
+		workspaceRoot: root,
+		derivedDataPath,
+		casPath,
+		xcodeMajor,
+		swiftVersion,
+		reactNativeVersion,
+		ccache,
+		optimizations
+	});
+	if (settings.length > 0 && optimizations.compilationCache) {
+		register({
+			dir: casPath,
+			name: "Xcode compilation cache",
+			prune: "atomic",
+			note: "shared Xcode compilation cache"
+		});
+		const swift = settings.includes("SWIFT_ENABLE_COMPILE_CACHE=YES") ? settings.includes("SWIFT_ENABLE_PREFIX_MAPPING=YES") ? "Swift on" : "Swift on, unmapped" : swiftVersion && !swiftPrefixMappingSupported(swiftVersion) ? `Swift off, ${swiftVersion.major}.${swiftVersion.minor} < ${SWIFT_PREFIX_MAPPING_MIN_SWIFT.major}.${SWIFT_PREFIX_MAPPING_MIN_SWIFT.minor}` : swiftVersion && reactNativeVersion && !reactNativeSupportsSwiftCache(reactNativeVersion) ? `Swift off, react-native ${reactNativeVersion.major}.${reactNativeVersion.minor} < ${SWIFT_CACHE_MIN_REACT_NATIVE.major}.${SWIFT_CACHE_MIN_REACT_NATIVE.minor}` : "Swift off";
+		onNote(chalk.dim(phaseLine("cache", `compilation cache on (CAS at ${casPath}, ${swift})`)));
+	}
+	return settings;
+}
+async function buildIos(inputs) {
+	const { root, iosDir, logWriter, udid, destination, now = () => Date.now() } = inputs;
+	if (!root || typeof root !== "string") throw new TypeError("buildIos requires {root}");
+	if (!logWriter || typeof logWriter.write !== "function") throw new TypeError("buildIos requires {logWriter} with a write() method");
+	if (!udid && !destination) throw new TypeError("buildIos requires {udid} (or an explicit {destination})");
+	const startedAt = now();
+	return buildXcode({
+		...inputs,
+		startedAt,
+		project: inputs.project ?? discoverXcodeProject(root, iosDir),
+		compilationCache: inputs.compilationCache === void 0 ? ({ derivedDataPath, exec }) => resolveCompilationCacheSettings({
+			root,
+			iosDir,
+			derivedDataPath,
+			exec,
+			optimizations: inputs.optimizations,
+			onNote: inputs.onNote
+		}) : inputs.compilationCache
+	});
+}
+//#endregion
+export { discoverXcodeProject as a, readProductFlavors as c, androidPathRoomRemedy as d, ccacheEnabled as i, androidPathRoom as l, buildAndroid as n, gradlewPath as o, buildIos as r, productFlavorRefusal as s, apkOutputsDir as t, androidPathRoomMessage as u };

package/dist/react-native-doctor-DYXoh-6I.mjs

@@ -0,0 +1,78 @@
+import { G as resolveIosProjectDir, U as resolveAndroidLayout } from "./settings-Bbztm4oV.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { _ as detectIsExpo } from "./project-B8_duAzW.mjs";
+import { I as bundlerPin, i as iosToolchainAsync, n as androidToolchain, t as androidRequirements } from "./toolchain-DqyDXs30.mjs";
+import { a as repairCxxLauncherState, n as detectLinkedLibraryGitMetadata, r as reactNativeDoctorFindings, t as detectFingerprintParity } from "./doctor-DPAqhVCK.mjs";
+import { existsSync } from "node:fs";
+//#region src/integrations/react-native-doctor.ts
+function reactNativeProjectDoctor(root) {
+	return {
+		inspect: reactNativeDoctorFindings,
+		async inspectAsync({ options: { platform }, settings }) {
+			const parity = await detectFingerprintParity(root, {
+				platform,
+				iosProjectPath: resolveIosProjectDir(settings, root).relative
+			});
+			const linkedGit = await detectLinkedLibraryGitMetadata(root, { platform });
+			return [parity, linkedGit?.code === parity?.code ? null : linkedGit].filter((finding) => finding !== null);
+		},
+		offloadTargets({ options: { platform, host = process.platform }, settings, repoRoot }, iosRuntime) {
+			const checksIos = platform !== "android" && host === "darwin";
+			const androidDir = resolveAndroidLayout(settings, root, repoRoot ?? root).gradleRoot;
+			const checksAndroid = platform === "android" || platform === void 0 && (existsSync(androidDir) || detectIsExpo(root));
+			if (!checksIos && !checksAndroid) return null;
+			return async () => {
+				const targets = [];
+				if (checksIos) {
+					const [local, runtime] = await Promise.all([iosToolchainAsync(root), iosRuntime()]);
+					targets.push({
+						platform: "ios",
+						local,
+						runtime,
+						cocoapodsPinned: bundlerPin(root) !== null
+					});
+				}
+				if (checksAndroid) targets.push({
+					platform: "android",
+					local: androidToolchain(),
+					requires: androidRequirements(root)
+				});
+				return targets;
+			};
+		},
+		repair: (platform, settings, repoRoot) => platform === "ios" ? {
+			removed: [],
+			refused: []
+		} : repairCxxLauncherState(root, settings, resolveAndroidLayout(settings, root, repoRoot ?? root)),
+		successLines: reactNativeDoctorSuccessLines
+	};
+}
+function reactNativeDoctorSuccessLines(platform) {
+	const lines = [
+		"",
+		"Project",
+		phaseLine("project", "source checkout, dependencies, local upstream, nested worktrees Watchman would crawl")
+	];
+	if (platform !== "android") {
+		lines.push("", "iOS");
+		lines.push(phaseLine("setup", "CocoaPods, warm state, effective Debug simulator architectures"));
+		lines.push(phaseLine("caches", "Metro, Xcode compilation, ccache, build provider"));
+		lines.push(phaseLine("devices", "remote device, SimSlim profile"));
+	}
+	if (platform !== "ios") {
+		lines.push("", "Android");
+		lines.push(phaseLine("setup", "Android SDK, warm state"));
+		lines.push(phaseLine("caches", "Metro, Gradle, ccache, build provider"));
+		lines.push(phaseLine("devices", "remote device"));
+	}
+	lines.push("", "Expo and React Native");
+	lines.push(phaseLine("services", "EAS session"));
+	lines.push(phaseLine("fingerprint", "parity when dependencies are absent"));
+	lines.push("", "Handled automatically");
+	const suppliedCaches = platform === "ios" ? "Metro transform store, Xcode compilation cache" : platform === "android" ? "Metro transform store, Gradle build cache, ccache" : "Metro transform store, Xcode compilation cache, Gradle build cache, ccache";
+	lines.push(phaseLine("caches", suppliedCaches));
+	lines.push(phaseLine("meaning", "missing project cache settings are healthy"));
+	return lines;
+}
+//#endregion
+export { reactNativeProjectDoctor };