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

package/dist/textEdit.d.ts

@@ -0,0 +1,72 @@
+import { UIKitKeyEvent } from './controls';
+import { ScrollWindow } from './scroll';
+import { UIKitFontMetrics } from './text/font';
+export interface TextEditState {
+    text: string;
+    /** Caret position, 0 to `text.length`. */
+    caret: number;
+    /** The other end of the selection; equals `caret` when nothing is selected. */
+    anchor: number;
+}
+/** A state with the caret at `caret` (default: the end) and no selection. */
+export declare function textEditState(text: string, caret?: number, anchor?: number): TextEditState;
+/** The selected span as [start, end) (empty when start equals end). */
+export declare function selectionOf(s: TextEditState): [number, number];
+export declare function hasSelection(s: TextEditState): boolean;
+export declare function selectAll(s: TextEditState): TextEditState;
+/** Move the caret to `index`; with `extend`, the anchor stays and the selection grows. */
+export declare function setCaret(s: TextEditState, index: number, extend?: boolean): TextEditState;
+/** Replace the selection (or insert at the caret) with `str`. */
+export declare function insertText(s: TextEditState, str: string): TextEditState;
+/** Delete the selection, or the character before the caret. */
+export declare function deleteBackward(s: TextEditState): TextEditState;
+/** Delete the selection, or the character after the caret. */
+export declare function deleteForward(s: TextEditState): TextEditState;
+/**
+ * The state after an editing key: caret moves (arrows, Home, End, with Shift
+ * extending the selection and Meta or Ctrl jumping to the ends), Backspace,
+ * Delete, select-all (Meta or Ctrl plus A) and typed characters. A typed
+ * character that `accept` rejects leaves the state as it is but still counts
+ * as handled, so a number field swallows letters. Returns null for keys that
+ * are not edits (Enter, Escape, Tab, ArrowUp, ...), which the widget decides.
+ */
+export declare function editKey(s: TextEditState, e: UIKitKeyEvent, accept?: (ch: string) => boolean): TextEditState | null;
+/** The selected text, empty when nothing is selected. */
+export declare function selectedText(s: TextEditState): string;
+/** The clipboard action a key asks for: Meta or Ctrl plus C, X or V. */
+export declare function clipboardKey(e: UIKitKeyEvent): 'copy' | 'cut' | 'paste' | null;
+/**
+ * A usable `maxLength`: a non-negative finite count, else undefined (no
+ * limit), so a NaN or negative option neither empties the field nor blocks
+ * every key.
+ */
+export declare function maxLengthOf(maxLength: number | undefined): number | undefined;
+/** `text` cut to `maxLength` (see `maxLengthOf`); the same string when it fits. */
+export declare function truncateText(text: string, maxLength: number | undefined): string;
+/**
+ * An edit carried across a `maxLength` change: the text cut to the limit with
+ * the caret and anchor still inside it. The same state when nothing changes.
+ */
+export declare function truncateEdit(s: TextEditState, maxLength: number | undefined): TextEditState;
+/**
+ * Replace the selection with the characters of `str` that `accept` allows,
+ * as many as keep the text within `maxLength` (pasting into a full field
+ * inserts nothing).
+ */
+export declare function pasteText(s: TextEditState, str: string, accept?: (ch: string) => boolean, maxLength?: number): TextEditState;
+/** The advance of each code unit of `text` at `sizePx` (0 for a glyph the font lacks). */
+export declare function glyphAdvances(metrics: UIKitFontMetrics, text: string, sizePx: number): number[];
+/** Width of the glyphs from index `from` up to (not including) `to`. */
+export declare function advanceBetween(advances: readonly number[], from: number, to: number): number;
+/**
+ * The caret index nearest to `px`, measured from the left edge of the glyph
+ * at `first`: a point past the middle of a glyph lands after it.
+ */
+export declare function caretIndexAt(advances: readonly number[], first: number, px: number): number;
+/**
+ * The run of whole glyphs a field of `viewport` width shows, starting at
+ * `first` but scrolled the least distance that keeps the caret in view: the
+ * caret's glyph becomes the first shown when the caret lies before the run,
+ * and the glyph before the caret becomes the last shown when it lies after.
+ */
+export declare function textWindow(advances: readonly number[], viewport: number, first: number, caret: number): ScrollWindow;

package/dist/textField.d.ts

@@ -0,0 +1,33 @@
+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';
+/** The style knobs the text of a field needs. */
+export interface TextFieldStyle {
+    textSizePx: number;
+    caretWidth: number;
+    caretColor: RGBA;
+    /** Color behind selected text. */
+    selectionFill: RGBA;
+}
+/** The width a text area has for glyphs, keeping room for the caret. */
+export declare function textFieldViewport(area: UIKitBox, caretWidth: number): number;
+/**
+ * The run of glyphs a text area shows, starting at `firstGlyph` but scrolled
+ * the least distance that keeps `caret` in view.
+ */
+export declare function textFieldWindow(area: UIKitBox, style: TextFieldStyle, metrics: UIKitFontMetrics, text: string, firstGlyph: number, caret: number): ScrollWindow;
+/** The caret index for a canvas x over text shown from `firstGlyph`. */
+export declare function textFieldCaretAt(area: UIKitBox, style: TextFieldStyle, metrics: UIKitFontMetrics, text: string, firstGlyph: number, px: number): number;
+/**
+ * The draw data for a field's text: the selection (behind), the glyphs that
+ * fit and, while focused with nothing selected, the caret. `edit` is the
+ * edit in progress or null when the field is not focused.
+ */
+export declare function buildTextFieldContent(area: UIKitBox, baseline: number, style: TextFieldStyle, metrics: UIKitFontMetrics, text: string, edit: TextEditState | null, firstGlyph: number, color: RGBA, enabled: boolean): {
+    rects: RectData[];
+    text: UIKitTextItem[];
+    shown: ScrollWindow;
+};

package/dist/textInput.d.ts

@@ -0,0 +1,123 @@
+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 input. All lengths are in canvas pixels. */
+export interface TextInputStyle {
+    /** 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;
+    /** 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 cap-height box 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;
+    caretColor: RGBA;
+    caretWidth: number;
+    /** Color behind selected text. */
+    selectionFill: RGBA;
+}
+export declare const DEFAULT_TEXT_INPUT_STYLE: TextInputStyle;
+export interface TextInputSpec {
+    /** Stable key: the handle for updates, pointer tracking and the callbacks. */
+    id: string;
+    /** Optional label, drawn to the left of the field. */
+    label?: string;
+    /** Top-left corner of the whole control (label included), in canvas pixels. */
+    x: number;
+    y: number;
+    /** Field width (the label adds to it). Default: the style's `fieldWidth`. */
+    width?: 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. Default: accept all. */
+    accept?: (ch: string) => boolean;
+    /** A disabled input draws dimmed and ignores input. Default true. */
+    enabled?: boolean;
+    /** Per-input overrides of the overlay's default style. */
+    style?: Partial<TextInputStyle>;
+    /** Fired on every keystroke that changes the text. */
+    onInput?: (text: string, id: string) => void;
+    /** Fired once when changed text is committed: on Enter and on losing focus. */
+    onChange?: (text: string, id: string) => void;
+    /** Fired on Enter, changed or not, after `onChange`. */
+    onSubmit?: (text: string, id: string) => void;
+}
+/** The control's boxes in canvas pixels. */
+export interface TextInputLayout {
+    /** The whole control: label and field. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The bordered field. */
+    field: UIKitBox;
+    /** Where the text, caret and selection draw. */
+    textArea: UIKitBox;
+    /** Baseline of the label and the field text. */
+    baseline: number;
+}
+/** The transient state that changes how a text input looks. */
+export interface TextInputVisual {
+    /** The text shown: the committed text, or the edit in progress. */
+    text: string;
+    /** The edit in progress while the input has keyboard focus, else null. */
+    edit: TextEditState | null;
+    /** Index of the first glyph the text area shows (the overlay keeps it between frames). */
+    firstGlyph: number;
+    hover: boolean;
+    enabled: boolean;
+}
+export declare function resolveTextInputStyle(base: TextInputStyle, override?: Partial<TextInputStyle>): TextInputStyle;
+/** The control's boxes for a spec. */
+export declare function layoutTextInput(spec: TextInputSpec, style: TextInputStyle, metrics: UIKitFontMetrics): TextInputLayout;
+/** Scale every length in a spec and style by `k` (CSS pixels to canvas pixels). */
+export declare function scaleTextInput(spec: TextInputSpec, style: TextInputStyle, k: number): {
+    spec: TextInputSpec;
+    style: TextInputStyle;
+};
+/** True when canvas point (px, py) lies inside the field (the label is not interactive). */
+export declare function textInputContains(layout: TextInputLayout, px: number, py: number): boolean;
+/**
+ * The run of glyphs the text area shows, starting at `firstGlyph` but
+ * scrolled the least distance that keeps `caret` in view.
+ */
+export declare function textInputTextWindow(layout: TextInputLayout, style: TextInputStyle, metrics: UIKitFontMetrics, text: string, firstGlyph: number, caret: number): ScrollWindow;
+/** The caret index for a canvas x over text shown from `firstGlyph`. */
+export declare function textInputCaretAt(layout: TextInputLayout, style: TextInputStyle, metrics: UIKitFontMetrics, text: string, firstGlyph: number, px: number): number;
+/**
+ * The draw data for one text input in one visual state: the field, the
+ * placeholder or the selection, the visible run of text and the caret, and
+ * the label.
+ */
+export declare function buildTextInput(spec: TextInputSpec, style: TextInputStyle, layout: TextInputLayout, metrics: UIKitFontMetrics, visual: TextInputVisual): {
+    rects: RectData[];
+    text: UIKitTextItem[];
+};

package/dist/textInputOverlay.d.ts

@@ -0,0 +1,139 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { ClipboardBridge } from './host';
+import { UIKitFont } from './text/font';
+import { TextInputLayout, TextInputSpec, TextInputStyle } from './textInput';
+export interface UIKitTextInputOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default style for every input; a spec's `style` overrides per key. */
+    style?: Partial<TextInputStyle>;
+    /**
+     * 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 UIKitTextInputOverlay 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 focusedId;
+    /** The held press, which drags the selection. */
+    private pressId;
+    private lastDownId;
+    private lastDownAt;
+    constructor(font: UIKitFont, options?: UIKitTextInputOverlayOptions);
+    /** CSS cursor while a field is hovered: a text beam. */
+    get hoverCursor(): string;
+    /** Replace the default style for every input (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<TextInputStyle>): void;
+    /**
+     * Add an input, or replace the one with the same id. A replacement takes
+     * the new spec's text and ends any edit in progress.
+     */
+    addTextInput(spec: TextInputSpec): void;
+    /** Replace the whole input set. */
+    setTextInputs(specs: readonly TextInputSpec[]): void;
+    removeTextInput(id: string): void;
+    /**
+     * Patch one input's spec (label, position, placeholder, enabled, ...). The
+     * committed text is kept unless the patch sets `value`.
+     */
+    updateTextInput(id: string, patch: Partial<Omit<TextInputSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Set an input'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 inputs, in draw order. */
+    get ids(): string[];
+    /** An input's boxes in spec units (canvas pixels, or CSS pixels with `cssUnits`). */
+    getLayout(id: string): TextInputLayout | null;
+    /** The input with keyboard focus (being edited), if any. */
+    get focusedInput(): string | null;
+    /**
+     * Give an input keyboard focus with its whole text selected, or null to
+     * clear. Leaving an input commits its edit. Disabled inputs 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;
+    /**
+     * Editing keys change the text; Enter commits and submits; Escape reverts;
+     * Meta or Ctrl plus C, X and V go through the clipboard.
+     */
+    /** Enter commits the field and, in a dialog, submits it. */
+    submitsForm(e: UIKitKeyEvent): boolean;
+    keyDown(e: UIKitKeyEvent): boolean;
+    /**
+     * Paste text into the focused input from code, as a host that catches the
+     * DOM paste event itself would. Line breaks are dropped, 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;
+    private invalidate;
+    /** 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 input is still being
+     * edited when it arrives.
+     */
+    private clipboardAction;
+    /** The edit state for a freshly focused (or reverted) input: all selected. */
+    private freshEdit;
+    /**
+     * Commit the edit: changed text becomes the value and fires `onChange`.
+     * When the input stays focused the text is selected again.
+     */
+    private commit;
+    /** The caret for a drag: a pointer left of the shown text pulls one hidden glyph into view. */
+    private dragCaretAt;
+    private caretAt;
+    /**
+     * Settle the scroll position for the next frame: the stored first glyph,
+     * moved the least distance that keeps the caret in view. Every caret move
+     * (key edit, press, drag) settles, so `firstGlyph` is always the window
+     * the next frame shows and pointer math can read it as is; `rebuild` settles
+     * again for caret moves that bypass this (focus, commit).
+     */
+    private firstShown;
+    private scaled;
+    private layoutOf;
+    /** The topmost (last added) enabled input whose field is under a canvas point. */
+    private hitEntry;
+    private rebuild;
+}

package/dist/toggle.d.ts

@@ -0,0 +1,115 @@
+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 toggle. All lengths are in canvas pixels. */
+export interface ToggleStyle {
+    /** Side of the square check box. */
+    boxSize: number;
+    /** Corner radius of the box. */
+    radius: number;
+    /** Space between the box and the label. */
+    gap: number;
+    /** Box color when unchecked. */
+    fill: RGBA;
+    /** Box color when checked. */
+    checkedFill: RGBA;
+    /** Box color when unchecked and hovered. */
+    hoverFill: RGBA;
+    /** Box color when checked and hovered. */
+    checkedHoverFill: RGBA;
+    /** Box color when disabled (checked or not; the mark still shows). */
+    disabledFill: RGBA;
+    /** Box border color. */
+    border: RGBA;
+    borderWidth: number;
+    /** Check-mark color and stroke width. */
+    checkColor: RGBA;
+    checkWidth: number;
+    textColor: RGBA;
+    disabledTextColor: RGBA;
+    /** Label em size. */
+    textSizePx: number;
+    /**
+     * Halo outline width around the label, so it reads 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;
+    /** Scale of the box while the pointer holds it down. */
+    pressScale: number;
+    /** Focus ring color (drawn around the box while the toggle has keyboard focus). */
+    focusRing: RGBA;
+    focusRingWidth: number;
+}
+export declare const DEFAULT_TOGGLE_STYLE: ToggleStyle;
+export interface ToggleSpec {
+    /** Stable key: the handle for updates, pointer tracking and the callback. */
+    id: string;
+    label: string;
+    /** Top-left corner of the whole control (box plus label), in canvas pixels. */
+    x: number;
+    y: number;
+    /** Initial state. Default false. */
+    checked?: boolean;
+    /** Per-toggle overrides of the overlay's default style. */
+    style?: Partial<ToggleStyle>;
+    /** A disabled toggle draws dimmed and ignores input. Default true. */
+    enabled?: boolean;
+    /** Fired when the user changes the state (pointer or keyboard), not by `setChecked`. */
+    onChange?: (checked: boolean, id: string) => void;
+}
+/** The control's box in canvas pixels, plus the check box inside it. */
+export interface ToggleLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    box: {
+        x: number;
+        y: number;
+        size: number;
+    };
+}
+/** The transient state that changes how a toggle looks. */
+export interface ToggleVisual {
+    checked: boolean;
+    hover: boolean;
+    pressed: boolean;
+    focused: boolean;
+    enabled: boolean;
+}
+export declare function resolveToggleStyle(base: ToggleStyle, override?: Partial<ToggleStyle>): ToggleStyle;
+/** The control box for a spec: the check box plus the label beside it. */
+export declare function layoutToggle(spec: ToggleSpec, style: ToggleStyle, metrics: UIKitFontMetrics): ToggleLayout;
+/** Scale every length in a spec and style by `k` (CSS pixels to canvas pixels). */
+export declare function scaleToggle(spec: ToggleSpec, style: ToggleStyle, k: number): {
+    spec: ToggleSpec;
+    style: ToggleStyle;
+};
+/**
+ * Check-mark strokes inside a square box, as line segments. Exported so a
+ * checkable menu item can draw the same mark.
+ */
+export declare function buildCheckMark(x: number, y: number, size: number, width: number, color: RGBA): LineData[];
+/** A transparent rect whose border is the focus ring, drawn `inset` outside a box. */
+export declare function buildFocusRing(box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, radius: number, color: RGBA, width: number, inset?: number): RectData;
+/**
+ * The draw data for one toggle in one visual state: the box (shrunk about its
+ * centre while pressed), the check mark when checked, a focus ring when
+ * focused, and the label vertically centred on the box.
+ */
+export declare function buildToggle(spec: ToggleSpec, style: ToggleStyle, metrics: UIKitFontMetrics, layout: ToggleLayout, visual: ToggleVisual): {
+    rects: RectData[];
+    lines: LineData[];
+    text: UIKitTextItem;
+};
+/** True when canvas point (px, py) lies inside the control box (box plus label). */
+export declare function toggleContains(layout: ToggleLayout, px: number, py: number): boolean;

package/dist/toggleOverlay.d.ts

@@ -0,0 +1,80 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { UIKitFont } from './text/font';
+import { ToggleLayout, ToggleSpec, ToggleStyle } from './toggle';
+export interface UIKitToggleOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default style for every toggle; a spec's `style` overrides per key. */
+    style?: Partial<ToggleStyle>;
+    /**
+     * 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 UIKitToggleOverlay 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 pressedId;
+    /** While pressed: whether the pointer is currently over the pressed toggle. */
+    private pressInside;
+    private hoverId;
+    private focusedId;
+    private layer;
+    constructor(font: UIKitFont, options?: UIKitToggleOverlayOptions);
+    /** Replace the default style for every toggle (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<ToggleStyle>): void;
+    /**
+     * Add a toggle, or replace the one with the same id. A replacement keeps the
+     * current checked state unless the new spec sets `checked`.
+     */
+    addToggle(spec: ToggleSpec): void;
+    /** Replace the whole toggle set. */
+    setToggles(specs: readonly ToggleSpec[]): void;
+    removeToggle(id: string): void;
+    /** Patch one toggle's spec (label, position, style, enabled, checked, callback). */
+    updateToggle(id: string, patch: Partial<Omit<ToggleSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Set a toggle's state from code. Does not fire `onChange`. */
+    setChecked(id: string, checked: boolean): void;
+    isChecked(id: string): boolean;
+    /** Flip a toggle as the user would (a keyboard shortcut, say): fires `onChange`. */
+    toggle(id: string): void;
+    /** The ids of all toggles, in draw order. */
+    get ids(): string[];
+    /** A toggle's box in spec units (canvas pixels, or CSS pixels with `cssUnits`). */
+    getLayout(id: string): ToggleLayout | null;
+    /** The toggle with keyboard focus, if any. */
+    get focusedToggle(): string | null;
+    /** Give a toggle keyboard focus (Space/Enter flips it), or null to clear. */
+    focus(id: string | null): void;
+    hitTest(x: number, y: number): boolean;
+    pointerDown(x: number, y: number): boolean;
+    pointerMove(x: number, y: number): boolean;
+    /** Flips the toggle when released inside the one that was pressed. */
+    pointerUp(x: number, y: number): boolean;
+    pointerCancel(): void;
+    /** Space or Enter flips the focused toggle. */
+    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 scaled;
+    private layoutOf;
+    /** The topmost (last added) enabled toggle under a canvas point. */
+    private hitEntry;
+    private rebuild;
+}