@carlesandres/house 0.4.0 → 0.4.2

package/src/update/compare.ts

@@ -0,0 +1,41 @@
+/**
+ * Strict-greater version compare for the update notice.
+ *
+ * The notice fires only when the registry's published version is *strictly
+ * greater* than the running version on its numeric base. Pre-release
+ * suffixes are stripped before compare because:
+ *
+ *  - `dist-tags.latest` is by convention a stable, never a pre-release; the
+ *    notice does not target users who opted into pre-releases via a custom
+ *    install command.
+ *  - A local dev build of `0.5.0-dev.3` should NOT be nagged toward the
+ *    published `0.5.0` while iterating on the same base — they're "the
+ *    same version" for nag purposes.
+ */
+
+const toBaseSegments = (version: string): readonly number[] | null => {
+	const base = version.split("-", 1)[0] ?? ""
+	const parts = base.split(".")
+	const nums: number[] = []
+	for (const p of parts) {
+		const n = Number(p)
+		if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) return null
+		nums.push(n)
+	}
+	return nums.length > 0 ? nums : null
+}
+
+/** True iff `candidate` > `current` on the numeric base. Malformed input → false. */
+export const isNewer = (candidate: string, current: string): boolean => {
+	const a = toBaseSegments(candidate)
+	const b = toBaseSegments(current)
+	if (!a || !b) return false
+	const len = Math.max(a.length, b.length)
+	for (let i = 0; i < len; i++) {
+		const x = a[i] ?? 0
+		const y = b[i] ?? 0
+		if (x > y) return true
+		if (x < y) return false
+	}
+	return false
+}

package/src/update/notice.ts

@@ -0,0 +1,29 @@
+/**
+ * Notice formatting for the update check. Kept separate from the probe so
+ * the surfaces (in-app footer, quit-time stderr print) can be reshaped
+ * without touching the network or cache code.
+ *
+ * Install-method note: we don't try to detect npm vs bun vs Homebrew. The
+ * runtime probe (`process.versions.bun`) only tells us how house was
+ * launched, not how it was installed — a user who ran `npm i -g …` and
+ * then happens to invoke via a bun-installed shim would be misled.
+ * Showing both commands is unambiguous and lets the user pick the one
+ * matching their install.
+ */
+
+import type { UpdateInfo } from "./check.ts"
+
+/** One-liner for the footer toast — must fit a tight viewport. */
+export const formatFooterNotice = (info: UpdateInfo): string =>
+	`update available: ${info.latestVersion} (current ${info.currentVersion})`
+
+/** Multi-line block printed to stderr after the renderer tears down. The
+ *  user keeps this in scrollback and can copy the command directly. */
+export const formatQuitNotice = (info: UpdateInfo): string =>
+	[
+		"",
+		`house ${info.latestVersion} is available (you have ${info.currentVersion}).`,
+		`  npm i -g ${info.pkgName}`,
+		`  bun add -g ${info.pkgName}`,
+		"",
+	].join("\n")

package/src/update/runtime.ts

@@ -0,0 +1,48 @@
+/**
+ * Process-singleton wiring for the update probe.
+ *
+ * The probe runs at most once per process. The result lands in a module
+ * variable so:
+ *  - any UI surface (DiscoverShell, App) can subscribe and re-render when
+ *    it resolves, without each one issuing its own request;
+ *  - the `process.on("exit")` hook can synchronously read the result and
+ *    print the quit-time notice (async work can't run during 'exit').
+ *
+ * Failures resolve to `null` — silent by design. See `check.ts`.
+ */
+
+import type { UpdateInfo } from "./check.ts"
+import { checkForUpdate } from "./check.ts"
+
+let current: UpdateInfo | null = null
+let started = false
+let pending: Promise<void> | null = null
+const listeners = new Set<(info: UpdateInfo) => void>()
+
+export const startUpdateProbe = (pkgName: string, currentVersion: string): Promise<void> => {
+	if (pending) return pending
+	started = true
+	pending = checkForUpdate({ pkgName, currentVersion })
+		.then((info) => {
+			if (info) {
+				current = info
+				for (const cb of listeners) cb(info)
+			}
+		})
+		.catch(() => {
+			// silent — the feature is opportunistic
+		})
+	return pending
+}
+
+export const currentUpdateInfo = (): UpdateInfo | null => current
+
+export const subscribeUpdateInfo = (cb: (info: UpdateInfo) => void): (() => void) => {
+	if (current) cb(current)
+	listeners.add(cb)
+	return () => {
+		listeners.delete(cb)
+	}
+}
+
+export const isProbeStarted = (): boolean => started

package/src/update/useUpdateNotice.ts

@@ -0,0 +1,24 @@
+/**
+ * React hook for the update-available footer toast.
+ *
+ * Returns the formatted one-liner once the singleton probe resolves with a
+ * strictly-newer-and-downloadable version, and `null` otherwise. Mounting
+ * multiple consumers is safe — they all share the same probe via
+ * `runtime.ts`.
+ */
+
+import { useEffect, useState } from "react"
+import { currentUpdateInfo, subscribeUpdateInfo } from "./runtime.ts"
+import { formatFooterNotice } from "./notice.ts"
+
+export const useUpdateNotice = (): string | null => {
+	const [text, setText] = useState<string | null>(() => {
+		const cur = currentUpdateInfo()
+		return cur ? formatFooterNotice(cur) : null
+	})
+	useEffect(() => {
+		const unsub = subscribeUpdateInfo((info) => setText(formatFooterNotice(info)))
+		return unsub
+	}, [])
+	return text
+}