stim 0.0.0 → 1.0.0

package/dist/ndjson-DcAtEx_K.mjs

@@ -0,0 +1,131 @@
+import { closeSync, mkdirSync, openSync, writeSync } from "fs";
+import { dirname } from "path";
+//#region src/ndjson.ts
+const LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal"
+];
+const SOURCES = [
+	"metro",
+	"client",
+	"device",
+	"build"
+];
+function levelRank(level) {
+	const i = LEVELS.indexOf(level);
+	return i < 0 ? 0 : i;
+}
+function parseNdjsonLine(line) {
+	if (typeof line !== "string") return null;
+	const trimmed = line.trim();
+	if (!trimmed) return null;
+	let value;
+	try {
+		value = JSON.parse(trimmed);
+	} catch {
+		return null;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function parseNdjsonText(text) {
+	if (typeof text !== "string" || text === "") return [];
+	const out = [];
+	const lines = text.split("\n");
+	lines.pop();
+	for (const line of lines) {
+		const record = parseNdjsonLine(line);
+		if (record) out.push(record);
+	}
+	return out;
+}
+function formatNdjsonLine(record) {
+	try {
+		return `${JSON.stringify(record)}\n`;
+	} catch {
+		return null;
+	}
+}
+function createNdjsonWriter(file, { truncate = false } = {}) {
+	let fd = null;
+	let freshFile = truncate;
+	let written = 0;
+	let dropped = 0;
+	let lastError = null;
+	let closed = false;
+	function open() {
+		mkdirSync(dirname(file), { recursive: true });
+		fd = openSync(file, freshFile ? "w" : "a");
+		freshFile = false;
+	}
+	function write(record) {
+		if (closed) {
+			dropped += 1;
+			return false;
+		}
+		const line = formatNdjsonLine(stamp(record));
+		if (line === null) {
+			dropped += 1;
+			lastError = /* @__PURE__ */ new TypeError("record could not be serialized to JSON");
+			return false;
+		}
+		try {
+			if (fd === null) open();
+			writeSync(fd, line);
+			written += 1;
+			return true;
+		} catch (err) {
+			if (fd !== null) {
+				try {
+					closeSync(fd);
+				} catch {}
+				fd = null;
+			}
+			dropped += 1;
+			lastError = err;
+			return false;
+		}
+	}
+	function close() {
+		if (fd !== null) {
+			try {
+				closeSync(fd);
+			} catch {}
+			fd = null;
+		}
+		closed = true;
+		return {
+			file,
+			written,
+			dropped,
+			lastError
+		};
+	}
+	return {
+		file,
+		write,
+		close,
+		get written() {
+			return written;
+		},
+		get dropped() {
+			return dropped;
+		},
+		get lastError() {
+			return lastError;
+		}
+	};
+}
+function stamp(record) {
+	const base = record && typeof record === "object" && !Array.isArray(record) ? record : { msg: String(record) };
+	if (typeof base.ts === "number" && Number.isFinite(base.ts)) return base;
+	return {
+		...base,
+		ts: Date.now()
+	};
+}
+//#endregion
+export { parseNdjsonLine as a, levelRank as i, SOURCES as n, parseNdjsonText as o, createNdjsonWriter as r, LEVELS as t };

package/dist/ndjson-DvHSsNU9.d.mts

@@ -0,0 +1,16 @@
+//#region src/ndjson.d.ts
+interface NdjsonWriter {
+  readonly file: string;
+  write(record: unknown): boolean;
+  close(): {
+    file: string;
+    written: number;
+    dropped: number;
+    lastError: Error | null;
+  };
+  readonly written: number;
+  readonly dropped: number;
+  readonly lastError: Error | null;
+}
+//#endregion
+export { NdjsonWriter as t };

package/dist/process-output-C7IlIzd7.mjs

@@ -0,0 +1,40 @@
+import { stripVTControlCharacters } from "node:util";
+//#region src/process-output.ts
+function stripAnsi(text) {
+	return stripVTControlCharacters(String(text ?? ""));
+}
+function createLineReader(onLine) {
+	let buffered = "";
+	return {
+		push(chunk) {
+			buffered += String(chunk);
+			const parts = buffered.split("\n");
+			buffered = parts.pop() ?? "";
+			for (const part of parts) onLine(part);
+		},
+		flush() {
+			if (!buffered) return;
+			const rest = buffered;
+			buffered = "";
+			onLine(rest);
+		}
+	};
+}
+function waitForChild(child) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const done = (value) => {
+			if (!settled) {
+				settled = true;
+				resolve(value);
+			}
+		};
+		child.on("exit", (code, signal) => done({
+			code,
+			signal
+		}));
+		child.on("error", (error) => done({ error }));
+	});
+}
+//#endregion
+export { stripAnsi as n, waitForChild as r, createLineReader as t };

package/dist/project-Dit1CckW.mjs

@@ -0,0 +1,234 @@
+import { s as findEnclosingWorktreeRoot, u as getProject } from "./config-7kmtuhO2.mjs";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+//#region src/project.ts
+const requireFromHere = createRequire(import.meta.url);
+function resolvePackageJson(projectRoot, name) {
+	try {
+		return requireFromHere.resolve(`${name}/package.json`, { paths: [projectRoot] });
+	} catch {
+		try {
+			const main = requireFromHere.resolve(name, { paths: [projectRoot] });
+			const marker = `/node_modules/${name}/`;
+			const at = main.lastIndexOf(marker);
+			if (at === -1) return null;
+			const candidate = join(main.slice(0, at + marker.length), "package.json");
+			return existsSync(candidate) ? candidate : null;
+		} catch {
+			return null;
+		}
+	}
+}
+function isPackageResolvable(projectRoot, name) {
+	return resolvePackageJson(projectRoot, name) !== null;
+}
+function projectShortcut(path, proj) {
+	if (proj?.label) return proj.label;
+	const rootPath = findEnclosingWorktreeRoot(path);
+	if (rootPath && rootPath !== path) return `${projectShortcut(rootPath, getProject(rootPath))}/${path.split("/").pop() || path}`;
+	return path.split("/").pop() || path;
+}
+function findProjectRoot(startDir) {
+	let dir;
+	try {
+		dir = realpathSync(resolve(startDir));
+	} catch {
+		dir = resolve(startDir);
+	}
+	while (true) {
+		if (existsSync(join(dir, "package.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+function loadPackageJson(projectRoot) {
+	const p = join(projectRoot, "package.json");
+	if (!existsSync(p)) return {
+		pkg: null,
+		parseError: null
+	};
+	try {
+		return {
+			pkg: JSON.parse(readFileSync(p, "utf-8")),
+			parseError: null
+		};
+	} catch (error) {
+		return {
+			pkg: null,
+			parseError: error?.message || String(error)
+		};
+	}
+}
+function readPackageJson(projectRoot) {
+	return loadPackageJson(projectRoot).pkg;
+}
+const APP_DEPENDENCIES = ["react-native", "expo"];
+function declaresAppDependency(pkg) {
+	if (!pkg || typeof pkg !== "object") return false;
+	const { dependencies, devDependencies } = pkg;
+	const deps = {
+		...dependencies,
+		...devDependencies
+	};
+	return APP_DEPENDENCIES.some((name) => name in deps);
+}
+function appProjectProblem(projectRoot) {
+	const file = join(projectRoot, "package.json");
+	const { pkg, parseError } = loadPackageJson(projectRoot);
+	if (parseError) return {
+		kind: "unreadable",
+		message: `${file} is not valid JSON (${parseError}), so Stim cannot tell whether this is a React Native or Expo app.`,
+		remedy: `Fix the JSON in ${file} -- an unfinished edit or a merge conflict leaves it unparseable -- then run the command again.`
+	};
+	if (declaresAppDependency(pkg)) return null;
+	return {
+		kind: "not-an-app",
+		message: `${file} depends on neither react-native nor expo, so this is not a React Native or Expo app.`,
+		remedy: "Run this from the app directory -- the one whose package.json depends on react-native or expo -- or from that directory inside a worktree."
+	};
+}
+function detectIsExpo(projectRoot) {
+	const pkg = readPackageJson(projectRoot);
+	const iosScript = pkg?.scripts?.ios;
+	if (typeof iosScript === "string") {
+		if (/\bexpo\s+run:ios\b/.test(iosScript)) return true;
+		if (/\breact-native\s+run-ios\b/.test(iosScript)) return false;
+	}
+	if (!pkg) return false;
+	const hasExpoDep = "expo" in {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const resolvable = () => isPackageResolvable(projectRoot, "expo");
+	if (!hasExpoDep && !resolvable()) return false;
+	const appJson = readAppJson(projectRoot);
+	if (appJson?.expo) return true;
+	const text = readAppConfigText(projectRoot);
+	if (text && /\b(?:from\s+['"]expo['"]|expo\/config|ExpoConfig)\b/.test(text)) return true;
+	if (hasExpoDep && resolvable()) return true;
+	if (looksLikeExpoConfig(appJson)) return true;
+	if (podfileUsesExpoModules(projectRoot)) return true;
+	return false;
+}
+function looksLikeExpoConfig(appJson) {
+	if (!appJson || typeof appJson !== "object" || Array.isArray(appJson)) return false;
+	if (appJson.expo) return true;
+	if ([
+		"slug",
+		"plugins",
+		"sdkVersion",
+		"experiments",
+		"runtimeVersion",
+		"updates",
+		"buildCacheProvider",
+		"assetBundlePatterns",
+		"splash",
+		"orientation",
+		"userInterfaceStyle"
+	].some((key) => appJson[key] !== void 0)) return true;
+	return Boolean(appJson.extra && typeof appJson.extra === "object" && appJson.extra.eas);
+}
+function podfileUsesExpoModules(projectRoot) {
+	const p = join(projectRoot, "ios", "Podfile");
+	if (!existsSync(p)) return false;
+	try {
+		return /^[^#\n]*use_expo_modules!/m.test(readFileSync(p, "utf-8"));
+	} catch {
+		return false;
+	}
+}
+function readAppJson(projectRoot) {
+	const p = join(projectRoot, "app.json");
+	if (!existsSync(p)) return null;
+	try {
+		return JSON.parse(readFileSync(p, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function readAppConfigText(projectRoot) {
+	for (const name of [
+		"app.config.js",
+		"app.config.ts",
+		"app.config.cjs",
+		"app.config.mjs"
+	]) {
+		const p = join(projectRoot, name);
+		if (existsSync(p)) try {
+			return readFileSync(p, "utf-8");
+		} catch {}
+	}
+	return null;
+}
+function detectBundleId(projectRoot) {
+	const fromJson = readAppJson(projectRoot)?.expo?.ios?.bundleIdentifier;
+	if (typeof fromJson === "string" && fromJson) return fromJson;
+	const text = readAppConfigText(projectRoot);
+	if (text) {
+		const id = text.match(/bundleIdentifier\s*:\s*["']([^"']+)["']/)?.[1];
+		if (id) return id;
+	}
+	return detectBundleIdFromPbxproj(projectRoot);
+}
+function detectAndroidPackage(projectRoot) {
+	const fromJson = readAppJson(projectRoot)?.expo?.android?.package;
+	if (typeof fromJson === "string" && fromJson) return fromJson;
+	const text = readAppConfigText(projectRoot);
+	if (text) {
+		const pkg = text.match(/package\s*:\s*["']([^"']+)["']/)?.[1];
+		if (pkg) return pkg;
+	}
+	return detectAndroidPackageFromGradle(projectRoot);
+}
+function detectBundleIdFromPbxproj(projectRoot) {
+	const iosDir = join(projectRoot, "ios");
+	if (!existsSync(iosDir)) return null;
+	let entries;
+	try {
+		entries = readdirSync(iosDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory() || !entry.name.endsWith(".xcodeproj")) continue;
+		const pbx = join(iosDir, entry.name, "project.pbxproj");
+		if (!existsSync(pbx)) continue;
+		let text;
+		try {
+			text = readFileSync(pbx, "utf-8");
+		} catch {
+			continue;
+		}
+		const concrete = [...text.matchAll(/PRODUCT_BUNDLE_IDENTIFIER\s*=\s*([^;\s"]+)\s*;/g)].map((m) => m[1]).filter((id) => !!id && !id.startsWith("$") && !id.includes("("));
+		if (concrete.length === 0) continue;
+		const counts = {};
+		for (const id of concrete) counts[id] = (counts[id] || 0) + 1;
+		let best = null, bestCount = 0, bestLen = Infinity;
+		for (const [id, count] of Object.entries(counts)) if (count > bestCount || count === bestCount && id.length < bestLen) {
+			best = id;
+			bestCount = count;
+			bestLen = id.length;
+		}
+		return best;
+	}
+	return null;
+}
+function detectAndroidPackageFromGradle(projectRoot) {
+	const gradle = join(projectRoot, "android", "app", "build.gradle");
+	if (!existsSync(gradle)) return null;
+	let text;
+	try {
+		text = readFileSync(gradle, "utf-8");
+	} catch {
+		return null;
+	}
+	const nsId = text.match(/namespace\s+["']([^"']+)["']/)?.[1];
+	if (nsId) return nsId;
+	const appId = text.match(/applicationId\s+["']([^"']+)["']/)?.[1];
+	if (appId) return appId;
+	return null;
+}
+//#endregion
+export { findProjectRoot as a, resolvePackageJson as c, detectIsExpo as i, detectAndroidPackage as n, isPackageResolvable as o, detectBundleId as r, projectShortcut as s, appProjectProblem as t };