@zaly/tui 0.0.4

package/dist/queries-DH3bj74K.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries-DH3bj74K.d.mts","names":[],"sources":["../src/input/keys.ts","../src/input/decoder.ts","../src/input/actions.ts","../src/layout/size.ts","../src/core/reactive.ts","../src/core/state.ts","../src/layout/border.ts","../src/widgets/text.ts","../src/widgets/box.ts","../src/widgets/overlay.ts","../src/core/ctx.ts","../src/widgets/log.ts","../src/services/logger.ts","../src/renderer/terminal.ts","../src/renderer/frame.ts","../src/renderer/surface.ts","../src/renderer/overlay.ts","../src/renderer/selection.ts","../src/renderer/stream.ts","../src/renderer/ui.ts","../src/renderer/renderer.ts","../src/core/node.ts","../src/input/router.ts","../src/input/queries.ts"],"mappings":"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"}

package/dist/reactive-f7NpAi69.mjs

@@ -0,0 +1,623 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/core/reactive.ts
+const activeCtx = new AsyncLocalStorage();
+function withTracking(ctx, fn) {
+	return activeCtx.run(ctx, fn);
+}
+/** Run `fn` outside any tracking scope. Signal reads inside don't
+*  subscribe the surrounding render, and async work started inside
+*  (timers, promises, intervals) doesn't capture the current ctx —
+*  callbacks fire with `getStore() === undefined`.
+*
+*  Use this when starting persistent async work from inside a render
+*  pass: a `setInterval` set up during `_render` would otherwise
+*  inherit the render's ALS context, and every timer tick would look
+*  like it's "inside" that render — its invalidates would be silently
+*  suppressed.
+*
+*  ```ts
+*  // inside _render() or a render-driven reconcile():
+*  untracked(() => {
+*    this.#timer = setInterval(() => this.invalidate(), speed)
+*  })
+*  ```
+*
+*  Equivalent to Solid's `untrack`. */
+function untrack(fn) {
+	return activeCtx.run(void 0, fn);
+}
+/** Resolve a `Reactive<T>` to its current `T` without subscribing to
+* any tracking context. */
+function peek(s) {
+	return untrack(() => unwrap(s));
+}
+function createContext(defaultValue) {
+	return {
+		defaultValue,
+		id: Symbol("@zaly/tui/context")
+	};
+}
+/** Publish `value` for `ctx` on the active Owner. Persistent for the
+*  Owner's lifetime. Descendants (in the render-call sense) that read
+*  via `useContext` walk up the Owner chain and find it. */
+function provideContext(ctx, value) {
+	const owner = activeOwnerStore.getStore();
+	if (owner === void 0) throw new Error("provideContext: no active Owner — call from a widget body / _render");
+	owner.setContext(ctx.id, value);
+}
+/** Read the current value of `ctx`. Walks the Owner chain
+*  (render-call ancestry, not mount tree). Returns the context's
+*  default when no ancestor has provided a value. */
+function useContext(ctx) {
+	for (let o = activeOwnerStore.getStore(); o !== void 0; o = o.parent) {
+		const map = o.contexts;
+		if (map?.has(ctx.id)) return map.get(ctx.id);
+	}
+	return ctx.defaultValue;
+}
+/** Brand tag: every accessor / setter returned by `signal` / `memo`
+*  carries this symbol so `unwrap` can tell a reactive source from a
+*  plain function-valued prop (label formatter, text callback, etc.). */
+const REACTIVE = Symbol.for("@zaly/tui/reactive");
+/** Runtime check: `true` when `v` was produced by `signal` / `memo`.
+*  False for plain callables (text-content functions, label formatters).
+*
+*  @internal */
+function isAccessor(v) {
+	return typeof v === "function" && v[REACTIVE] === "get";
+}
+/** Resolve a `Reactive<T>` to its current `T`. Call inside `_render`
+*  so accessor reads subscribe the rendering node. Only brand-tagged
+*  accessors are invoked — other function values pass through
+*  untouched, so widgets whose `T` is itself a function type (label
+*  formatters etc.) don't need a hand-rolled guard. */
+function unwrap(v) {
+	return isAccessor(v) ? v() : v;
+}
+function brand(fn, tag) {
+	Object.defineProperty(fn, REACTIVE, {
+		configurable: false,
+		enumerable: false,
+		value: tag,
+		writable: false
+	});
+	return fn;
+}
+/**
+* Reactive ownership scope — bundles cleanups + provided contexts
+* scoped to a single widget body (or a `createRoot` headless scope).
+*
+* Owners form a chain via `parent` mirroring the call-time widget
+* nesting: when `widget()` is invoked inside another widget's body,
+* `createNode` creates the inner Owner with `parent =
+* activeOwnerStore.getStore()` (the outer widget's Owner). That chain
+* is what `useContext` walks.
+*
+* Owners are **not** bound to Nodes anymore — a widget's `createNode`
+* pairs the Owner with the constructed Node only through
+* `Node.once("unmount", () => owner.dispose())`. Primitive Nodes
+* (`text`, `box`, …) don't get their own Owner; they share whatever
+* Owner created them.
+*
+* Use `onCleanup(cb)` to register cleanups against the active Owner.
+* Disposing the Owner runs them in reverse-registration order.
+*
+* @internal
+*/
+var Owner = class {
+	parent;
+	#cleanups = [];
+	#contexts;
+	#disposed = false;
+	constructor(parent) {
+		this.parent = parent;
+	}
+	get disposed() {
+		return this.#disposed;
+	}
+	/** Live view of this Owner's provided contexts. Populated by
+	*  `provideContext`. Walked upward via `parent` by `useContext`. */
+	get contexts() {
+		return this.#contexts;
+	}
+	setContext(id, value) {
+		(this.#contexts ??= /* @__PURE__ */ new Map()).set(id, value);
+	}
+	/** Register a cleanup. Runs on `dispose()`. */
+	addCleanup(fn) {
+		if (this.#disposed) {
+			fn();
+			return;
+		}
+		this.#cleanups.push(fn);
+	}
+	/** Fire cleanups in reverse-registration order. Idempotent. */
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		for (let i = this.#cleanups.length - 1; i >= 0; i--) try {
+			this.#cleanups[i]();
+		} catch (error) {
+			console.error("Owner cleanup threw:", error);
+		}
+		this.#cleanups = [];
+		this.#contexts = void 0;
+	}
+};
+const activeOwnerStore = new AsyncLocalStorage();
+/** Run `fn` as the `node`'s render pass. Signal reads inside subscribe
+*  the node's tracking ctx; the ctx's `notify` is `node.invalidate`,
+*  so any signal write that this render depended on invalidates the
+*  node and clears its cache. Cleanups are registered against the
+*  Node's `unmount` event.
+*
+*  Does **not** push an Owner — primitive Nodes share whatever Owner
+*  was active in their caller. Widget bodies install their own Owner
+*  via `createNode` at construction time, which is when `useContext`
+*  / `provideContext` / `effect` / `memo` care about the active scope.
+*
+*  @internal */
+function withActiveNode(node, fn) {
+	return withTracking(getNodeTrackingCtx(node), fn);
+}
+/** Run `fn` with a pre-existing Owner restored. Used by `effect` /
+*  `memo` to re-establish their creation-time owner chain on re-fire,
+*  so `useContext` walks the same ancestry regardless of whether the
+*  re-fire was triggered from inside or outside a render.
+*
+*  @internal */
+function withOwner(owner, fn) {
+	return activeOwnerStore.run(owner, fn);
+}
+function getNodeTrackingCtx(node) {
+	let ctx = nodeCtx.get(node);
+	if (ctx === void 0) {
+		ctx = {
+			notify: () => node.invalidate(),
+			register: (cleanup) => {
+				node.once("unmount", cleanup);
+			}
+		};
+		nodeCtx.set(node, ctx);
+	}
+	return ctx;
+}
+/** Create a fresh Owner scope and run `fn` inside it. Returns
+*  whatever `fn` returns. The Owner's parent is whatever was active at
+*  the call site (or `undefined` at module top).
+*
+*  The Owner is *not* auto-disposed — callers manage its lifetime via
+*  the Owner returned alongside the result, or (more commonly) by
+*  binding the Owner to a Node and disposing it on that Node's
+*  unmount.
+*
+*  Typical use is via a surface's function-shape `add(fn)` API which
+*  wraps this internally:
+*
+*  ```ts
+*  ui.add(() => {
+*    const [count, setCount] = signal(0)
+*    onCleanup(() => console.log("gone"))
+*    return text(() => `count: ${count()}`)
+*  })
+*  ```
+*
+*  For headless reactive scopes (tests, programmatic effects), call
+*  `createRoot` directly:
+*
+*  ```ts
+*  const { result, owner } = createRoot(() => signal(0))
+*  // ... use result ...
+*  owner.dispose()
+*  ```
+*/
+function createRoot(fn) {
+	const owner = new Owner(activeOwnerStore.getStore());
+	return withOwner(owner, () => fn(() => owner.dispose()));
+}
+/** Run `fn` inside a fresh Owner scope and bind the returned Node to
+*  that scope — when the Node unmounts, the Owner disposes (firing
+*  every `onCleanup`, tearing down every `effect` / `memo` /
+*  `createAsync` registered in the body).
+*
+*  This is what `widget()` calls under the hood: it's the per-instance
+*  scope boundary. Surfaces also call it directly at their `add` /
+*  `append` entry points so each appended subtree gets its own root.
+*
+*  ```ts
+*  ui.add(() => {
+*    const [c, setC] = signal(0)
+*    onCleanup(() => clearInterval(timer))
+*    const timer = setInterval(() => setC(x => x + 1), 1000)
+*    return text(() => `count: ${c()}`)
+*  })
+*  ```
+*/
+function createNode(fn) {
+	return createRoot((dispose) => fn().once("unmount", dispose));
+}
+/** Register a cleanup against the active Owner. Fires when the Owner
+*  disposes — i.e. when the widget body's `createNode` Node unmounts,
+*  or when the surrounding `createRoot` is disposed.
+*
+*  ```ts
+*  function widgetBody() {
+*    const id = setInterval(() => tick(), 1000)
+*    onCleanup(() => clearInterval(id))
+*    return box(…)
+*  }
+*  ```
+*
+*  Throws if called outside any active Owner — the cleanup would
+*  never fire and the caller is almost certainly mistaken. */
+function onCleanup(fn) {
+	const owner = activeOwnerStore.getStore();
+	if (owner === void 0) throw new Error("onCleanup: no active Owner — call from inside a widget body / createRoot");
+	owner.addCleanup(fn);
+}
+/** Current Owner, or `undefined` outside any render. Captured by
+*  effects/memos at creation time and restored on re-fire.
+*
+*  @internal */
+function useActiveOwner() {
+	return activeOwnerStore.getStore();
+}
+/** Whether we're currently executing inside `node`'s own render call
+*  stack — i.e. this code path was reached synchronously (or via an
+*  await preserved by `AsyncLocalStorage`) from `node`'s `withActiveNode`.
+*
+*  Used by `invalidate()` to suppress *internal* cascades — e.g.
+*  Markdown mutating its child Text inside its own `_render`. External
+*  mutations (network callbacks, event handlers) run outside any
+*  render's ALS scope, so this returns `false` for them and they emit
+*  normally even when a render is in flight.
+*
+*  @internal */
+function inRenderContextOf(node) {
+	const active = activeCtx.getStore();
+	return active !== void 0 && active === nodeCtx.get(node);
+}
+const nodeCtx = /* @__PURE__ */ new WeakMap();
+/**
+* Reactive value. Returns a `[get, set]` tuple that's also accessible
+* as `.get` / `.set` for destructure-skipping callers. Reads inside a
+* tracking context (node render, effect, memo) auto-subscribe; writes
+* notify every subscriber synchronously.
+*
+* ```ts
+* const [count, setCount] = signal(0)
+* setCount(1)               // value form
+* setCount((prev) => prev + 1)  // updater form
+* ```
+*
+* **Storing a function as a value — gotcha**: `set` interprets any
+* function argument as the *updater* form `(prev) => next`, calls it
+* with the current value, and stores the result. To store a function
+* value (e.g. a callable `StyleBuilder` or a handler ref), wrap with
+* the updater form so the call resolves to the function you wanted:
+*
+* ```ts
+* const [style, setStyle] = signal<StyleBuilder | undefined>(undefined)
+* setStyle(ctx.style)         // ✗ stored as `ctx.style(undefined)` — a string
+* setStyle(() => ctx.style)   // ✓ stored as the StyleBuilder itself
+* ```
+*
+* Same trap exists in Solid and React's `useState`. If you find
+* yourself reaching for it, also consider whether storing a *plain*
+* value (the underlying data, not the chain/builder) and recomputing
+* the function-y derivative inside a `memo` is cleaner — usually it
+* is.
+*
+* Equality is reference-based: `set(v)` where `v === current` skips
+* the notify. Wrap mutable values you want to "publish" in a fresh
+* object/array, or use a counter signal to force fan-out.
+*/
+function signal(initial, opts = {}) {
+	let value = initial;
+	const subs = /* @__PURE__ */ new Set();
+	const equals = opts.equals === false ? () => false : opts.equals ?? ((a, b) => a === b);
+	const get = brand(() => {
+		const ctx = activeCtx.getStore();
+		if (ctx && !subs.has(ctx.notify)) {
+			subs.add(ctx.notify);
+			ctx.register(() => subs.delete(ctx.notify));
+		}
+		return value;
+	}, "get");
+	const set = brand((next) => {
+		const resolved = typeof next === "function" ? next(value) : next;
+		if (equals(value, resolved)) return;
+		value = resolved;
+		const snapshot = [...subs];
+		for (const notify of snapshot) notify();
+	}, "set");
+	return Object.assign([get, set], {
+		get,
+		set
+	});
+}
+/**
+* Lift a plain value to an `Accessor<T>`. The returned function always
+* returns `value`, never tracks, never notifies — useful at the boundary
+* where a static value enters a tree that otherwise expects `Accessor<T>`.
+*
+* Branded so `isAccessor` reports `true` and downstream `unwrap` calls
+* resolve to a stable function call rather than treating the value as
+* a ctx-aware thunk.
+*
+* ```ts
+* // Component expects `Accessor<Theme>` deep in the tree:
+* <CodeBlock theme={toAccessor(myStaticTheme)} />
+* ```
+*/
+function toAccessor(fn) {
+	return brand(() => fn(), "get");
+}
+/**
+* Run `fn` immediately, then re-run whenever a signal it read writes.
+* Returns a disposer that stops the effect and drops all tracked
+* subscriptions. Unlike node render, effect dependencies are re-tracked
+* from scratch on every run — reads that disappear from `fn` stop
+* triggering re-runs.
+*
+* ```ts
+* const dispose = effect(() => {
+*   console.log("status is", status())
+* })
+* // ...
+* dispose()
+* ```
+*
+* **Footgun**: don't write a signal from inside an effect that reads
+* the same signal — you'll loop. Writing unrelated signals is fine.
+*/
+function effect(fn) {
+	let cleanups = [];
+	let disposed = false;
+	const owner = useActiveOwner();
+	const ctx = {
+		notify: () => {
+			if (disposed) return;
+			run();
+		},
+		register: (cleanup) => {
+			cleanups.push(cleanup);
+		}
+	};
+	const run = () => {
+		const old = cleanups;
+		cleanups = [];
+		for (const c of old) c();
+		const tracked = () => withTracking(ctx, fn);
+		const cleanup = owner !== void 0 ? withOwner(owner, tracked) : tracked();
+		if (typeof cleanup === "function") cleanups.push(cleanup);
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		for (const c of cleanups) c();
+		cleanups = [];
+	};
+	owner?.addCleanup(dispose);
+	run();
+	return dispose;
+}
+/**
+* Derived, cached signal. `fn` runs once eagerly; the cached value is
+* returned from the accessor. When any signal `fn` reads writes, the
+* memo recomputes and notifies its own subscribers — but only if the
+* new value differs from the cached one (reference equality).
+*
+* ```ts
+* const [value, setValue] = signal(0)
+* const pct = memo(() => Math.round(value() * 100))
+* text(({ style }) => `${pct()}%`)   // subscribes to pct, not value
+* ```
+*
+* Returns an `Accessor<T>`, not a `[read, write]` tuple — memos are
+* read-only by construction.
+*/
+function memo(fn) {
+	const [get, set] = signal(void 0);
+	effect(() => {
+		set(() => fn());
+	});
+	return get;
+}
+function createStore(initial) {
+	const state = { ...initial };
+	const sigs = {};
+	const ensure = (key) => sigs[key] ??= signal(state[key]);
+	const setKey = (key, value) => {
+		if (state[key] === value) return;
+		state[key] = value;
+		sigs[key]?.set(() => value);
+	};
+	const set = (patch) => {
+		const p = typeof patch === "function" ? patch(state) : patch;
+		for (const k of Object.keys(p)) {
+			const v = p[k];
+			setKey(k, v);
+		}
+	};
+	return new Proxy({}, {
+		get(_, key) {
+			if (key === "set") return set;
+			return ensure(key).get();
+		},
+		getOwnPropertyDescriptor(_, key) {
+			if (!Object.hasOwn(state, key)) return void 0;
+			return {
+				configurable: true,
+				enumerable: true,
+				value: state[key]
+			};
+		},
+		has(_, key) {
+			return key === "set" || key in state;
+		},
+		ownKeys() {
+			return Reflect.ownKeys(state);
+		},
+		set(_, key, value) {
+			setKey(key, value);
+			return true;
+		}
+	});
+}
+/** Nearest Suspense provider in the Owner chain. `undefined` when no
+*  boundary is installed — `createAsync` runs fire-and-forget in that
+*  case (signal resolves later, normal invalidation re-renders). */
+const SuspenseContext = createContext(void 0);
+/**
+* Build a boundary whose count flips propagate to `parent` on the 0→1
+* and 1→0 transitions. Used by Stream's `append` and the `suspense()`
+* widget. Internal-ish — most callers shouldn't construct boundaries
+* directly.
+*
+* @internal
+*/
+function createSuspenseBoundary(parent) {
+	let count = 0;
+	let idle;
+	return {
+		active: () => count > 0,
+		decrement: () => {
+			if (count === 0) return;
+			count--;
+			if (count === 0) {
+				parent?.decrement();
+				idle?.resolve();
+				idle = void 0;
+			}
+		},
+		increment: () => {
+			count++;
+			if (count === 1) parent?.increment();
+		},
+		whenIdle: () => {
+			if (count === 0) return Promise.resolve();
+			if (idle === void 0) {
+				const { promise, resolve } = Promise.withResolvers();
+				idle = {
+					promise,
+					resolve
+				};
+			}
+			return idle.promise;
+		}
+	};
+}
+function createAsync(fn, opts) {
+	const [value, setValue] = signal(opts?.initialValue);
+	const suspense = useContext(SuspenseContext);
+	let gen = 0;
+	effect(() => {
+		const my = ++gen;
+		let p;
+		try {
+			p = fn(untrack(value));
+		} catch (error) {
+			p = Promise.reject(error);
+		}
+		suspense?.increment();
+		p.then((v) => {
+			if (my === gen) setValue(() => v);
+		}, () => {}).finally(() => suspense?.decrement());
+	});
+	return value;
+}
+function createProgressive(fn, opts = {}) {
+	const throttle = opts.throttle ?? 16;
+	const [loading, setLoading] = signal(true);
+	const [state, setState] = signal(opts.initialValue, { equals: false });
+	const ret = Object.assign(state, {
+		get loading() {
+			return loading;
+		},
+		whenIdle: () => {
+			if (!loading()) return Promise.resolve();
+			idle ??= Promise.withResolvers();
+			return idle.promise;
+		}
+	});
+	let gen = 0;
+	let idle;
+	effect(() => {
+		const my = ++gen;
+		const ac = new AbortController();
+		(async () => {
+			try {
+				setLoading(true);
+				let prev = 0;
+				const result = await fn({
+					set: (value) => {
+						if (ac.signal.aborted || my !== gen) return;
+						const now = performance.now();
+						if (now - prev >= throttle) {
+							prev = now;
+							setState(() => value);
+						}
+					},
+					signal: ac.signal
+				});
+				if (my === gen) {
+					setState(() => result);
+					setLoading(false);
+					idle?.resolve();
+					idle = void 0;
+				}
+			} catch (error) {
+				if (my === gen) {
+					setLoading(false);
+					idle?.reject(error);
+					idle = void 0;
+				}
+			} finally {
+				ac.abort();
+			}
+		})();
+		return () => {
+			ac.abort();
+		};
+	});
+	return ret;
+}
+function createIterable(fn, opts = {}) {
+	return createProgressive(async ({ signal: s, set }) => {
+		const results = [];
+		for await (const item of fn({ signal: s })) {
+			if (s.aborted) return results;
+			results.push(...Array.isArray(item) ? item : [item]);
+			set(results);
+		}
+		return results;
+	}, {
+		...opts,
+		initialValue: opts.initialValue ?? []
+	});
+}
+function createRef(value, opts = {}) {
+	let current = value;
+	let cleanup;
+	const get = () => {
+		if (current === void 0) throw new Error("Ref value accessed before initialization");
+		return current;
+	};
+	Object.defineProperty(get, "value", {
+		get: () => current,
+		set: (v) => {
+			if (current === v) return;
+			cleanup?.();
+			cleanup = void 0;
+			const prev = current;
+			current = v;
+			cleanup = opts.onSet?.(v, prev) ?? void 0;
+		}
+	});
+	return get;
+}
+//#endregion
+export { useActiveOwner as C, withOwner as E, unwrap as S, withActiveNode as T, peek as _, createIterable as a, toAccessor as b, createRef as c, createSuspenseBoundary as d, effect as f, onCleanup as g, memo as h, createContext as i, createRoot as l, isAccessor as m, SuspenseContext as n, createNode as o, inRenderContextOf as p, createAsync as r, createProgressive as s, Owner as t, createStore as u, provideContext as v, useContext as w, untrack as x, signal as y };
+
+//# sourceMappingURL=reactive-f7NpAi69.mjs.map