@textui/core 0.1.0

package/dist/render/static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../src/render/static.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAwB,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC1F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAoBrC;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACnC,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,OAAO,IAAI,IAAI,CAAC;CACjB;AAaD,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,mBAAwB,GAAG;IACtE,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,OAAO,IAAI,IAAI,CAAC;CACjB,CA0EA;AAYD,wBAAgB,UAAU,CACxB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,mBAAwB,GAChC,kBAAkB,CA2EpB;AAED,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAO7F"}

package/dist/render/static.js

@@ -0,0 +1,209 @@
+import { Buffer } from './buffer.js';
+import { layout, resolveEdges } from './layout.js';
+import { buildBoxes, paintTree } from '../runtime/paint.js';
+import { collectEffects, disposeTree, renderTree } from '../runtime/reconcile.js';
+import { flushMeasures } from '../runtime/hooks.js';
+import { NO_INTERACTION } from '../runtime/style.js';
+import { createStore } from '../core/store.js';
+import { createEvents } from '../core/events.js';
+import { createWhen } from '../core/when.js';
+import { createComponents } from '../core/components.js';
+import { createServices } from '../core/services.js';
+import { createFocus } from '../core/focus.js';
+import { createLayers } from '../core/layers.js';
+import { createAnimation } from '../core/animation.js';
+import { createI18n } from '../core/i18n.js';
+import { createThemes } from '../themes/registry.js';
+import { PRIMITIVES } from '../ui/primitives.js';
+import { FULL_CAPABILITIES } from '../types/capabilities.js';
+import { ZERO_EDGES } from '../types/geometry.js';
+const DEFAULT_CAPABILITIES = {
+    ...FULL_CAPABILITIES,
+    mouse: false,
+    wheel: false,
+    focusEvents: false,
+    paste: false,
+    altScreen: false,
+    synchronizedOutput: false,
+    kittyKeyboard: false,
+};
+export function createStaticRuntime(options = {}) {
+    const store = createStore();
+    const events = createEvents();
+    const when = createWhen(store);
+    const components = createComponents();
+    const services = createServices();
+    const focus = createFocus();
+    const layers = createLayers();
+    const animation = createAnimation({ manual: true, enabled: false });
+    const i18n = createI18n(options.locale ?? 'en');
+    const themes = createThemes(options.themes);
+    // The four primitives, and nothing else by default.
+    //
+    // This registered the whole catalog until it didn't: some eighty entries a
+    // screen made of `box` and `text` never looked at, and that JSX never
+    // needed either, since an imported component travels on its own node.
+    // Naming a component in data is the case a registry is for, and that case
+    // asks for it through `components`.
+    components.registerMany(PRIMITIVES);
+    if (options.components)
+        components.registerMany(options.components);
+    const capabilities = {
+        ...DEFAULT_CAPABILITIES,
+        ...options.capabilities,
+    };
+    let size = { width: options.width ?? 80, height: 24 };
+    const onError = options.onError ?? ((err, context) => {
+        console.error(`[textui] ${context}`, err);
+    });
+    store.onError = onError;
+    events.onError = onError;
+    if (options.initialState) {
+        store.batch(() => {
+            for (const [path, value] of Object.entries(options.initialState)) {
+                store.set((path.startsWith('$/') ? path : `$/${path}`), value);
+            }
+        });
+    }
+    store.set('$/modus/capabilities', capabilities);
+    store.set('$/modus/size', size);
+    const runtime = {
+        store, events, when, components, services, focus, layers, animation, i18n,
+        theme: () => themes.resolve(options.theme ?? 'dark', capabilities),
+        capabilities: () => capabilities,
+        size: () => size,
+        execute: (id) => {
+            throw new Error(`[textui] command "${id}" cannot run under the static renderer`);
+        },
+        emit: (path, payload) => events.emit(path, payload),
+        requestRender: () => { },
+        app: () => null,
+        onError,
+    };
+    return {
+        runtime,
+        setSize(width, height) {
+            size = { width, height };
+            store.set('$/modus/size', size);
+        },
+        dispose() {
+            animation.dispose();
+            layers.dispose();
+            events.dispose();
+            store.dispose();
+        },
+    };
+}
+function rootBoxFor(children) {
+    return {
+        style: { direction: 'column' },
+        borderEdges: ZERO_EDGES,
+        children,
+        rect: { x: 0, y: 0, width: 0, height: 0 },
+        content: { x: 0, y: 0, width: 0, height: 0 },
+    };
+}
+export function renderOnce(node, options = {}) {
+    const width = options.width ?? 80;
+    const { runtime, setSize, dispose: disposeRuntime } = createStaticRuntime(options);
+    // Measure against a generous height first when the caller wants `auto`, so
+    // nothing is clipped before we know how tall the content actually is.
+    const measureHeight = options.height === 'auto' || options.height === undefined
+        ? 4096
+        : options.height;
+    setSize(width, measureHeight);
+    const env = {
+        theme: runtime.theme(),
+        capabilities: runtime.capabilities(),
+        stateOf: () => NO_INTERACTION,
+    };
+    let root = null;
+    const maxPasses = options.maxPasses ?? 8;
+    for (let pass = 0; pass < maxPasses; pass++) {
+        root = renderTree(runtime, root, node);
+        const effects = collectEffects(root);
+        if (effects.length === 0)
+            break;
+        for (const effect of effects)
+            effect();
+        if (!hasDirty(root))
+            break;
+    }
+    let instance = root;
+    let boxes = buildBoxes(instance, env);
+    let rootBox = rootBoxFor(boxes);
+    layout(rootBox, { x: 0, y: 0, width, height: measureHeight });
+    // A measured component only knows its size once it has been laid out. Give
+    // it that, then render again - otherwise the static renderer is the one
+    // place where a viewport draws nothing.
+    for (let pass = 0; pass < maxPasses && flushMeasures(); pass++) {
+        instance = renderTree(runtime, instance, node);
+        for (const effect of collectEffects(instance))
+            effect();
+        boxes = buildBoxes(instance, env);
+        rootBox = rootBoxFor(boxes);
+        layout(rootBox, { x: 0, y: 0, width, height: measureHeight });
+    }
+    const used = contentHeight(rootBox);
+    const height = options.height === 'auto' || options.height === undefined
+        ? Math.max(1, used)
+        : options.height;
+    // Lay out again at the real height so `flex` and `justify` see the truth.
+    if (height !== measureHeight) {
+        setSize(width, height);
+        layout(rootBox, { x: 0, y: 0, width, height });
+        for (let pass = 0; pass < maxPasses && flushMeasures(); pass++) {
+            instance = renderTree(runtime, instance, node);
+            for (const effect of collectEffects(instance))
+                effect();
+            rootBox = rootBoxFor(buildBoxes(instance, env));
+            layout(rootBox, { x: 0, y: 0, width, height });
+        }
+    }
+    const buffer = new Buffer(width, height);
+    paintTree(buffer, instance, env, { x: 0, y: 0, width, height });
+    return {
+        buffer,
+        text: buffer.toText(),
+        root: instance,
+        runtime,
+        dispose() {
+            disposeTree(instance);
+            disposeRuntime();
+        },
+    };
+}
+/** Render to plain text. The shortest path from a component to a string. */
+export function renderToString(node, options = {}) {
+    const result = renderOnce(node, options);
+    try {
+        return result.text;
+    }
+    finally {
+        result.dispose();
+    }
+}
+function contentHeight(box) {
+    let bottom = 0;
+    const walk = (b) => {
+        if (b.rect.width > 0 && b.rect.height > 0) {
+            // Plus the margin below it, which is space the box needs even though
+            // nothing paints there. Measuring to the bottom edge alone reports a
+            // height the layout cannot reproduce: laid out again inside it, the
+            // margin has to come out of the box, and the box loses the rows.
+            // `<box margin={2} border="single">` measured 5 and then drew one row
+            // of a three-row box.
+            bottom = Math.max(bottom, b.rect.y + b.rect.height + resolveEdges(b.style.margin).bottom);
+        }
+        for (const child of b.children)
+            walk(child);
+    };
+    for (const child of box.children)
+        walk(child);
+    return bottom;
+}
+function hasDirty(instance) {
+    if (instance.dirty)
+        return true;
+    return instance.children.some(hasDirty);
+}

package/dist/runtime/bindings.d.ts

@@ -0,0 +1,46 @@
+import type { Action, BindingPath, ComponentNode } from '../types/graph.js';
+import type { ReactiveStore } from '../types/store.js';
+/**
+ * Prop values arrive as literals, bindings (`{ path }`) or function calls
+ * (`{ call }`). Resolving them is what makes a node written as data behave
+ * exactly like one written in JSX.
+ *
+ * Every path read during a resolve is recorded, so the caller can subscribe to
+ * precisely the paths this subtree depends on and re-render on nothing else.
+ */
+export interface ResolveContext {
+    store: ReactiveStore;
+    /** Relative paths resolve against this. */
+    dataContext?: BindingPath;
+    /** Run a registered command. */
+    execute(id: string, args?: Record<string, unknown>): unknown;
+    /** Publish on an event path. */
+    emit(path: string, payload?: unknown): void;
+    /** Collected during the resolve; the caller subscribes to these. */
+    reads: Set<string>;
+}
+/**
+ * Turn an action into something callable. Actions stay data right up to the
+ * moment they are invoked, which is what lets the same button work whether it
+ * was written in JSX with a closure or loaded from JSON naming a command.
+ */
+export declare function resolveAction(ctx: ResolveContext, action: Action | ((...args: unknown[]) => unknown) | undefined): ((...args: unknown[]) => unknown) | undefined;
+/** Resolve one prop value, leaving nodes and closures alone. */
+export declare function resolveValue(ctx: ResolveContext, value: unknown): unknown;
+/**
+ * Resolve every prop on a node. `component`, `id`, `key` and `$meta` are
+ * structural and pass through untouched.
+ *
+ * A prop named `onSomething` whose value is an action becomes a callable, so a
+ * node loaded from JSON can say `{ onPress: { functionCall: { call: 'x' } } }`
+ * and the component receives the same shape it would get from JSX. Without
+ * this, actions-as-data would only work on the handful of props the runtime
+ * knew about by name.
+ */
+export declare function resolveProps(ctx: ResolveContext, node: ComponentNode): Record<string, unknown>;
+/** True when the value is a templated child list: one instance per item. */
+export declare function isTemplateChildren(v: unknown): v is {
+    template: ComponentNode;
+    path: BindingPath;
+};
+//# sourceMappingURL=bindings.d.ts.map

package/dist/runtime/bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../src/runtime/bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAAE,WAAW,EAAE,aAAa,EACnC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvD;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,2CAA2C;IAC3C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,gCAAgC;IAChC,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC7D,gCAAgC;IAChC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5C,oEAAoE;IACpE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACpB;AAsCD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS,GAC7D,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,GAAG,SAAS,CAW/C;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAkBzE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,aAAa,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAezB;AAOD,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,OAAO,GACT,CAAC,IAAI;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAMrD"}

package/dist/runtime/bindings.js

@@ -0,0 +1,116 @@
+import { isAction, isComponentNode, isDataBinding, isFunctionCall } from '../types/graph.js';
+import { resolvePath } from '../util/paths.js';
+/** `#/a/b` means: the value AT this path is itself a path. One extra hop. */
+function readPath(ctx, raw) {
+    let path = raw;
+    // `{{ /other/path }}` substitutes another path's value into this one first.
+    if (path.includes('{{')) {
+        path = path.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_m, inner) => {
+            const resolved = resolvePath(inner.trim(), ctx.dataContext);
+            ctx.reads.add(resolved);
+            return String(ctx.store.get(resolved) ?? '');
+        });
+    }
+    if (path.startsWith('#/')) {
+        const indirect = resolvePath(path.slice(1), ctx.dataContext);
+        ctx.reads.add(indirect);
+        const target = ctx.store.get(indirect);
+        if (typeof target !== 'string')
+            return undefined;
+        const final = resolvePath(target, ctx.dataContext);
+        ctx.reads.add(final);
+        return ctx.store.get(final);
+    }
+    const resolved = resolvePath(path, ctx.dataContext);
+    ctx.reads.add(resolved);
+    return ctx.store.get(resolved);
+}
+function resolveCall(ctx, call) {
+    const args = {};
+    for (const [k, v] of Object.entries(call.args ?? {})) {
+        args[k] = resolveValue(ctx, v);
+    }
+    return ctx.execute(call.call, args);
+}
+/**
+ * Turn an action into something callable. Actions stay data right up to the
+ * moment they are invoked, which is what lets the same button work whether it
+ * was written in JSX with a closure or loaded from JSON naming a command.
+ */
+export function resolveAction(ctx, action) {
+    if (action === undefined)
+        return undefined;
+    if (typeof action === 'function')
+        return action;
+    if ('handler' in action)
+        return action.handler;
+    if ('functionCall' in action) {
+        return () => resolveCall(ctx, action.functionCall);
+    }
+    if ('emit' in action) {
+        return () => ctx.emit(action.emit.path, resolveValue(ctx, action.emit.payload));
+    }
+    return undefined;
+}
+/** Resolve one prop value, leaving nodes and closures alone. */
+export function resolveValue(ctx, value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value !== 'object')
+        return value;
+    if (typeof value === 'function')
+        return value;
+    if (isDataBinding(value))
+        return readPath(ctx, value.path);
+    if (isFunctionCall(value))
+        return resolveCall(ctx, value);
+    // Nodes and templated child lists stay as they are; the reconciler owns them.
+    if (isComponentNode(value))
+        return value;
+    if (isAction(value))
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => resolveValue(ctx, v));
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        out[k] = resolveValue(ctx, v);
+    }
+    return out;
+}
+/**
+ * Resolve every prop on a node. `component`, `id`, `key` and `$meta` are
+ * structural and pass through untouched.
+ *
+ * A prop named `onSomething` whose value is an action becomes a callable, so a
+ * node loaded from JSON can say `{ onPress: { functionCall: { call: 'x' } } }`
+ * and the component receives the same shape it would get from JSX. Without
+ * this, actions-as-data would only work on the handful of props the runtime
+ * knew about by name.
+ */
+export function resolveProps(ctx, node) {
+    const out = {};
+    for (const [k, v] of Object.entries(node)) {
+        if (k === 'component' || k === '$meta' || k === 'key')
+            continue;
+        if (k === 'children') {
+            out.children = v;
+            continue;
+        }
+        if (isHandlerProp(k) && isAction(v)) {
+            out[k] = resolveAction(ctx, v);
+            continue;
+        }
+        out[k] = resolveValue(ctx, v);
+    }
+    return out;
+}
+/** `onPress`, `onSelect`, `onChange` - but not `once` or `only`. */
+function isHandlerProp(key) {
+    return key.length > 2 && key.startsWith('on') && key[2] === key[2]?.toUpperCase();
+}
+/** True when the value is a templated child list: one instance per item. */
+export function isTemplateChildren(v) {
+    return (typeof v === 'object' && v !== null &&
+        'template' in v && 'path' in v &&
+        isComponentNode(v.template));
+}

package/dist/runtime/hooks.d.ts

@@ -0,0 +1,284 @@
+import type { BindingPath, EventPath } from '../types/graph.js';
+import type { Disposable } from '../types/disposable.js';
+import type { ResolvedTheme } from '../types/theme.js';
+import type { TerminalCapabilities } from '../types/capabilities.js';
+import type { Rect, Size } from '../types/geometry.js';
+import type { ServiceKey } from '../types/services.js';
+import type { KeyEvent } from '../types/input.js';
+import type { CommandDefinition } from '../types/command.js';
+import type { FocusDirection } from '../types/focus.js';
+import type { TaskFn, TaskState } from '../types/async.js';
+import type { StreamSource } from '../types/stream.js';
+import type { TextUIApp } from '../types/app.js';
+import type { I18n } from '../types/i18n.js';
+import type { Navigator } from '../types/navigation.js';
+import type { Resource } from '../types/resource.js';
+import type { SyntaxQuery, SyntaxRegistry, SyntaxToken } from '../types/syntax.js';
+import type { RenderOutput } from '../types/render.js';
+import type { Instance } from './instance.js';
+import type { Runtime } from './runtime.js';
+export declare function setCurrentInstance(instance: Instance | null): void;
+export declare function currentInstance(): Instance;
+export declare function useRuntime(): Runtime;
+export type SetState<T> = (next: T | ((prev: T) => T)) => void;
+export declare function useState<T>(initial: T | (() => T)): [T, SetState<T>];
+export declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initial: S): [S, (action: A) => void];
+export declare function useRef<T>(initial: T): {
+    current: T;
+};
+export declare function useMemo<T>(factory: () => T, deps: unknown[]): T;
+export declare function useCallback<T extends (...args: never[]) => unknown>(fn: T, deps: unknown[]): T;
+/**
+ * Runs after the frame is painted. The returned function runs before the next
+ * run and on unmount - so a subscription set up here is torn down exactly once.
+ */
+export declare function useEffect(effect: () => void | (() => void), deps?: unknown[]): void;
+/** Same contract as `useEffect`, but flushed before the frame is painted. */
+export declare function useLayoutEffect(effect: () => void | (() => void), deps?: unknown[]): void;
+export interface Context<T> {
+    id: string;
+    defaultValue: T;
+    Provider: (props: {
+        value: T;
+        children?: unknown;
+    }) => RenderOutput;
+}
+export declare function createContext<T>(name: string, defaultValue: T): Context<T>;
+export declare function useContext<T>(context: Context<T>): T;
+/**
+ * Store-backed state, in the shape of `useState`.
+ *
+ * The second argument is an initial value, and it behaves like one: if the
+ * path is empty the first time a component asks for it, it is written. That is
+ * what makes the hook safe to read like state - every other reader of the same
+ * path sees the same thing, immediately, rather than each one privately
+ * imagining its own default.
+ *
+ * The store stays authoritative. Copying a value out into `useState` and
+ * editing the copy creates a second answer to a question the store already
+ * answers; this hook is the way to avoid needing to.
+ *
+ * For a reader that must not write - a component displaying a path that
+ * something else owns - use `useStoreValue`, whose second argument is a
+ * display fallback and nothing more.
+ */
+export declare function useStore<T = unknown>(path: BindingPath, initial?: T): [T | undefined, (value: T) => void];
+/**
+ * Read a store path without ever writing it.
+ *
+ * `fallback` is what this reader shows while the path is empty. It is not an
+ * initial value and it is not shared: another component reading the same path
+ * still sees nothing.
+ */
+export declare function useStoreValue<T = unknown>(path: BindingPath, fallback?: T): T | undefined;
+/** Subscribe to a whole subtree - a namespace, a collection, a scope. */
+export declare function useStoreSubtree<T = unknown>(path: BindingPath): T | undefined;
+export declare function useCollection<T = unknown>(path: BindingPath): import("../index.js").CollectionOps<T>;
+export declare function useEvent(path: EventPath, handler: (payload: unknown) => void, options?: {
+    subtree?: boolean;
+}): void;
+export declare function useEmit(): (path: EventPath, payload?: unknown) => void;
+export declare function useApp(): TextUIApp;
+export declare function useTheme(): ResolvedTheme;
+export declare function useCapabilities(): TerminalCapabilities;
+/** Terminal size, re-rendering on resize. */
+export declare function useSize(): Size;
+/**
+ * Adapt to the space this component was actually given, not to the terminal.
+ * A sidebar and the main area are different widths on the same screen.
+ */
+/**
+ * The content rect this component was last laid out into.
+ *
+ * A component that fills the space it is given cannot size itself from its
+ * content - a file viewer that renders one row per line makes every pane
+ * around it move when a different file is opened. Measuring inverts that: the
+ * layout decides the size, and the component renders exactly what fits.
+ *
+ * The value is the previous frame's, and asking for it schedules another pass
+ * when it changed, so the first frame after a resize is one frame behind and
+ * every frame after it is exact.
+ */
+export declare function useMeasure(): Rect;
+/**
+ * How big the content is, when it is bigger than the box holding it.
+ *
+ * `null` when everything fits. The layout has always recorded this - the
+ * comment where it does says "so a scroll container knows how far it can go" -
+ * but nothing read it, so no scroll container knew, and every one of them
+ * scrolled for ever past its own last line.
+ *
+ * Reported for the nearest *scroll container* at or below this component's own
+ * box - a viewport is a row holding the scrolling part beside a scrollbar, and
+ * the row is not the part that scrolls.
+ */
+export declare function useScrollExtent(): Size | null;
+/**
+ * Publish every watcher's laid-out rect. Returns true when one changed, which
+ * means the frame is not final and the caller should render again.
+ */
+export declare function flushMeasures(): boolean;
+export declare function useBreakpoint(width: number, breakpoints?: {
+    compact?: number;
+    minimal?: number;
+}): 'full' | 'compact' | 'minimal';
+export declare function useI18n(): I18n;
+export declare function useService<T>(key: ServiceKey<T>): T | undefined;
+export declare function useRequiredService<T>(key: ServiceKey<T>): T;
+export interface UseFocusOptions {
+    id?: string;
+    disabled?: boolean;
+    skipTab?: boolean;
+    autoFocus?: boolean;
+    order?: number;
+    scopeId?: string;
+    onFocus?(): void;
+    onBlur?(): void;
+}
+export interface FocusHandle {
+    id: string;
+    focused: boolean;
+    focus(): void;
+    blur(): void;
+    move(direction: FocusDirection): void;
+}
+/** The focus scope this instance sits inside, if any. */
+export declare function focusScopeOf(instance: Instance): string | undefined;
+export declare function useFocus(options?: UseFocusOptions): FocusHandle;
+/** A focus scope. Modals trap; a sidebar does not. */
+export declare function useFocusScope(options?: {
+    id?: string;
+    trap?: boolean;
+    restore?: boolean;
+    autoFocus?: boolean;
+    active?: boolean;
+}): string;
+/**
+ * Keyboard input. Scoped to focus by default - a handler that fires while
+ * something else is focused is nearly always a bug, so `global` has to be
+ * asked for.
+ */
+/**
+ * A key that is not this control's to take.
+ *
+ * A list handles `pagedown`, and `ctrl+pagedown` is an application saying
+ * "next file" over the top of it - one is navigation inside the control, the
+ * other is a chord aimed past it. A control that switches on `event.name`
+ * alone takes both, and the application's binding then works everywhere except
+ * in the pane a person is actually looking at.
+ */
+export declare function chorded(event: KeyEvent): boolean;
+export declare function useInput(handler: (event: KeyEvent) => boolean | void, options?: {
+    focusId?: string;
+    global?: boolean;
+    enabled?: boolean;
+}): void;
+/**
+ * The screen this is drawn inside: which one, and what it was given.
+ *
+ * Reads the published entry rather than props, so a control eight levels down
+ * can ask which task it is showing without every box between it and the screen
+ * forwarding an id it does not care about.
+ */
+/**
+ * Keys, by the name they are written under everywhere else.
+ *
+ * `useInput` hands you a `KeyEvent` and leaves you to compare its fields,
+ * which is four lines of `event.ctrl && event.name === 's'` per key and a bug
+ * the first time somebody forgets that shift is implied by an uppercase
+ * letter. The keybinding registry already had the answer - one canonical
+ * spelling per stroke - so this reads the same strings.
+ *
+ *     useKeymap({
+ *       '+': () => setCount((c) => c + 1),
+ *       '-': () => setCount((c) => c - 1),
+ *       space: () => setRunning((r) => !r),
+ *       'ctrl+s': save,
+ *     });
+ *
+ * Global by default, unlike `useInput`. A component that lists the keys it
+ * wants almost never also wants them to stop working the moment focus lands
+ * somewhere else - and the screens where that is wrong have a focusable to
+ * name, so they can say `{ global: false }` and mean it.
+ *
+ * A handler that returns nothing has handled the key. Return `false` to let
+ * it carry on to whatever is behind.
+ */
+export declare function useKeymap(map: Record<string, (event: KeyEvent) => boolean | void>, options?: {
+    focusId?: string;
+    global?: boolean;
+    enabled?: boolean;
+}): void;
+export declare function useScreen<P = Record<string, unknown>>(): {
+    id: string | null;
+    params: P;
+};
+/** The stack, for a component that moves between screens. */
+export declare function useNavigate(): Navigator;
+export declare function useCommand(def: Omit<CommandDefinition, 'scopeId'>, deps?: unknown[]): void;
+export declare function useExecute(): (id: string, args?: Record<string, unknown>) => unknown;
+export interface TaskHandle<T> extends TaskState<T> {
+    run(...args: unknown[]): Promise<T | undefined>;
+    cancel(): void;
+    reset(): void;
+}
+/**
+ * An async unit of work with a lifecycle a component can render: idle,
+ * running, success, error, cancelled - plus progress and cancellation.
+ */
+export declare function useTask<T>(fn: TaskFn<T>, deps?: unknown[]): TaskHandle<T>;
+/** A task that runs on mount and can be refreshed. */
+export declare function useResource<T>(fn: TaskFn<T>, deps?: unknown[]): TaskHandle<T> & {
+    refresh(): void;
+};
+/** Read a resource through the registry, by URI. */
+export declare function useResourceUri(uri: string | null): {
+    resource: Resource | null;
+    content: string | Uint8Array | null;
+    status: TaskState['status'];
+    error: unknown;
+    refresh(): void;
+};
+/** The highlighter registry, or undefined outside an application. */
+export declare function useSyntax(): SyntaxRegistry | undefined;
+/**
+ * Tokenise text for display, memoised on the text and the query.
+ *
+ * Nothing registered for this kind means one plain token per line, which is
+ * exactly what an uncoloured viewer wants - so a caller never branches on
+ * whether highlighting exists.
+ */
+export declare function useHighlight(text: string, query?: SyntaxQuery): SyntaxToken[][];
+export interface ClipboardHandle {
+    /** What is on the clipboard now. Reading it here means a menu row that
+     *  offers "Paste" redraws when there is something to paste. */
+    text: string;
+    read(): string;
+    write(text: string): void;
+}
+/**
+ * The clipboard, as a hook.
+ *
+ * `write` puts the text on the system clipboard as well, when the terminal
+ * can take it. Nothing reads the system clipboard back - see
+ * `core/clipboard.ts` for why - so a paste is whatever this application last
+ * copied, plus whatever the terminal delivers as a bracketed paste.
+ */
+export declare function useClipboard(): ClipboardHandle;
+/** The most recent `limit` values from any stream source. */
+export declare function useStream<T>(source: StreamSource<T> | null, options?: {
+    limit?: number;
+}): T[];
+/** A frame ticker, throttled and globally disableable by the driver. */
+export declare function useTicker(onTick: (frame: number, elapsedMs: number) => void, options?: {
+    fps?: number;
+    enabled?: boolean;
+}): void;
+/** A frame counter, for spinners and marquees. Frozen when animation is off. */
+export declare function useFrame(fps?: number): number;
+/** A value that eases towards its target. Snaps when animation is off. */
+export declare function useTween(target: number, durationMs?: number): number;
+export declare function useInterval(fn: () => void, ms: number, enabled?: boolean): void;
+/** Register a disposable for the lifetime of this component. */
+export declare function useDisposable(factory: () => Disposable, deps?: unknown[]): void;
+//# sourceMappingURL=hooks.d.ts.map