semajsx 0.8.0 → 0.9.0

package/dist/{src-CXY-7FC3.mjs → src-77V1Plyd.mjs}

@@ -1,6 +1,6 @@
 import { t as signal } from "./signal-4PgGfydw.mjs";
 import { t as computed } from "./computed-BpjqvQu1.mjs";
-import { c as when, i as jsx, t as createRenderer, v as Fragment } from "./src-Cv4rRVzv.mjs";
+import { a as jsxs, c as when, i as jsx, t as createRenderer, v as Fragment } from "./src--YS4EvMz.mjs";
 import Yoga from "yoga-layout-prebuilt";
 import ansiEscapes from "ansi-escapes";
 import stringWidth from "string-width";
@@ -11,54 +11,62 @@ import wrapAnsi from "wrap-ansi";
 
 //#region ../terminal/src/utils/colors.ts
 /**
+* Color name to chalk function mapping (hoisted to module level for performance)
+*/
+const colors = {
+	black: chalk.black,
+	red: chalk.red,
+	green: chalk.green,
+	yellow: chalk.yellow,
+	blue: chalk.blue,
+	magenta: chalk.magenta,
+	cyan: chalk.cyan,
+	white: chalk.white,
+	gray: chalk.gray,
+	grey: chalk.grey,
+	blackBright: chalk.blackBright,
+	redBright: chalk.redBright,
+	greenBright: chalk.greenBright,
+	yellowBright: chalk.yellowBright,
+	blueBright: chalk.blueBright,
+	magentaBright: chalk.magentaBright,
+	cyanBright: chalk.cyanBright,
+	whiteBright: chalk.whiteBright
+};
+/**
+* Background color name to chalk function mapping (hoisted to module level for performance)
+*/
+const bgColors = {
+	black: chalk.bgBlack,
+	red: chalk.bgRed,
+	green: chalk.bgGreen,
+	yellow: chalk.bgYellow,
+	blue: chalk.bgBlue,
+	magenta: chalk.bgMagenta,
+	cyan: chalk.bgCyan,
+	white: chalk.bgWhite,
+	gray: chalk.bgGray,
+	grey: chalk.bgGrey,
+	blackBright: chalk.bgBlackBright,
+	redBright: chalk.bgRedBright,
+	greenBright: chalk.bgGreenBright,
+	yellowBright: chalk.bgYellowBright,
+	blueBright: chalk.bgBlueBright,
+	magentaBright: chalk.bgMagentaBright,
+	cyanBright: chalk.bgCyanBright,
+	whiteBright: chalk.bgWhiteBright
+};
+/**
 * Get a chalk color function by name
 */
 function getChalkColor(colorName) {
-	return {
-		black: chalk.black,
-		red: chalk.red,
-		green: chalk.green,
-		yellow: chalk.yellow,
-		blue: chalk.blue,
-		magenta: chalk.magenta,
-		cyan: chalk.cyan,
-		white: chalk.white,
-		gray: chalk.gray,
-		grey: chalk.grey,
-		blackBright: chalk.blackBright,
-		redBright: chalk.redBright,
-		greenBright: chalk.greenBright,
-		yellowBright: chalk.yellowBright,
-		blueBright: chalk.blueBright,
-		magentaBright: chalk.magentaBright,
-		cyanBright: chalk.cyanBright,
-		whiteBright: chalk.whiteBright
-	}[colorName] || chalk;
+	return colors[colorName] || chalk;
 }
 /**
 * Get a chalk background color function by name
 */
 function getChalkBgColor(colorName) {
-	return {
-		black: chalk.bgBlack,
-		red: chalk.bgRed,
-		green: chalk.bgGreen,
-		yellow: chalk.bgYellow,
-		blue: chalk.bgBlue,
-		magenta: chalk.bgMagenta,
-		cyan: chalk.bgCyan,
-		white: chalk.bgWhite,
-		gray: chalk.bgGray,
-		grey: chalk.bgGrey,
-		blackBright: chalk.bgBlackBright,
-		redBright: chalk.bgRedBright,
-		greenBright: chalk.bgGreenBright,
-		yellowBright: chalk.bgYellowBright,
-		blueBright: chalk.bgBlueBright,
-		magentaBright: chalk.bgMagentaBright,
-		cyanBright: chalk.bgCyanBright,
-		whiteBright: chalk.bgWhiteBright
-	}[colorName] || chalk;
+	return bgColors[colorName] || chalk;
 }
 
 //#endregion
@@ -378,7 +386,8 @@ var TerminalRenderer = class {
 		this.buffer = [];
 		this.previousOutput = "";
 		this.lastOutputHeight = 0;
-		this.wasRawMode = false;
+		this.resizeHandler = null;
+		this.resizeCallback = null;
 		this.root = {
 			type: "root",
 			stream,
@@ -393,11 +402,22 @@ var TerminalRenderer = class {
 			this.root.yogaNode.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN);
 			this.root.yogaNode.setAlignItems(Yoga.ALIGN_FLEX_START);
 		}
-		if (process.stdin.isTTY && process.stdin.setRawMode) {
-			this.wasRawMode = process.stdin.isRaw || false;
-			if (!this.wasRawMode) process.stdin.setRawMode(true);
-		}
 		this.root.stream.write(ansiEscapes.cursorHide);
+		this.resizeHandler = () => {
+			const { columns, rows } = this.root.stream;
+			if (this.root.yogaNode) {
+				this.root.yogaNode.setWidth(columns || 80);
+				this.root.yogaNode.setHeight(rows || 24);
+			}
+			if (this.resizeCallback) this.resizeCallback();
+		};
+		this.root.stream.on("resize", this.resizeHandler);
+	}
+	/**
+	* Set a callback to be called on terminal resize (triggers re-render).
+	*/
+	setResizeCallback(callback) {
+		this.resizeCallback = callback;
 	}
 	/**
 	* Get the root node
@@ -515,7 +535,10 @@ var TerminalRenderer = class {
 		this.render();
 		this.root.stream.write("\n");
 		this.root.stream.write(ansiEscapes.cursorShow);
-		if (process.stdin.isTTY && process.stdin.setRawMode && !this.wasRawMode) process.stdin.setRawMode(false);
+		if (this.resizeHandler) {
+			this.root.stream.removeListener("resize", this.resizeHandler);
+			this.resizeHandler = null;
+		}
 		if (this.root.yogaNode) this.root.yogaNode.freeRecursive();
 	}
 };
@@ -543,99 +566,392 @@ function setSignalProperty(node, key, signal) {
 	});
 }
 /**
+* Set of all recognized style property names (hoisted to module level for performance)
+*/
+const styleProps = new Set([
+	"flexDirection",
+	"justifyContent",
+	"alignItems",
+	"flexGrow",
+	"flexShrink",
+	"flexBasis",
+	"width",
+	"height",
+	"minWidth",
+	"minHeight",
+	"maxWidth",
+	"maxHeight",
+	"margin",
+	"marginLeft",
+	"marginRight",
+	"marginTop",
+	"marginBottom",
+	"marginInline",
+	"marginBlock",
+	"padding",
+	"paddingLeft",
+	"paddingRight",
+	"paddingTop",
+	"paddingBottom",
+	"paddingInline",
+	"paddingBlock",
+	"border",
+	"borderColor",
+	"color",
+	"backgroundColor",
+	"bold",
+	"italic",
+	"underline",
+	"strikethrough",
+	"dim"
+]);
+/**
 * Check if a property is a style property
 */
 function isStyleProperty(key) {
-	return new Set([
-		"flexDirection",
-		"justifyContent",
-		"alignItems",
-		"flexGrow",
-		"flexShrink",
-		"flexBasis",
-		"width",
-		"height",
-		"minWidth",
-		"minHeight",
-		"maxWidth",
-		"maxHeight",
-		"margin",
-		"marginLeft",
-		"marginRight",
-		"marginTop",
-		"marginBottom",
-		"marginInline",
-		"marginBlock",
-		"padding",
-		"paddingLeft",
-		"paddingRight",
-		"paddingTop",
-		"paddingBottom",
-		"paddingInline",
-		"paddingBlock",
-		"border",
-		"borderColor",
-		"color",
-		"backgroundColor",
-		"bold",
-		"italic",
-		"underline",
-		"strikethrough",
-		"dim"
-	]).has(key);
+	return styleProps.has(key);
 }
 
 //#endregion
-//#region ../terminal/src/components/ExitHint.tsx
-/** @jsxImportSource @semajsx/terminal */
+//#region ../terminal/src/context.ts
 /**
-* Global exiting signal for terminal rendering
-* Set to true during unmount to hide exit hints in final render
+* The active terminal session. Set by render(), cleared on unmount.
 */
-const globalExitingSignal = signal(false);
+let activeSession = null;
 /**
-* Get the global exiting signal
-* Used internally by render() to coordinate with ExitHint component
+* Create a fresh terminal session
 */
-function getExitingSignal() {
-	return globalExitingSignal;
+function createTerminalSession() {
+	return {
+		keyboardListeners: [],
+		lastKeySignal: signal(null),
+		keyboardInstalled: false,
+		stdinHandler: null,
+		exitCallback: null,
+		cleanupCallbacks: [],
+		exitingSignal: signal(false)
+	};
 }
 /**
-* Reset the exiting signal (useful for testing or multiple render cycles)
+* Set the active terminal session
 */
-function resetExitingSignal() {
-	globalExitingSignal.value = false;
+function setActiveSession(session) {
+	activeSession = session;
 }
 /**
-* ExitHint component - hides its children during the final render before exit
+* Get the active terminal session, or null if no render is active
+*/
+function getActiveSession() {
+	return activeSession;
+}
+
+//#endregion
+//#region ../terminal/src/keyboard.ts
+/**
+* Parse raw stdin data into a KeyEvent
+*/
+function parseKeyEvent(data) {
+	const raw = data.toString();
+	const event = {
+		key: "",
+		ctrl: false,
+		shift: false,
+		meta: false,
+		raw
+	};
+	if (raw === "\x1B[A") {
+		event.key = "up";
+		return event;
+	}
+	if (raw === "\x1B[B") {
+		event.key = "down";
+		return event;
+	}
+	if (raw === "\x1B[C") {
+		event.key = "right";
+		return event;
+	}
+	if (raw === "\x1B[D") {
+		event.key = "left";
+		return event;
+	}
+	if (raw === "\x1B[H" || raw === "\x1B[1~") {
+		event.key = "home";
+		return event;
+	}
+	if (raw === "\x1B[F" || raw === "\x1B[4~") {
+		event.key = "end";
+		return event;
+	}
+	if (raw === "\x1B[5~") {
+		event.key = "pageup";
+		return event;
+	}
+	if (raw === "\x1B[6~") {
+		event.key = "pagedown";
+		return event;
+	}
+	if (raw === "\x1B[3~") {
+		event.key = "delete";
+		return event;
+	}
+	if (raw === "\x1B[2~") {
+		event.key = "insert";
+		return event;
+	}
+	if (raw.length === 2 && raw[0] === "\x1B") {
+		event.meta = true;
+		event.key = raw[1];
+		return event;
+	}
+	if (raw === "\x1B") {
+		event.key = "escape";
+		return event;
+	}
+	if (raw === "") {
+		event.key = "c";
+		event.ctrl = true;
+		return event;
+	}
+	if (raw === "\r" || raw === "\n") {
+		event.key = "return";
+		return event;
+	}
+	if (raw === "	") {
+		event.key = "tab";
+		return event;
+	}
+	if (raw === "" || raw === "\b") {
+		event.key = "backspace";
+		return event;
+	}
+	if (raw === " ") {
+		event.key = "space";
+		return event;
+	}
+	if (raw.length === 1) {
+		const code = raw.charCodeAt(0);
+		if (code >= 1 && code <= 26) {
+			event.ctrl = true;
+			event.key = String.fromCharCode(code + 96);
+			return event;
+		}
+	}
+	if (raw.length === 1) {
+		event.key = raw;
+		if (raw >= "A" && raw <= "Z") event.shift = true;
+		return event;
+	}
+	event.key = raw;
+	return event;
+}
+/**
+* Install the keyboard handler on stdin for the active render context.
+* Called automatically by render() when setting up keyboard input.
+*/
+function installKeyboardHandler() {
+	const ctx = getActiveSession();
+	if (!ctx || ctx.keyboardInstalled) return;
+	ctx.keyboardInstalled = true;
+	ctx.stdinHandler = (data) => {
+		const event = parseKeyEvent(data);
+		ctx.lastKeySignal.value = event;
+		const listeners = [...ctx.keyboardListeners];
+		for (const listener of listeners) listener(event);
+	};
+	if (process.stdin.isTTY) process.stdin.on("data", ctx.stdinHandler);
+}
+/**
+* Uninstall the keyboard handler for the active render context.
+* Called during cleanup/unmount.
+*/
+function uninstallKeyboardHandler() {
+	const ctx = getActiveSession();
+	if (!ctx || !ctx.keyboardInstalled) return;
+	ctx.keyboardInstalled = false;
+	if (ctx.stdinHandler) {
+		process.stdin.removeListener("data", ctx.stdinHandler);
+		ctx.stdinHandler = null;
+	}
+	ctx.keyboardListeners = [];
+}
+/**
+* Subscribe to keyboard events with a callback.
+* Returns an unsubscribe function.
 *
-* This is useful for hiding "Press Ctrl+C to exit" messages in the final
-* terminal output, keeping only the actual content visible.
+* @example
+* ```tsx
+* const unsub = onKeypress((event) => {
+*   if (event.key === "up") moveUp();
+*   if (event.key === "down") moveDown();
+*   if (event.key === "return") confirm();
+* });
 *
-* The component automatically detects when unmount() is called and reactively
-* hides its children during the final render using signal-based reactivity.
+* // Later: unsub();
+* ```
+*/
+function onKeypress(handler) {
+	const ctx = getActiveSession();
+	if (!ctx) return () => {};
+	ctx.keyboardListeners.push(handler);
+	installKeyboardHandler();
+	return () => {
+		const idx = ctx.keyboardListeners.indexOf(handler);
+		if (idx !== -1) ctx.keyboardListeners.splice(idx, 1);
+	};
+}
+/**
+* Get a readonly signal of the last keypress event.
+* Useful for reactive UIs that need to respond to any key.
 *
 * @example
 * ```tsx
-* render(
-*   <box flexDirection="column" padding={1}>
-*     <text bold>Counter: {count}</text>
+* const lastKey = useKeypress();
+* // lastKey.value is null initially, then updated on each keypress
+* ```
+*/
+function useKeypress() {
+	const ctx = getActiveSession();
+	if (!ctx) return signal(null);
+	installKeyboardHandler();
+	return ctx.lastKeySignal;
+}
+
+//#endregion
+//#region ../terminal/src/hooks.ts
+/**
+* Terminal hooks for interactive CLI applications
+*/
+/**
+* Set the exit callback on the active render context.
+* Called internally by render().
+*/
+function setExitCallback(callback) {
+	const ctx = getActiveSession();
+	if (ctx) ctx.exitCallback = callback;
+}
+/**
+* Programmatic exit hook - allows components to trigger unmount.
 *
-*     <ExitHint>
-*       <text dim marginTop={1} color="yellow">
-*         Press Ctrl+C or ESC to exit
-*       </text>
-*     </ExitHint>
-*   </box>
-* );
+* Returns a function that, when called, unmounts the terminal app
+* (equivalent to pressing Ctrl+C).
+*
+* @example
+* ```tsx
+* function App() {
+*   const exit = useExit();
+*
+*   onKeypress((event) => {
+*     if (event.key === "q") exit();
+*   });
+*
+*   return <text>Press q to quit</text>;
+* }
 * ```
+*/
+function useExit() {
+	return () => {
+		const ctx = getActiveSession();
+		if (ctx?.exitCallback) ctx.exitCallback();
+	};
+}
+/**
+* Check whether stdin raw mode is supported and/or active.
 *
-* Result after exit:
-* - The counter remains visible
-* - The exit hint is hidden from final output
+* Useful for graceful degradation in non-TTY environments (CI, pipes).
+*
+* @example
+* ```tsx
+* const { supported, active } = isRawModeSupported();
+* if (!supported) {
+*   print(<text>Interactive mode not available</text>);
+* }
+* ```
 */
-function ExitHint({ children }) {
-	return when(computed(globalExitingSignal, (isExiting) => !isExiting), children);
+function isRawModeSupported() {
+	const supported = Boolean(process.stdin.isTTY && process.stdin.setRawMode);
+	return {
+		supported,
+		active: supported && Boolean(process.stdin.isRaw)
+	};
+}
+
+//#endregion
+//#region ../terminal/src/lifecycle.ts
+/**
+* Component lifecycle management for terminal rendering.
+*
+* Provides an onCleanup registry that components can use to register
+* cleanup callbacks (timers, listeners, etc.) that run during unmount.
+*
+* Supports two modes:
+* - Per-component scope (via onBeforeComponent/onAfterComponent hooks in core)
+*   Cleanups attached to RenderedNode.subscriptions, run when component unmounts
+* - Global fallback (when called outside component render)
+*   Cleanups stored in TerminalSession.cleanupCallbacks, run on full unmount
+*/
+/**
+* Stack of per-component cleanup scopes.
+* Pushed by onBeforeComponent(), popped by onAfterComponent().
+*/
+const cleanupScopes = [];
+/**
+* Push a new per-component cleanup scope.
+* Called by core's renderComponent via onBeforeComponent strategy hook.
+*/
+function pushCleanupScope() {
+	cleanupScopes.push([]);
+}
+/**
+* Pop the current cleanup scope and return collected callbacks.
+* Called by core's renderComponent via onAfterComponent strategy hook.
+*/
+function popCleanupScope() {
+	return cleanupScopes.pop() ?? [];
+}
+/**
+* Register a cleanup callback that will run when the component unmounts.
+*
+* When called during component rendering, the callback is attached to
+* the component's RenderedNode and runs when that component is unmounted
+* (including via conditional rendering with when()/signal).
+*
+* When called outside component rendering (e.g., in render setup code),
+* falls back to the global session cleanup list.
+*
+* @example
+* ```tsx
+* function Timer() {
+*   const elapsed = signal(0);
+*   const timer = setInterval(() => { elapsed.value++ }, 1000);
+*   onCleanup(() => clearInterval(timer));
+*   return <text>Elapsed: {elapsed}s</text>;
+* }
+* ```
+*/
+function onCleanup(fn) {
+	if (cleanupScopes.length > 0) {
+		cleanupScopes[cleanupScopes.length - 1].push(fn);
+		return;
+	}
+	const ctx = getActiveSession();
+	if (ctx) ctx.cleanupCallbacks.push(fn);
+}
+/**
+* Run all registered global cleanup callbacks and clear the registry.
+* Called internally by render() during unmount.
+*
+* Note: Per-component cleanups are handled by core's unmount/cleanupSubscriptions.
+* This only flushes the global fallback list.
+*/
+function flushCleanups() {
+	const ctx = getActiveSession();
+	if (!ctx) return;
+	const callbacks = [...ctx.cleanupCallbacks];
+	ctx.cleanupCallbacks = [];
+	for (const fn of callbacks) try {
+		fn();
+	} catch {}
 }
 
 //#endregion
@@ -651,7 +967,9 @@ const { renderNode, cleanupSubscriptions } = createRenderer({
 	removeChild,
 	replaceNode,
 	setProperty,
-	setSignalProperty
+	setSignalProperty,
+	onBeforeComponent: pushCleanupScope,
+	onAfterComponent: popCleanupScope
 });
 /**
 * Render a VNode tree to the terminal
@@ -681,7 +999,8 @@ const { renderNode, cleanupSubscriptions } = createRenderer({
 */
 function render(element, options = {}) {
 	const { renderer, autoRender = true, fps = 60, stream: outputStream = process.stdout } = options;
-	resetExitingSignal();
+	const session = createTerminalSession();
+	setActiveSession(session);
 	const autoCreated = !renderer;
 	const actualRenderer = renderer || new TerminalRenderer(outputStream);
 	const root = actualRenderer.getRoot();
@@ -692,15 +1011,24 @@ function render(element, options = {}) {
 	}
 	actualRenderer.render();
 	let isRendering = false;
+	let renderPending = false;
 	const safeRender = () => {
-		if (isRendering) return;
+		if (isRendering) {
+			renderPending = true;
+			return;
+		}
 		isRendering = true;
 		try {
 			actualRenderer.render();
+			while (renderPending) {
+				renderPending = false;
+				actualRenderer.render();
+			}
 		} finally {
 			isRendering = false;
 		}
 	};
+	actualRenderer.setResizeCallback(safeRender);
 	let renderInterval = null;
 	if (autoRender) {
 		const interval = Math.floor(1e3 / fps);
@@ -714,8 +1042,11 @@ function render(element, options = {}) {
 	});
 	const originalRawMode = process.stdin.isTTY && process.stdin.isRaw;
 	let handleExit = null;
-	let handleKeypress = null;
+	let exitKeyUnsub = null;
+	let cleaned = false;
 	const cleanup = () => {
+		if (cleaned) return;
+		cleaned = true;
 		if (renderInterval) {
 			clearInterval(renderInterval);
 			renderInterval = null;
@@ -724,19 +1055,28 @@ function render(element, options = {}) {
 			process.removeListener("SIGINT", handleExit);
 			process.removeListener("SIGTERM", handleExit);
 		}
-		if (handleKeypress) process.stdin.removeListener("data", handleKeypress);
+		flushCleanups();
+		setExitCallback(null);
+		if (exitKeyUnsub) {
+			exitKeyUnsub();
+			exitKeyUnsub = null;
+		}
+		uninstallKeyboardHandler();
 		if (process.stdin.isTTY && process.stdin.setRawMode) try {
 			process.stdin.setRawMode(originalRawMode || false);
 		} catch {}
 		cleanupSubscriptions(rendered);
+		actualRenderer.setResizeCallback(null);
 		actualRenderer.destroy();
+		setActiveSession(null);
 		if (exitResolver) exitResolver();
 	};
 	const unmount = () => {
-		getExitingSignal().value = true;
+		session.exitingSignal.value = true;
 		actualRenderer.render();
 		cleanup();
 	};
+	setExitCallback(unmount);
 	if (autoCreated) {
 		handleExit = () => {
 			unmount();
@@ -748,13 +1088,12 @@ function render(element, options = {}) {
 			if (process.stdin.isTTY) {
 				process.stdin.setRawMode(true);
 				process.stdin.resume();
-				handleKeypress = (data) => {
-					const key = data.toString();
-					if (key === "" || key === "\x1B") {
+				installKeyboardHandler();
+				exitKeyUnsub = onKeypress((event) => {
+					if (event.key === "c" && event.ctrl || event.key === "escape") {
 						if (handleExit) handleExit();
 					}
-				};
-				process.stdin.on("data", handleKeypress);
+				});
 			}
 		} catch (err) {
 			cleanup();
@@ -819,6 +1158,41 @@ function print(element, options = {}) {
 	if (process.stdin.isTTY && process.stdin.setRawMode && wasRawMode) process.stdin.setRawMode(true);
 }
 
+//#endregion
+//#region ../terminal/src/components/ExitHint.tsx
+/** @jsxImportSource @semajsx/terminal */
+/**
+* ExitHint component - hides its children during the final render before exit
+*
+* This is useful for hiding "Press Ctrl+C to exit" messages in the final
+* terminal output, keeping only the actual content visible.
+*
+* The component automatically detects when unmount() is called and reactively
+* hides its children during the final render using signal-based reactivity.
+*
+* @example
+* ```tsx
+* render(
+*   <box flexDirection="column" padding={1}>
+*     <text bold>Counter: {count}</text>
+*
+*     <ExitHint>
+*       <text dim marginTop={1} color="yellow">
+*         Press Ctrl+C or ESC to exit
+*       </text>
+*     </ExitHint>
+*   </box>
+* );
+* ```
+*
+* Result after exit:
+* - The counter remains visible
+* - The exit hint is hidden from final output
+*/
+function ExitHint({ children }) {
+	return when(computed(getActiveSession()?.exitingSignal ?? signal(false), (isExiting) => !isExiting), children);
+}
+
 //#endregion
 //#region ../terminal/src/components/BlankLine.tsx
 /**
@@ -842,5 +1216,167 @@ function BlankLine({ count = 1 }) {
 }
 
 //#endregion
-export { renderBackground as C, getChalkColor as E, setText as S, getChalkBgColor as T, getParent as _, setProperty as a, removeChild as b, renderTextElement as c, applyStyle as d, collectText as f, getNextSibling as g, createTextNode as h, ExitHint as i, renderTextNode as l, createElement as m, print as n, setSignalProperty as o, createComment as p, render as r, TerminalRenderer as s, BlankLine as t, appendChild as u, insertBefore as v, renderBorder as w, replaceNode as x, markNodeAsDirty as y };
-//# sourceMappingURL=src-CXY-7FC3.mjs.map
+//#region ../terminal/src/components/Spinner.tsx
+/** @jsxImportSource @semajsx/terminal */
+/**
+* Built-in spinner frame sets
+*/
+const spinnerFrames = {
+	dots: {
+		frames: [
+			"⠋",
+			"⠙",
+			"⠹",
+			"⠸",
+			"⠼",
+			"⠴",
+			"⠦",
+			"⠧",
+			"⠇",
+			"⠏"
+		],
+		interval: 80
+	},
+	line: {
+		frames: [
+			"-",
+			"\\",
+			"|",
+			"/"
+		],
+		interval: 130
+	},
+	arc: {
+		frames: [
+			"◜",
+			"◠",
+			"◝",
+			"◞",
+			"◡",
+			"◟"
+		],
+		interval: 100
+	},
+	bouncingBar: {
+		frames: [
+			"[    ]",
+			"[=   ]",
+			"[==  ]",
+			"[=== ]",
+			"[ ===]",
+			"[  ==]",
+			"[   =]",
+			"[    ]"
+		],
+		interval: 80
+	}
+};
+/**
+* Spinner component - animated loading indicator for terminal UIs.
+*
+* @example
+* ```tsx
+* <Spinner />
+* <Spinner type="line" label="Loading..." />
+* <Spinner frames={["🌑", "🌒", "🌓", "🌔", "🌕"]} interval={150} />
+* ```
+*/
+function Spinner({ type = "dots", frames: customFrames, interval: customInterval, label, color = "cyan" }) {
+	const config = spinnerFrames[type];
+	const frames = customFrames ?? config.frames;
+	const interval = customInterval ?? config.interval;
+	const frameSignal = signal(frames[0]);
+	let index = 0;
+	const timer = setInterval(() => {
+		index = (index + 1) % frames.length;
+		frameSignal.value = frames[index];
+	}, interval);
+	onCleanup(() => clearInterval(timer));
+	if (label) return /* @__PURE__ */ jsxs("box", {
+		flexDirection: "row",
+		children: [/* @__PURE__ */ jsx("text", {
+			color,
+			children: frameSignal
+		}), /* @__PURE__ */ jsxs("text", { children: [" ", label] })]
+	});
+	return /* @__PURE__ */ jsx("text", {
+		color,
+		children: frameSignal
+	});
+}
+
+//#endregion
+//#region ../terminal/src/components/MultiSelect.tsx
+/** @jsxImportSource @semajsx/terminal */
+/**
+* MultiSelect component - interactive multi-selection menu.
+*
+* Navigate with arrow keys, toggle with Space, confirm with Enter, cancel with Escape.
+*
+* @example
+* ```tsx
+* <MultiSelect
+*   title="Select frameworks:"
+*   options={[
+*     { label: "React", value: "react" },
+*     { label: "Vue", value: "vue" },
+*     { label: "Svelte", value: "svelte" },
+*   ]}
+*   onConfirm={(selected) => console.log("Selected:", selected)}
+* />
+* ```
+*/
+function MultiSelect({ options, onConfirm, onCancel, title, indicator = "❯", selectedIndicator = "◉", unselectedIndicator = "◯", focusColor = "cyan", selectedColor = "green" }) {
+	const focusIndex = signal(0);
+	const selectedSet = signal(/* @__PURE__ */ new Set());
+	const unsub = onKeypress((event) => {
+		if (event.key === "up") focusIndex.value = Math.max(0, focusIndex.value - 1);
+		else if (event.key === "down") focusIndex.value = Math.min(options.length - 1, focusIndex.value + 1);
+		else if (event.key === "space") {
+			const current = new Set(selectedSet.value);
+			const value = options[focusIndex.value].value;
+			if (current.has(value)) current.delete(value);
+			else current.add(value);
+			selectedSet.value = current;
+		} else if (event.key === "return") {
+			unsub();
+			onConfirm(Array.from(selectedSet.value));
+		} else if (event.key === "escape" && onCancel) {
+			unsub();
+			onCancel();
+		}
+	});
+	onCleanup(unsub);
+	const items = options.map((option, i) => {
+		const isFocused = computed(focusIndex, (idx) => idx === i);
+		const isSelected = computed(selectedSet, (set) => set.has(option.value));
+		const prefix = computed(isSelected, (sel) => sel ? selectedIndicator : unselectedIndicator);
+		const line = computed(isFocused, (focused) => focused ? `${indicator} ${prefix.value} ${option.label}` : `  ${prefix.value} ${option.label}`);
+		return /* @__PURE__ */ jsx("text", {
+			color: computed(isFocused, (focused) => {
+				if (focused) return focusColor;
+				if (isSelected.value) return selectedColor;
+			}),
+			children: line
+		}, option.value);
+	});
+	return /* @__PURE__ */ jsxs("box", {
+		flexDirection: "column",
+		children: [
+			title ? /* @__PURE__ */ jsx("text", {
+				bold: true,
+				children: title
+			}) : null,
+			items,
+			/* @__PURE__ */ jsx("text", {
+				dim: true,
+				marginTop: 1,
+				children: "↑/↓ navigate · space toggle · enter confirm"
+			})
+		]
+	});
+}
+
+//#endregion
+export { replaceNode as A, createElement as C, insertBefore as D, getParent as E, getChalkColor as F, renderBackground as M, renderBorder as N, markNodeAsDirty as O, getChalkBgColor as P, createComment as S, getNextSibling as T, renderTextElement as _, ExitHint as a, applyStyle as b, onCleanup as c, onKeypress as d, parseKeyEvent as f, TerminalRenderer as g, setSignalProperty as h, BlankLine as i, setText as j, removeChild as k, isRawModeSupported as l, setProperty as m, Spinner as n, print as o, useKeypress as p, spinnerFrames as r, render as s, MultiSelect as t, useExit as u, renderTextNode as v, createTextNode as w, collectText as x, appendChild as y };
+//# sourceMappingURL=src-77V1Plyd.mjs.map