@stim-cli/core 1.20.0 → 1.20.2

package/dist/status-derived-C13g6eQt.mjs

@@ -0,0 +1,151 @@
+//#region state/status-derived.ts
+const PLATFORMS = ["ios", "android"];
+function isRunning(platform, device) {
+	if (platform === "ios") return device.state === "Booted";
+	return device.state === "detected" && !device.physical;
+}
+function appPresence(env, platform, device) {
+	if (!isRunning(platform, device) || device.app?.state === "running") return null;
+	const everBuilt = env.builds?.[platform]?.some((entry) => entry.result === "succeeded") ?? true;
+	if (env.lastBuilds?.[platform]?.status === "failed" && !everBuilt) return "none";
+	return device.app?.state === "stopped" ? "closed" : null;
+}
+function deviceSlots(env) {
+	return [{
+		slot: "default",
+		ios: env.ios,
+		android: env.android
+	}, ...env.slots ?? []];
+}
+function latestBuild(env) {
+	let latest = null;
+	for (const platform of PLATFORMS) {
+		const build = env.lastBuilds?.[platform];
+		if (build && (latest === null || Date.parse(build.startedAt) > Date.parse(latest.startedAt))) latest = build;
+	}
+	return latest;
+}
+function stage(kind, since, platform = null) {
+	return {
+		kind,
+		since: since ?? null,
+		platform,
+		closedApps: []
+	};
+}
+function workspaceStage(env) {
+	if (env.macos?.build.state === "running") return stage("building", env.macos.build.startedAt, "macos");
+	if (env.macos?.build.state === "failed") return stage("build-failed", env.macos.build.finishedAt ?? env.macos.build.startedAt, "macos");
+	if (env.build?.state === "running") return stage("building", env.build.startedAt, env.build.platform);
+	const macosApp = env.macos?.state === "running" || env.macos?.state === "orphaned" ? env.macos : null;
+	const live = env.live || macosApp !== null;
+	if (!live && env.phase === "warming") return stage("warming", env.phaseSince);
+	if (!live && env.phase === "ready") return stage("ready", env.phaseSince);
+	const latest = latestBuild(env);
+	if (latest?.status === "failed") return stage("build-failed", latest.finishedAt ?? latest.startedAt, latest.platform);
+	if (live || (env.remoteDevices?.length ?? 0) > 0) {
+		const closedApps = deviceSlots(env).flatMap(({ slot, ...devices }) => PLATFORMS.flatMap((platform) => {
+			const device = devices[platform];
+			return device && appPresence(env, platform, device) === "closed" ? [{
+				platform,
+				slot
+			}] : [];
+		}));
+		return {
+			...stage("running", env.supervisor?.startedAt ?? macosApp?.build.finishedAt ?? macosApp?.build.startedAt),
+			closedApps
+		};
+	}
+	const lastStop = env.metro?.lastStop;
+	return stage("stopped", lastStop && "at" in lastStop ? lastStop.at : null);
+}
+function checksState(checks) {
+	if (!checks) return null;
+	if (checks.failing > 0) return "failing";
+	if (checks.pending > 0) return "pending";
+	return checks.passing > 0 ? "passing" : null;
+}
+function gitChip(worktree) {
+	const git = worktree.git;
+	if (!git) return null;
+	const pull = worktree.pullRequest;
+	const parts = [];
+	const ahead = git.ahead ?? 0;
+	const behind = git.behind ?? 0;
+	if (ahead || behind) parts.push({
+		kind: "arrows",
+		ahead,
+		behind
+	});
+	const uncommitted = git.changed + git.untracked;
+	if (uncommitted) parts.push({
+		kind: "changed",
+		count: uncommitted
+	});
+	if (git.mergedInto !== null) {
+		if (pull?.state !== "merged") parts.push({
+			kind: "merged",
+			into: git.mergedInto
+		});
+	} else if (git.upstream === null) parts.push({ kind: "no-upstream" });
+	return {
+		parts,
+		ci: pull ? checksState(pull.checks) : null
+	};
+}
+function buildCause(build) {
+	if (("result" in build ? build.result : build.status) !== "failed") return null;
+	const at = build.diagnostics?.find((d) => d.file && d.line !== null && d.line !== void 0);
+	if (at) return {
+		key: `${at.file}:${at.line}`,
+		file: at.file,
+		line: at.line
+	};
+	return {
+		key: build.errorCode ?? "failed",
+		file: null,
+		line: null
+	};
+}
+function withCauses(builds) {
+	if (!builds) return builds;
+	return Object.fromEntries(Object.entries(builds).map(([platform, list]) => [platform, list?.map((build) => withCause(build))]));
+}
+function withCause(build) {
+	const cause = buildCause(build);
+	return cause ? {
+		...build,
+		cause
+	} : build;
+}
+function withGitChip(worktree) {
+	const chip = gitChip(worktree);
+	return chip ? {
+		...worktree,
+		gitChip: chip
+	} : worktree;
+}
+/** The environment with the conclusions clients draw from it: `stage`, `appPresence`, `gitChip` and `cause`. */
+function withDerivedFacts(env) {
+	const device = (platform, record) => record ? {
+		...record,
+		appPresence: appPresence(env, platform, record)
+	} : record;
+	const derived = {
+		...env,
+		stage: workspaceStage(env)
+	};
+	if (env.ios) derived.ios = device("ios", env.ios);
+	if (env.android) derived.android = device("android", env.android);
+	if (env.slots) derived.slots = env.slots.map((slot) => ({
+		...slot,
+		ios: device("ios", slot.ios),
+		android: device("android", slot.android)
+	}));
+	if (env.worktree) derived.worktree = withGitChip(env.worktree);
+	if (env.lastBuilds) derived.lastBuilds = Object.fromEntries(Object.entries(env.lastBuilds).map(([platform, build]) => [platform, withCause(build)]));
+	if (env.builds) derived.builds = withCauses(env.builds);
+	return derived;
+}
+//#endregion
+export { withGitChip as n, withDerivedFacts as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stim-cli/core",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "description": "Shared internal cache and runtime primitives for Stim packages.",
   "license": "MIT",
   "repository": {