@solid-tui/runtime 0.1.0

package/dist/index.mjs

@@ -0,0 +1,446 @@
+import { $ as createMemo, A as createElement, F as memo, H as addLayoutListener, I as mergeProps, J as catchError, L as setProp, M as effect, N as insert, P as insertNode, Q as createEffect, R as spread, T as kittyModifiers, X as createComponent$1, Y as children, Z as createContext, at as splitProps, b as nonAlphanumericKeys, d as AnimationSchedulerKey, et as createRenderEffect, f as AppContextKey, h as TextContextKey, it as onCleanup, j as createTextNode, k as createComponent, l as Text, m as StdinContextKey, nt as createSignal, ot as untrack, p as FocusContextKey, q as batch, r as createApp, rt as on, s as useWindowSize, st as useContext, t as renderToString, tt as createRoot, u as Box, v as createAnimationScheduler, w as kittyFlags, x as parseKeypress, y as normalizeInterval, z as use } from "./render-to-string-zweiEGvu.mjs";
+//#region src/components/newline.ts
+function Newline(props) {
+	const el = createElement(useContext(TextContextKey) ? "tui-virtual-text" : "tui-text");
+	insert(el, () => "\n".repeat(props.count ?? 1));
+	return el;
+}
+//#endregion
+//#region src/components/spacer.ts
+function Spacer(_props) {
+	const el = createElement("tui-box");
+	setProp(el, "flexGrow", 1);
+	setProp(el, "flexShrink", 1);
+	return el;
+}
+//#endregion
+//#region src/components/static.ts
+function Static(props) {
+	const [cursor, setCursor] = createSignal(0);
+	const el = createElement("tui-static");
+	const onWritten = () => {
+		setCursor(props.items.length);
+	};
+	createEffect(() => {
+		const len = props.items.length;
+		if (len < cursor()) setCursor(len);
+	});
+	spread(el, () => ({
+		position: "absolute",
+		flexDirection: "column",
+		...props.style,
+		internal_onWritten: onWritten
+	}), true);
+	insert(el, () => {
+		const renderItem = props.children;
+		if (!renderItem) return null;
+		return props.items.slice(cursor()).map((item, i) => renderItem({
+			item,
+			index: cursor() + i
+		}));
+	});
+	return el;
+}
+//#endregion
+//#region src/components/transform.ts
+function isEmpty(value) {
+	if (value == null || value === false || value === true) return true;
+	if (Array.isArray(value)) return value.every(isEmpty);
+	return false;
+}
+function Transform(props) {
+	const appCtx = useContext(AppContextKey);
+	const [local, rest] = splitProps(props, ["children", "accessibilityLabel"]);
+	const content = createComponent$1(TextContextKey.Provider, {
+		value: true,
+		get children() {
+			return local.children;
+		}
+	});
+	const resolved = children(() => content);
+	const el = createElement("tui-transform");
+	spread(el, rest, true);
+	insert(el, () => {
+		return (appCtx?.isScreenReaderEnabled ?? false) && local.accessibilityLabel ? local.accessibilityLabel : resolved();
+	});
+	return (() => isEmpty(resolved()) ? null : el);
+}
+//#endregion
+//#region src/hooks/useApp.ts
+function useApp() {
+	const ctx = useContext(AppContextKey);
+	if (!ctx) throw new Error("useApp() must be called inside a solid-tui render tree");
+	return {
+		exit: ctx.exit,
+		waitUntilRenderFlush: ctx.waitUntilRenderFlush
+	};
+}
+//#endregion
+//#region src/hooks/useInput.ts
+const read$3 = (value) => typeof value === "function" ? value() : value;
+function useInput(handler, options = {}) {
+	const stdin = useContext(StdinContextKey);
+	if (!stdin) throw new Error("useInput() must be called inside a solid-tui render tree");
+	const stdinCtx = stdin;
+	let attached = false;
+	function listener(data) {
+		const keypress = parseKeypress(data);
+		if (keypress.ignore) return;
+		const key = {
+			upArrow: keypress.name === "up",
+			downArrow: keypress.name === "down",
+			leftArrow: keypress.name === "left",
+			rightArrow: keypress.name === "right",
+			pageDown: keypress.name === "pagedown",
+			pageUp: keypress.name === "pageup",
+			home: keypress.name === "home",
+			end: keypress.name === "end",
+			return: keypress.name === "return",
+			escape: keypress.name === "escape",
+			ctrl: keypress.ctrl,
+			shift: keypress.shift,
+			tab: keypress.name === "tab",
+			backspace: keypress.name === "backspace",
+			delete: keypress.name === "delete",
+			meta: keypress.meta,
+			super: keypress.super ?? false,
+			hyper: keypress.hyper ?? false,
+			capsLock: keypress.capsLock ?? false,
+			numLock: keypress.numLock ?? false,
+			eventType: keypress.eventType
+		};
+		let input;
+		if (keypress.isKittyProtocol) if (keypress.isPrintable) input = keypress.text ?? keypress.name;
+		else if (keypress.ctrl && keypress.name.length === 1) input = keypress.name;
+		else input = "";
+		else if (keypress.ctrl) input = keypress.name ?? "";
+		else input = keypress.sequence;
+		if (!keypress.isKittyProtocol && nonAlphanumericKeys.includes(keypress.name)) input = "";
+		if (input.startsWith("\x1B")) input = input.slice(1);
+		if (input.length === 1 && /[A-Z]/.test(input)) key.shift = true;
+		handler(input, key);
+	}
+	function attach() {
+		if (attached) return;
+		attached = true;
+		stdinCtx.acquireRawMode();
+		stdinCtx.internal_eventEmitter.on("input", listener);
+	}
+	function detach() {
+		if (!attached) return;
+		attached = false;
+		stdinCtx.internal_eventEmitter.off("input", listener);
+		stdinCtx.releaseRawMode();
+	}
+	createEffect(() => {
+		if (read$3(options.isActive ?? true)) attach();
+		else detach();
+	});
+	onCleanup(detach);
+}
+//#endregion
+//#region src/hooks/usePaste.ts
+const read$2 = (value) => typeof value === "function" ? value() : value;
+function usePaste(handler, options = {}) {
+	const stdin = useContext(StdinContextKey);
+	if (!stdin) throw new Error("usePaste() must be called inside a solid-tui render tree");
+	const stdinCtx = stdin;
+	let attached = false;
+	function listener(text) {
+		handler(text);
+	}
+	function attach() {
+		if (attached) return;
+		attached = true;
+		stdinCtx.acquireRawMode();
+		stdinCtx.setBracketedPasteMode(true);
+		stdinCtx.internal_eventEmitter.on("paste", listener);
+	}
+	function detach() {
+		if (!attached) return;
+		attached = false;
+		stdinCtx.internal_eventEmitter.off("paste", listener);
+		stdinCtx.setBracketedPasteMode(false);
+		stdinCtx.releaseRawMode();
+	}
+	createEffect(() => {
+		if (read$2(options.isActive ?? true)) attach();
+		else detach();
+	});
+	onCleanup(detach);
+}
+//#endregion
+//#region src/hooks/useFocus.ts
+let nextAutoId = 0;
+const read$1 = (value) => typeof value === "function" ? value() : value;
+function useFocus(options = {}) {
+	const ctx = useContext(FocusContextKey);
+	const stdin = useContext(StdinContextKey);
+	if (!ctx) throw new Error("useFocus() must be called inside a solid-tui render tree");
+	const fallbackId = `__auto-${nextAutoId++}`;
+	const [isFocused, setFocused] = createSignal(false);
+	let rawModeAcquired = false;
+	let currentId;
+	let unsubscribe;
+	const unregister = () => {
+		if (currentId === void 0) return;
+		unsubscribe?.();
+		unsubscribe = void 0;
+		ctx.remove(currentId);
+		currentId = void 0;
+	};
+	const acquireRaw = () => {
+		if (!rawModeAcquired && stdin?.isRawModeSupported) {
+			stdin.acquireRawMode();
+			rawModeAcquired = true;
+		}
+	};
+	const releaseRaw = () => {
+		if (rawModeAcquired && stdin) {
+			stdin.releaseRawMode();
+			rawModeAcquired = false;
+		}
+	};
+	createEffect(() => {
+		const id = read$1(options.id ?? fallbackId) ?? fallbackId;
+		const autoFocus = read$1(options.autoFocus ?? false);
+		if (id === currentId) return;
+		unregister();
+		setFocused(false);
+		unsubscribe = ctx.subscribe(id, setFocused);
+		ctx.add(id, { autoFocus });
+		currentId = id;
+		setFocused(ctx.activeId === id);
+		if (read$1(options.isActive ?? true)) {
+			ctx.activate(id);
+			acquireRaw();
+		} else ctx.deactivate(id);
+	});
+	createEffect(() => {
+		if (currentId === void 0) return;
+		if (read$1(options.isActive ?? true)) {
+			ctx.activate(currentId);
+			acquireRaw();
+		} else {
+			ctx.deactivate(currentId);
+			releaseRaw();
+		}
+	});
+	onCleanup(() => {
+		unregister();
+		releaseRaw();
+	});
+	return {
+		isFocused,
+		focus: ctx.focus
+	};
+}
+//#endregion
+//#region src/hooks/useFocusManager.ts
+function useFocusManager() {
+	const ctx = useContext(FocusContextKey);
+	if (!ctx) throw new Error("useFocusManager() must be called inside a solid-tui render tree");
+	return {
+		enableFocus: ctx.enableFocus.bind(ctx),
+		disableFocus: ctx.disableFocus.bind(ctx),
+		focusNext: ctx.focusNext.bind(ctx),
+		focusPrevious: ctx.focusPrevious.bind(ctx),
+		focus: ctx.focus.bind(ctx),
+		activeId: ctx.activeIdValue
+	};
+}
+//#endregion
+//#region src/hooks/useStdin.ts
+function useStdin() {
+	const ctx = useContext(StdinContextKey);
+	if (!ctx) throw new Error("useStdin() must be called inside a solid-tui render tree");
+	return ctx;
+}
+//#endregion
+//#region src/hooks/useStdout.ts
+function useStdout() {
+	const ctx = useContext(AppContextKey);
+	if (!ctx) throw new Error("useStdout() must be called inside a solid-tui render tree");
+	return {
+		stdout: ctx.stdout,
+		write: (data) => ctx.writeToStdout(data)
+	};
+}
+//#endregion
+//#region src/hooks/useStderr.ts
+function useStderr() {
+	const ctx = useContext(AppContextKey);
+	if (!ctx) throw new Error("useStderr() must be called inside a solid-tui render tree");
+	return {
+		stderr: ctx.stderr,
+		write: (data) => ctx.writeToStderr(data)
+	};
+}
+//#endregion
+//#region src/hooks/useCursor.ts
+function useCursor() {
+	const ctx = useContext(AppContextKey);
+	if (!ctx) throw new Error("useCursor() must be called inside a solid-tui render tree");
+	const [position, setPosition] = createSignal(void 0);
+	createEffect(() => {
+		ctx.setCursorPosition(position());
+	});
+	onCleanup(() => {
+		ctx.setCursorPosition(void 0);
+	});
+	return { setCursorPosition: setPosition };
+}
+//#endregion
+//#region src/hooks/useIsScreenReaderEnabled.ts
+function useIsScreenReaderEnabled() {
+	const ctx = useContext(AppContextKey);
+	if (!ctx) throw new Error("useIsScreenReaderEnabled() must be called inside a solid-tui render tree");
+	return ctx.isScreenReaderEnabled;
+}
+//#endregion
+//#region src/hooks/useAnimation.ts
+const read = (value) => typeof value === "function" ? value() : value;
+function useAnimation(options = {}) {
+	const [frame, setFrame] = createSignal(0);
+	const [time, setTime] = createSignal(0);
+	const [delta, setDelta] = createSignal(0);
+	const scheduler = useContext(AnimationSchedulerKey) ?? createAnimationScheduler();
+	const renderThrottleMs = scheduler.renderThrottleMs;
+	let interval = normalizeInterval(read(options.interval ?? 100));
+	let handle;
+	let startTime = 0;
+	let lastRenderedTime = 0;
+	let nextRenderTime = 0;
+	function tick(now) {
+		if (renderThrottleMs > 0 && now < nextRenderTime) return;
+		setFrame(Math.floor((now - startTime) / interval));
+		setTime(now - startTime);
+		setDelta(now - lastRenderedTime);
+		lastRenderedTime = now;
+		nextRenderTime = now + renderThrottleMs;
+	}
+	function stop() {
+		handle?.unsubscribe();
+		handle = void 0;
+	}
+	function start() {
+		stop();
+		setFrame(0);
+		setTime(0);
+		setDelta(0);
+		handle = scheduler.subscribe(tick, interval);
+		startTime = handle.startTime;
+		lastRenderedTime = handle.startTime;
+		nextRenderTime = handle.startTime + renderThrottleMs;
+	}
+	function reset() {
+		if (handle) start();
+	}
+	createEffect((prev) => {
+		const active = read(options.isActive ?? true);
+		const nextInterval = normalizeInterval(read(options.interval ?? 100));
+		const intervalChanged = prev !== void 0 && nextInterval !== prev.interval;
+		const becameActive = prev === void 0 || !prev.active;
+		interval = nextInterval;
+		if (!active) {
+			stop();
+			return {
+				active,
+				interval
+			};
+		}
+		if (becameActive || intervalChanged) start();
+		return {
+			active,
+			interval
+		};
+	});
+	onCleanup(stop);
+	return {
+		frame,
+		time,
+		delta,
+		reset
+	};
+}
+//#endregion
+//#region src/hooks/useBoxMetrics.ts
+function resolveYogaNode(value) {
+	if (!value || typeof value !== "object") return null;
+	const obj = value;
+	if (obj.yoga) return obj;
+	return null;
+}
+function resolveTuiNode(value) {
+	if (!value || typeof value !== "object") return null;
+	const obj = value;
+	return typeof obj.type === "string" ? obj : null;
+}
+function findRootNode(node) {
+	let current = node;
+	while (current) {
+		if (current.type === "root") return current;
+		current = current.parent;
+	}
+	return null;
+}
+function measureElement(node) {
+	const tuiNode = resolveYogaNode(node);
+	if (!tuiNode) return {
+		width: 0,
+		height: 0
+	};
+	const width = tuiNode.yoga.getComputedWidth();
+	const height = tuiNode.yoga.getComputedHeight();
+	return {
+		width: Number.isFinite(width) ? width : 0,
+		height: Number.isFinite(height) ? height : 0
+	};
+}
+function useBoxMetrics(ref) {
+	const [width, setWidth] = createSignal(0);
+	const [height, setHeight] = createSignal(0);
+	const [left, setLeft] = createSignal(0);
+	const [top, setTop] = createSignal(0);
+	const [hasMeasured, setHasMeasured] = createSignal(false);
+	let unsubscribeLayout;
+	function updateMetrics() {
+		const node = resolveYogaNode(ref());
+		if (!node) {
+			setWidth(0);
+			setHeight(0);
+			setLeft(0);
+			setTop(0);
+			setHasMeasured(false);
+			return;
+		}
+		const w = node.yoga.getComputedWidth();
+		const h = node.yoga.getComputedHeight();
+		const l = node.yoga.getComputedLeft();
+		const t = node.yoga.getComputedTop();
+		setWidth(Number.isFinite(w) ? w : 0);
+		setHeight(Number.isFinite(h) ? h : 0);
+		setLeft(Number.isFinite(l) ? l : 0);
+		setTop(Number.isFinite(t) ? t : 0);
+		setHasMeasured(true);
+	}
+	createEffect(() => {
+		unsubscribeLayout?.();
+		unsubscribeLayout = void 0;
+		const root = findRootNode(resolveTuiNode(ref()));
+		if (root) {
+			unsubscribeLayout = addLayoutListener(root, updateMetrics);
+			updateMetrics();
+		} else updateMetrics();
+	});
+	onCleanup(() => unsubscribeLayout?.());
+	return {
+		width,
+		height,
+		left,
+		top,
+		hasMeasured
+	};
+}
+//#endregion
+export { Box, Newline, Spacer, Static, Text, Transform, batch, catchError, children, createApp, createComponent, createContext, createEffect, createElement, createMemo, createRenderEffect, createRoot, createSignal, createTextNode, effect, insert, insertNode, kittyFlags, kittyModifiers, measureElement, memo, mergeProps, on, onCleanup, renderToString, setProp, splitProps, spread, untrack, use, useAnimation, useApp, useBoxMetrics, useContext, useCursor, useFocus, useFocusManager, useInput, useIsScreenReaderEnabled, usePaste, useStderr, useStdin, useStdout, useWindowSize };