@niivue/uikit 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/slider.d.ts

@@ -0,0 +1,152 @@
+import { LineData } from './line';
+import { RectData } from './rect';
+import { UIKitFontMetrics } from './text/font';
+import { RGBA } from './text/layout';
+import { UIKitTextItem } from './textOverlay';
+/** Every visual knob on a slider. All lengths are in canvas pixels. */
+export interface SliderStyle {
+    trackHeight: number;
+    trackRadius: number;
+    /** Track color to the right of the thumb. */
+    trackFill: RGBA;
+    /** Track color from the left end to the thumb. */
+    trackActiveFill: RGBA;
+    /** Diameter of the (round) thumb. */
+    thumbSize: number;
+    thumbFill: RGBA;
+    thumbHoverFill: RGBA;
+    /** Thumb color while it is being dragged. */
+    thumbActiveFill: RGBA;
+    thumbBorder: RGBA;
+    thumbBorderWidth: number;
+    /** Tick marks under the track (drawn when the spec sets `tickStep`). */
+    tickColor: RGBA;
+    tickLength: number;
+    tickWidth: number;
+    textColor: RGBA;
+    disabledTextColor: RGBA;
+    /** Label and value em size. */
+    textSizePx: number;
+    /**
+     * Halo outline width around the label and value, so they read over any
+     * scene; 0 draws none. 1 to 2 reads best with the bundled font.
+     */
+    textOutlineWidth: number;
+    /** Halo color; null picks black or white for contrast with `textColor`. */
+    textOutlineColor: RGBA | null;
+    /** Space between the label row baseline and the thumb row. */
+    labelGap: number;
+    /** Focus ring color (drawn around the thumb while the slider has keyboard focus). */
+    focusRing: RGBA;
+    focusRingWidth: number;
+}
+export declare const DEFAULT_SLIDER_STYLE: SliderStyle;
+export interface SliderSpec {
+    /** Stable key: the handle for updates, pointer tracking and the callbacks. */
+    id: string;
+    /** Optional label, drawn above the track at the left. */
+    label?: string;
+    /** Top-left corner of the whole control, in canvas pixels. */
+    x: number;
+    y: number;
+    /** Width of the whole control (the track spans it, inset by half the thumb). */
+    width: number;
+    min: number;
+    max: number;
+    /**
+     * Value granularity. Omit for a continuous slider; the keyboard then moves
+     * by one hundredth of the range.
+     */
+    step?: number;
+    /** Initial value (snapped to the range and step). */
+    value: number;
+    /** Draw the current value above the track at the right. Default false. */
+    showValue?: boolean;
+    /** Formatter for the displayed value. Default: the step's decimal places. */
+    format?: (value: number) => string;
+    /** Spacing of tick marks under the track, in value units. Omit for none. */
+    tickStep?: number;
+    /** A disabled slider draws dimmed and ignores input. Default true. */
+    enabled?: boolean;
+    /** Per-slider overrides of the overlay's default style. */
+    style?: Partial<SliderStyle>;
+    /** Fired for every value change during a drag or key press. */
+    onInput?: (value: number, id: string) => void;
+    /**
+     * Fired once when an interaction commits a changed value: on pointer release
+     * after a drag that moved it, and after each key press that moved it.
+     */
+    onChange?: (value: number, id: string) => void;
+}
+/** The control's box in canvas pixels plus the track and the thumb's rail. */
+export interface SliderLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The drawn track bar. */
+    track: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Where the thumb centre may travel: from x0 (min) to x1 (max) along cy. */
+    rail: {
+        x0: number;
+        x1: number;
+        cy: number;
+    };
+    /** Baseline of the label row, or null when the slider has no label row. */
+    labelBaseline: number | null;
+}
+/** The transient state that changes how a slider looks. */
+export interface SliderVisual {
+    value: number;
+    hover: boolean;
+    /** The thumb is being dragged. */
+    active: boolean;
+    focused: boolean;
+    enabled: boolean;
+}
+export declare function resolveSliderStyle(base: SliderStyle, override?: Partial<SliderStyle>): SliderStyle;
+/** The number of decimal places needed to print multiples of `step` exactly (0 for no step). */
+export declare function stepDecimals(step: number): number;
+/** A `step` that can snap: finite and positive, else undefined (continuous). */
+export declare function usableStep(step: number | undefined): number | undefined;
+/** Round `value` to the nearest multiple of `step` from `origin`, printed exactly. */
+export declare function snapToStep(value: number, origin: number, step: number): number;
+/** Clamp `value` into [min, max] and, with a positive step, snap it to the step grid from min. */
+export declare function snapValue(value: number, min: number, max: number, step?: number): number;
+/** Position of `value` along the range as 0..1 (0 when the range is empty). */
+export declare function valueToFraction(value: number, min: number, max: number): number;
+export declare function fractionToValue(fraction: number, min: number, max: number): number;
+/** The step a key press moves by: the spec's, or a hundredth of the range. */
+export declare function effectiveStep(spec: Pick<SliderSpec, 'min' | 'max' | 'step'>): number;
+/** Move `value` by one step (ten with `big`) in `direction` (+1 or -1), snapped. */
+export declare function stepValue(value: number, spec: Pick<SliderSpec, 'min' | 'max' | 'step'>, direction: 1 | -1, big?: boolean): number;
+/** The displayed text for a value: the spec's formatter, else the step's precision. */
+export declare function formatSliderValue(spec: Pick<SliderSpec, 'step' | 'format'>, value: number): string;
+/** The control box for a spec: an optional label row above the thumb row. */
+export declare function layoutSlider(spec: SliderSpec, style: SliderStyle, metrics: UIKitFontMetrics): SliderLayout;
+/** Scale every length in a spec and style by `k` (CSS pixels to canvas pixels). */
+export declare function scaleSlider(spec: SliderSpec, style: SliderStyle, k: number): {
+    spec: SliderSpec;
+    style: SliderStyle;
+};
+/** The thumb centre x for a value. */
+export declare function sliderThumbX(layout: SliderLayout, spec: Pick<SliderSpec, 'min' | 'max'>, value: number): number;
+/** The (snapped) value for a pointer x along the rail. */
+export declare function sliderValueAt(layout: SliderLayout, spec: Pick<SliderSpec, 'min' | 'max' | 'step'>, px: number): number;
+/** True when canvas point (px, py) lies inside the control box. */
+export declare function sliderContains(layout: SliderLayout, px: number, py: number): boolean;
+/**
+ * The draw data for one slider in one visual state: the track with its active
+ * part filled to the thumb, tick marks, the thumb (with a focus ring when
+ * focused), and the label row.
+ */
+export declare function buildSlider(spec: SliderSpec, style: SliderStyle, layout: SliderLayout, visual: SliderVisual): {
+    rects: RectData[];
+    lines: LineData[];
+    text: UIKitTextItem[];
+};

package/dist/sliderOverlay.d.ts

@@ -0,0 +1,92 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { SliderLayout, SliderSpec, SliderStyle } from './slider';
+import { UIKitFont } from './text/font';
+export interface UIKitSliderOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default style for every slider; a spec's `style` overrides per key. */
+    style?: Partial<SliderStyle>;
+    /**
+     * Interpret spec positions and style lengths as CSS pixels and scale them by
+     * the frame's device pixel ratio, instead of canvas pixels.
+     */
+    cssUnits?: boolean;
+}
+export declare class UIKitSliderOverlay implements UIKitOverlayRenderer, UIKitInteractive {
+    readonly hoverCursor = "pointer";
+    private readonly font;
+    private readonly rects;
+    private readonly lines;
+    private readonly labels;
+    private readonly entries;
+    private baseStyle;
+    private readonly cssUnits;
+    private requestRedraw;
+    private scale;
+    private geometryDirty;
+    private dragId;
+    /** The value when the drag started, to decide whether release fires onChange. */
+    private dragStartValue;
+    private hoverId;
+    private focusedId;
+    private layer;
+    constructor(font: UIKitFont, options?: UIKitSliderOverlayOptions);
+    /** Replace the default style for every slider (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<SliderStyle>): void;
+    /**
+     * Add a slider, or replace the one with the same id. The spec's `value` is
+     * snapped to its range and step; a replacement takes the new spec's value.
+     */
+    addSlider(spec: SliderSpec): void;
+    /** Replace the whole slider set. */
+    setSliders(specs: readonly SliderSpec[]): void;
+    removeSlider(id: string): void;
+    /**
+     * Patch one slider's spec (label, position, range, step, enabled, ...). The
+     * current value is kept (re-snapped to the new range) unless the patch sets
+     * `value`.
+     */
+    updateSlider(id: string, patch: Partial<Omit<SliderSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Set a slider's value from code (snapped). Fires neither callback. */
+    setValue(id: string, value: number): void;
+    getValue(id: string): number | undefined;
+    /** The ids of all sliders, in draw order. */
+    get ids(): string[];
+    /** A slider's box in spec units (canvas pixels, or CSS pixels with `cssUnits`). */
+    getLayout(id: string): SliderLayout | null;
+    /** The slider with keyboard focus, if any. */
+    get focusedSlider(): string | null;
+    /** Give a slider keyboard focus, or null to clear. Disabled sliders refuse. */
+    focus(id: string | null): void;
+    /** True while a thumb is being dragged. */
+    get isDragging(): boolean;
+    hitTest(x: number, y: number): boolean;
+    /** Jumps the thumb to the pointer and starts a drag. */
+    pointerDown(x: number, y: number): boolean;
+    pointerMove(x: number, y: number): boolean;
+    /** Ends the drag; fires `onChange` if the value moved since the press. */
+    pointerUp(x: number, y: number): boolean;
+    /** Ends the drag where it is; fires `onChange` if the value moved. */
+    pointerCancel(): void;
+    /**
+     * Arrow keys step the focused slider (Shift: ten steps), PageUp/PageDown
+     * step by ten, Home/End jump to the ends.
+     */
+    keyDown(e: UIKitKeyEvent): boolean;
+    blur(): void;
+    bindLayer(layer: UIKitRedrawSource): void;
+    drawOverlay(frame: UIKitOverlayFrame): void;
+    /** Release GPU resources on both backends. */
+    destroy(): void;
+    private invalidate;
+    private endDrag;
+    /** Set an entry's value from a pointer x, firing onInput when it changes. */
+    private setFromPointer;
+    private scaled;
+    private layoutOf;
+    /** The topmost (last added) enabled slider under a canvas point. */
+    private hitEntry;
+    private rebuild;
+}

package/dist/text/layout.d.ts

@@ -34,6 +34,14 @@ export interface TextLayoutOptions {
 export declare function autoOutlineColor(fill: RGBA): RGBA;
 /** Total advance width of `str` in pixels at `sizePx`. */
 export declare function measureWidth(metrics: UIKitFontMetrics, str: string, sizePx: number): number;
+/**
+ * Cap height of the font in em units: how far the top of a capital letter sits
+ * above the baseline. Used to centre a label on its button vertically by the
+ * capitals rather than by each string's own ink, so a row of buttons keeps one
+ * baseline whether or not a label has descenders. Falls back to a typical 0.7em
+ * when the atlas has no capital H.
+ */
+export declare function capHeight(metrics: UIKitFontMetrics): number;
 /**
  * Normalize a line direction angle so text drawn along it is never upside down.
  * When the raw angle points leftward (cos < 0), the label would render mirrored;

package/dist/textArea.d.ts

@@ -0,0 +1,216 @@
+import { UIKitKeyEvent } from './controls';
+import { RectData } from './rect';
+import { ScrollWindow, UIKitBox } from './scroll';
+import { UIKitFontMetrics } from './text/font';
+import { RGBA } from './text/layout';
+import { TextEditState } from './textEdit';
+import { UIKitTextItem } from './textOverlay';
+/** Every visual knob on a text area. All lengths are in canvas pixels. */
+export interface TextAreaStyle {
+    /** Field color at rest. */
+    fill: RGBA;
+    /** Field color while the pointer hovers it. */
+    hoverFill: RGBA;
+    /** Field color when disabled. */
+    disabledFill: RGBA;
+    border: RGBA;
+    /** Border color while the field has keyboard focus. */
+    focusBorder: RGBA;
+    borderWidth: number;
+    radius: number;
+    textColor: RGBA;
+    disabledTextColor: RGBA;
+    /** Color of the placeholder shown while the field is empty. */
+    placeholderColor: RGBA;
+    /** Label and field text em size. */
+    textSizePx: number;
+    /** Row height as a multiple of the em size. */
+    lineHeight: number;
+    /** Halo outline width around the label (it sits on the scene); 0 draws none. */
+    textOutlineWidth: number;
+    /** Halo color; null picks black or white for contrast with `textColor`. */
+    textOutlineColor: RGBA | null;
+    /** Space between the field's left border and the text. */
+    paddingX: number;
+    /** Space between the rows and the field's top and bottom edges. */
+    paddingY: number;
+    /** Space between a label and the field. */
+    labelGap: number;
+    /** Field width when the spec gives none. */
+    fieldWidth: number;
+    /** Visible rows when the spec gives none. */
+    rows: number;
+    caretColor: RGBA;
+    caretWidth: number;
+    /** Color behind selected text. */
+    selectionFill: RGBA;
+    /** Width of the scrollbar thumb shown when the rows overflow. */
+    scrollbarWidth: number;
+    /** Space between the text and the scrollbar, and between it and the border. */
+    scrollbarGap: number;
+    scrollbarColor: RGBA;
+    scrollbarTrackColor: RGBA;
+}
+export declare const DEFAULT_TEXT_AREA_STYLE: TextAreaStyle;
+export interface TextAreaSpec {
+    /** Stable key: the handle for updates, pointer tracking and the callbacks. */
+    id: string;
+    /** Optional label, drawn above the field. */
+    label?: string;
+    /** Top-left corner of the whole control (label included), in canvas pixels. */
+    x: number;
+    y: number;
+    /** Field width. Default: the style's `fieldWidth`. */
+    width?: number;
+    /** Visible rows; longer text scrolls. Default: the style's `rows`. */
+    rows?: number;
+    /** Initial text. Default empty. */
+    value?: string;
+    /** Dimmed text shown while the field is empty. */
+    placeholder?: string;
+    /** Typing stops at this many characters. */
+    maxLength?: number;
+    /** Characters the field refuses from the keyboard (Enter is always a newline). */
+    accept?: (ch: string) => boolean;
+    /** A disabled area draws dimmed and ignores input. Default true. */
+    enabled?: boolean;
+    /** Per-area overrides of the overlay's default style. */
+    style?: Partial<TextAreaStyle>;
+    /** Fired on every keystroke that changes the text. */
+    onInput?: (text: string, id: string) => void;
+    /** Fired once when changed text is committed: on Meta or Ctrl plus Enter and on losing focus. */
+    onChange?: (text: string, id: string) => void;
+    /** Fired on Meta or Ctrl plus Enter, changed or not, after `onChange`. */
+    onSubmit?: (text: string, id: string) => void;
+}
+/** The control's boxes in canvas pixels. */
+export interface TextAreaLayout {
+    /** The whole control: label and field. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The bordered field. */
+    field: UIKitBox;
+    /** Where the rows of text, the caret and the selection draw. */
+    textArea: UIKitBox;
+    /** Baseline of the label (meaningful only with a label). */
+    labelBaseline: number;
+    /** Height of one row of text. */
+    rowHeight: number;
+    /** Rows the text area shows at once. */
+    rows: number;
+}
+/** The transient state that changes how a text area looks. */
+export interface TextAreaVisual {
+    /** The text shown: the committed text, or the edit in progress. */
+    text: string;
+    /** The edit in progress while the area has keyboard focus, else null. */
+    edit: TextEditState | null;
+    /** Index of the first row the text area shows (the overlay keeps it between frames). */
+    firstRow: number;
+    /**
+     * Scroll `firstRow` just far enough to show the caret (the default). The
+     * overlay passes false after the user scrolled by wheel or thumb, so the
+     * drawn rows match the viewport its hit tests use.
+     */
+    revealCaret?: boolean;
+    hover: boolean;
+    enabled: boolean;
+}
+/** One visual row: the code units [start, end) of the text it shows. */
+export interface TextRow {
+    start: number;
+    end: number;
+    /** True when the row ends its paragraph (at a newline or the end of the text). */
+    hard: boolean;
+}
+export declare function resolveTextAreaStyle(base: TextAreaStyle, override?: Partial<TextAreaStyle>): TextAreaStyle;
+/** The control's boxes for a spec. */
+export declare function layoutTextArea(spec: TextAreaSpec, style: TextAreaStyle, metrics: UIKitFontMetrics): TextAreaLayout;
+/** Scale every length in a spec and style by `k` (CSS pixels to canvas pixels). */
+export declare function scaleTextArea(spec: TextAreaSpec, style: TextAreaStyle, k: number): {
+    spec: TextAreaSpec;
+    style: TextAreaStyle;
+};
+/** True when canvas point (px, py) lies inside the field (the label is not interactive). */
+export declare function textAreaContains(layout: TextAreaLayout, px: number, py: number): boolean;
+/** The track and thumb for an overflowing area's row-based scrollbar. */
+export interface TextAreaScrollbar {
+    track: UIKitBox;
+    thumb: UIKitBox;
+    /** Largest valid first-row index for this content and viewport. */
+    maxFirst: number;
+}
+/**
+ * Returns the scrollbar geometry when `rowCount` overflows `shown`, otherwise
+ * null. Keeping this calculation shared means the drawn thumb and its pointer
+ * hit target cannot drift apart.
+ */
+export declare function textAreaScrollbar(layout: TextAreaLayout, style: TextAreaStyle, shown: ScrollWindow, rowCount: number): TextAreaScrollbar | null;
+/** The width the rows have for glyphs, keeping room for the caret. */
+export declare function textAreaWrapWidth(layout: TextAreaLayout, style: TextAreaStyle): number;
+/**
+ * Break `text` into rows no wider than `maxWidth`: at every newline, else
+ * after the last space that fits (the space may overhang the edge), else
+ * before the first glyph that does not fit. Every row holds at least one
+ * code unit unless its paragraph is empty, and the newline that ends a
+ * paragraph belongs to no row (it sits at the hard row's `end`).
+ */
+export declare function wrapRows(text: string, advances: readonly number[], maxWidth: number): TextRow[];
+/**
+ * The row that shows the caret at `caret`: the row containing it, or a hard
+ * row ending exactly there. A caret at a soft break sits on the next row.
+ */
+export declare function rowOfCaret(rows: readonly TextRow[], caret: number): number;
+/** The x offset of `caret` from the left edge of its row. */
+export declare function caretXInRow(advances: readonly number[], row: TextRow, caret: number): number;
+/**
+ * The caret index nearest to `px` (measured from the row's left edge) on a
+ * row. Past the end of a soft row the caret lands before a trailing space,
+ * so it stays on that row.
+ */
+export declare function caretInRow(text: string, advances: readonly number[], row: TextRow, px: number): number;
+/**
+ * The run of rows the text area shows, starting at `firstRow` but scrolled
+ * the least distance that keeps `caret` in view.
+ */
+export declare function textAreaWindow(layout: TextAreaLayout, rows: readonly TextRow[], firstRow: number, caret: number | null): ScrollWindow;
+/** The rows a text falls into inside a layout. */
+export declare function textAreaRows(layout: TextAreaLayout, style: TextAreaStyle, metrics: UIKitFontMetrics, text: string): TextRow[];
+/**
+ * The caret index for a canvas point over text shown from `firstRow`: the
+ * row under `py` (clamped to the rows shown) and the nearest glyph edge on it.
+ */
+export declare function textAreaCaretAt(layout: TextAreaLayout, style: TextAreaStyle, metrics: UIKitFontMetrics, text: string, firstRow: number, px: number, py: number): number;
+/**
+ * Move the caret `delta` rows, keeping `goalX` (the x the caret had before a
+ * run of vertical moves, or its current x when null) as far as the target
+ * row allows. Past the first or last row the caret goes to the text's ends.
+ */
+export declare function moveCaretRows(s: TextEditState, rows: readonly TextRow[], advances: readonly number[], delta: number, goalX: number | null, extend: boolean): {
+    state: TextEditState;
+    goalX: number;
+};
+/**
+ * The state after an editing key in a text area: Enter inserts a newline,
+ * ArrowUp and ArrowDown move by row (PageUp and PageDown by `pageRows`,
+ * Meta or Ctrl to the text's ends), Home and End move within the row (Meta
+ * or Ctrl to the text's ends), and every other key goes to the single-line
+ * model. `goalX` carries the x a run of vertical moves aims for; it comes
+ * back as null after any other key. Returns null for keys that are not edits.
+ */
+export declare function textAreaKey(s: TextEditState, e: UIKitKeyEvent, rows: readonly TextRow[], advances: readonly number[], goalX: number | null, pageRows: number, accept?: (ch: string) => boolean): {
+    state: TextEditState;
+    goalX: number | null;
+} | null;
+/**
+ * The draw data for one text area in one visual state: the field, the
+ * placeholder or the selection, the visible rows of text, the caret, the
+ * scrollbar when the rows overflow, and the label.
+ */
+export declare function buildTextArea(spec: TextAreaSpec, style: TextAreaStyle, layout: TextAreaLayout, metrics: UIKitFontMetrics, visual: TextAreaVisual): {
+    rects: RectData[];
+    text: UIKitTextItem[];
+    shown: ScrollWindow;
+};

package/dist/textAreaOverlay.d.ts

@@ -0,0 +1,145 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { ClipboardBridge } from './host';
+import { UIKitFont } from './text/font';
+import { TextAreaLayout, TextAreaSpec, TextAreaStyle } from './textArea';
+export interface UIKitTextAreaOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default style for every area; a spec's `style` overrides per key. */
+    style?: Partial<TextAreaStyle>;
+    /**
+     * Interpret spec positions and style lengths as CSS pixels and scale them by
+     * the frame's device pixel ratio, instead of canvas pixels.
+     */
+    cssUnits?: boolean;
+    /** Two presses on a focused field within this many ms select all. Default 400. */
+    doubleClickMs?: number;
+    /** Clock for the double-click interval. Default `performance.now`. */
+    now?: () => number;
+    /** Where copy, cut and paste go. Default: the browser's async clipboard. */
+    clipboard?: ClipboardBridge;
+}
+export declare class UIKitTextAreaOverlay implements UIKitOverlayRenderer, UIKitInteractive {
+    private readonly font;
+    private readonly rects;
+    private readonly labels;
+    private readonly entries;
+    private baseStyle;
+    private readonly cssUnits;
+    private readonly doubleClickMs;
+    private readonly now;
+    private requestRedraw;
+    private layer;
+    private clipboard;
+    private scale;
+    private geometryDirty;
+    private hoverId;
+    private hoverScrollbarId;
+    private focusedId;
+    /** The held press, which drags the selection. */
+    private pressId;
+    /** The held scrollbar thumb and the pointer's offset from its top edge. */
+    private scrollDrag;
+    private lastDownId;
+    private lastDownAt;
+    constructor(font: UIKitFont, options?: UIKitTextAreaOverlayOptions);
+    /** CSS cursor while a field is hovered: resize over a scrollbar thumb. */
+    get hoverCursor(): string;
+    /** Replace the default style for every area (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<TextAreaStyle>): void;
+    /**
+     * Add an area, or replace the one with the same id. A replacement takes
+     * the new spec's text and ends any edit in progress.
+     */
+    addTextArea(spec: TextAreaSpec): void;
+    /** Replace the whole area set. */
+    setTextAreas(specs: readonly TextAreaSpec[]): void;
+    removeTextArea(id: string): void;
+    /**
+     * Patch one area's spec (label, position, rows, placeholder, enabled, ...).
+     * The committed text is kept unless the patch sets `value`.
+     */
+    updateTextArea(id: string, patch: Partial<Omit<TextAreaSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Set an area's text from code. Fires no callback; a focused field shows it selected. */
+    setValue(id: string, value: string): void;
+    /** The committed text. */
+    getValue(id: string): string | undefined;
+    /** The text the field shows: the edit in progress, or the committed text. */
+    getText(id: string): string | undefined;
+    /** The ids of all areas, in draw order. */
+    get ids(): string[];
+    /** An area's boxes in spec units (canvas pixels, or CSS pixels with `cssUnits`). */
+    getLayout(id: string): TextAreaLayout | null;
+    /** Index of the first row an area shows. */
+    getFirstRow(id: string): number | undefined;
+    /** The area with keyboard focus (being edited), if any. */
+    get focusedArea(): string | null;
+    /**
+     * Give an area keyboard focus with its whole text selected, or null to
+     * clear. Leaving an area commits its edit. Disabled areas refuse.
+     */
+    focus(id: string | null): void;
+    hitTest(x: number, y: number): boolean;
+    /**
+     * Focuses the field and places the caret at the pointer, starting a drag
+     * selection; a second press within the double-click interval selects all.
+     */
+    pointerDown(x: number, y: number): boolean;
+    pointerMove(x: number, y: number): boolean;
+    pointerUp(x: number, y: number): boolean;
+    pointerCancel(): void;
+    /** Scrolls the area under the pointer by whole rows. True when one is there. */
+    wheel(x: number, y: number, _deltaX: number, deltaY: number): boolean;
+    /** Meta or Ctrl plus Enter submits a dialog; a plain Enter is a new line. */
+    submitsForm(e: UIKitKeyEvent): boolean;
+    /**
+     * Editing keys change the text; Meta or Ctrl plus Enter commits and
+     * submits; Escape reverts.
+     */
+    keyDown(e: UIKitKeyEvent): boolean;
+    /**
+     * Paste text into the focused area from code, as a host that catches the
+     * DOM paste event itself would. Line breaks are kept as newlines; the
+     * spec's `accept` and `maxLength` apply.
+     */
+    paste(text: string): boolean;
+    /** Commits the edit in progress and drops focus. */
+    blur(): void;
+    bindLayer(layer: UIKitRedrawSource): void;
+    drawOverlay(frame: UIKitOverlayFrame): void;
+    /** Release GPU resources on both backends. */
+    destroy(): void;
+    /** Take a new edit state, redrawing and firing `onInput` when the text changed. */
+    private applyEdit;
+    /**
+     * Copy or cut the selection to the clipboard, or start a paste: the read
+     * is asynchronous, and its text lands only if the area is still being
+     * edited when it arrives.
+     */
+    private clipboardAction;
+    private invalidate;
+    private resetLayout;
+    /** The edit state for a freshly focused (or reverted) area: all selected. */
+    private freshEdit;
+    /**
+     * Commit the edit: changed text becomes the value and fires `onChange`.
+     * When the area stays focused the text is selected again.
+     */
+    private commit;
+    private shownText;
+    private rowsOf;
+    private caretAt;
+    /** Current thumb geometry, or null when the text fits without scrolling. */
+    private scrollbarOf;
+    /** Hit-test the visible thumb plus a gutter-sized pointer target. */
+    private thumbContains;
+    /** Map a dragged thumb top to the nearest whole-row viewport position. */
+    private setScrollFromThumb;
+    private scaled;
+    private layoutOf;
+    /** The topmost (last added) enabled area whose field is under a canvas point. */
+    private hitEntry;
+    private rebuild;
+}