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

package/dist/menu.d.ts

@@ -0,0 +1,227 @@
+import { ButtonLayout, ButtonSpec, ButtonStyle, ButtonVisual } from './button';
+import { LineData } from './line';
+import { RectData } from './rect';
+import { UIKitBox } from './scroll';
+import { UIKitFontMetrics } from './text/font';
+import { RGBA } from './text/layout';
+import { UIKitTextItem } from './textOverlay';
+export type MenuItemKind = 'action' | 'check' | 'radio' | 'separator';
+export interface MenuItemSpec {
+    /** Stable key within the menu: the handle for state and the callbacks. */
+    id: string;
+    /** Shown text. Ignored for a separator. */
+    label?: string;
+    /**
+     * 'action' (default) fires and closes; 'check' keeps a boolean the user
+     * flips; 'radio' is one of an exclusive group; 'separator' is a rule.
+     */
+    kind?: MenuItemKind;
+    /** Current state of a check or radio item. Default false. */
+    checked?: boolean;
+    /** Radio group key. Radios without one share the menu's default group. */
+    group?: string;
+    /** A disabled item draws dimmed and cannot be highlighted or activated. */
+    enabled?: boolean;
+    /** A hint drawn right-aligned (a key combination, say). Not bound to any key. */
+    shortcut?: string;
+    /** Fired when this item is activated (after any state change is applied). */
+    onSelect?: (id: string) => void;
+}
+/** Every visual knob on a menu popup. All lengths are in canvas pixels. */
+export interface MenuStyle {
+    panelFill: RGBA;
+    panelBorder: RGBA;
+    panelBorderWidth: number;
+    panelRadius: number;
+    /** Space between the panel edge and the rows. */
+    panelPadding: number;
+    /** Height of an action, check or radio row. */
+    itemHeight: number;
+    /** Space between the row edge and its contents. */
+    itemPaddingX: number;
+    /** Row color under the highlighted item. */
+    highlightFill: RGBA;
+    textColor: RGBA;
+    disabledTextColor: RGBA;
+    shortcutColor: RGBA;
+    /** Item em size. */
+    textSizePx: number;
+    /** Check-mark and radio-dot color. */
+    checkColor: RGBA;
+    /** Side of the square the check mark or radio dot is drawn in. */
+    markSize: number;
+    /** Check-mark stroke width. */
+    markWidth: number;
+    /** Space between the mark slot and the label. */
+    markGap: number;
+    /** Least space between the longest label and the shortcut column. */
+    shortcutGap: number;
+    separatorColor: RGBA;
+    /** Height of a separator row (the rule is centred in it). */
+    separatorHeight: number;
+    /** Space between the button and the popup. */
+    gapToButton: number;
+    /** Width of the chevron on the button, and its stroke width. */
+    chevronSize: number;
+    chevronWidth: number;
+    /** Space between the label and the chevron. */
+    chevronGap: number;
+    /** Least popup width. */
+    minWidth: number;
+    /** Height of the strips at each end of a scrolled popup (they hold the arrows). */
+    scrollStripHeight: number;
+    /** Width of the scroll arrows, and their stroke width. */
+    scrollArrowSize: number;
+    scrollArrowWidth: number;
+    scrollArrowColor: RGBA;
+}
+export declare const DEFAULT_MENU_STYLE: MenuStyle;
+/** The button style menus start from: a push button that does not shrink. */
+export declare const DEFAULT_MENU_BUTTON_STYLE: ButtonStyle;
+export interface MenuButtonSpec {
+    /** Stable key: the handle for updates, open state and the callbacks. */
+    id: string;
+    label: string;
+    /** Top-left corner of the button, in canvas pixels. */
+    x: number;
+    y: number;
+    /** Fixed button size. Omit either to size that axis to the label and chevron. */
+    width?: number;
+    height?: number;
+    items: readonly MenuItemSpec[];
+    /** A disabled menu button draws dimmed and cannot open. Default true. */
+    enabled?: boolean;
+    /** Per-menu overrides of the overlay's default button style. */
+    buttonStyle?: Partial<ButtonStyle>;
+    /** Per-menu overrides of the overlay's default popup style. */
+    style?: Partial<MenuStyle>;
+    /** Fired when any enabled item is activated, after its own `onSelect`. */
+    onSelect?: (itemId: string, menuId: string) => void;
+    /**
+     * Fired for each check or radio item whose state changed: once for a check
+     * item, and for a radio once for the newly checked item plus once for each
+     * item it unchecked.
+     */
+    onChange?: (itemId: string, checked: boolean, menuId: string) => void;
+}
+/** One row of an open popup, in canvas pixels. */
+export interface MenuRowLayout {
+    /** Index into the menu's items. */
+    index: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The popup panel and its rows, in canvas pixels. */
+export interface MenuPopupLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /**
+     * The visible rows only. When the popup scrolls these are the run from
+     * `firstRow` that fits between the strips.
+     */
+    rows: MenuRowLayout[];
+    /** Whether the panel sits above the button (it would overflow below). */
+    above: boolean;
+    /** True when the items do not all fit and the popup scrolls by rows. */
+    scrollable: boolean;
+    /** Index of the first visible item (0 when not scrollable). */
+    firstRow: number;
+    /** Index after the last visible item (the item count when not scrollable). */
+    endRow: number;
+    /** The strips at the top and bottom of a scrollable popup, else null. */
+    scrollUp: UIKitBox | null;
+    scrollDown: UIKitBox | null;
+}
+/** A rectangle popups must stay within (the overlay frame's bounds). */
+export interface MenuBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function resolveMenuStyle(base: MenuStyle, override?: Partial<MenuStyle>): MenuStyle;
+/** True for an item the user can highlight and activate. */
+export declare function isMenuItemSelectable(item: MenuItemSpec): boolean;
+/** The `ButtonSpec` a menu button draws as (label plus room for the chevron). */
+export declare function menuButtonSpec(spec: MenuButtonSpec, buttonStyle: ButtonStyle, style: MenuStyle, metrics: UIKitFontMetrics): ButtonSpec;
+/** The button's box: fitted to the label plus the chevron unless fixed. */
+export declare function layoutMenuButton(spec: MenuButtonSpec, buttonStyle: ButtonStyle, style: MenuStyle, metrics: UIKitFontMetrics): ButtonLayout;
+/** The height of one row: a separator's or an item's. */
+export declare function menuRowHeight(item: MenuItemSpec, style: MenuStyle): number;
+/**
+ * Place the popup under the button (above it when it would overflow the
+ * bounds below), clamped into the bounds horizontally, and lay out its rows.
+ * When the items fit neither below nor above, the popup takes the roomier
+ * side and scrolls: it keeps a strip at each end and shows the whole rows
+ * from `firstRow` (clamped so the list never scrolls past its end) that fit
+ * between them. Without bounds a popup never scrolls.
+ */
+export declare function layoutMenuPopup(items: readonly MenuItemSpec[], style: MenuStyle, metrics: UIKitFontMetrics, button: ButtonLayout, bounds?: MenuBounds | null, firstRow?: number): MenuPopupLayout;
+/**
+ * The `firstRow` that brings item `index` into view in a scrollable popup,
+ * moving as little as possible (see `revealRow`). The current `firstRow` when
+ * the popup does not scroll or the item is already visible.
+ */
+export declare function menuRevealRow(items: readonly MenuItemSpec[], style: MenuStyle, layout: MenuPopupLayout, index: number): number;
+/**
+ * The scroll strip under a canvas point of a scrollable popup: -1 for the top
+ * strip, 1 for the bottom one, 0 for neither.
+ */
+export declare function menuScrollStripAt(layout: MenuPopupLayout, px: number, py: number): -1 | 0 | 1;
+/** Scale every length in a menu spec and its styles by `k`. */
+export declare function scaleMenu(spec: MenuButtonSpec, buttonStyle: ButtonStyle, style: MenuStyle, k: number): {
+    spec: MenuButtonSpec;
+    buttonStyle: ButtonStyle;
+    style: MenuStyle;
+};
+/** True when canvas point (px, py) lies inside the popup panel. */
+export declare function popupContains(layout: MenuPopupLayout, px: number, py: number): boolean;
+/** The index of the row under a canvas point, or -1 (separators count as rows). */
+export declare function menuRowAt(layout: MenuPopupLayout, px: number, py: number): number;
+/**
+ * The next selectable index from `from` in `direction`, wrapping around and
+ * skipping separators and disabled items. Pass -1 to start from the end the
+ * search enters at. Returns -1 when nothing is selectable.
+ */
+export declare function nextSelectableIndex(items: readonly MenuItemSpec[], from: number, direction: 1 | -1): number;
+/**
+ * The item states after activating `items[index]`: a check item flips, a
+ * radio item becomes the checked one in its group, anything else is unchanged.
+ * `changed` lists every item whose `checked` differs, the activated one first.
+ */
+export declare function activateMenuItem(items: readonly MenuItemSpec[], index: number): {
+    items: MenuItemSpec[];
+    changed: {
+        id: string;
+        checked: boolean;
+    }[];
+};
+/** Visual state of a menu button: a push button that also shows whether it is open. */
+export interface MenuButtonVisual extends ButtonVisual {
+    open: boolean;
+}
+/**
+ * The draw data for a menu button: the face and label (shifted left to leave
+ * room for the chevron) and a chevron pointing down, or up while open.
+ */
+export declare function buildMenuButton(spec: MenuButtonSpec, buttonStyle: ButtonStyle, style: MenuStyle, metrics: UIKitFontMetrics, layout: ButtonLayout, visual: MenuButtonVisual): {
+    rect: RectData;
+    text: UIKitTextItem;
+    lines: LineData[];
+};
+/**
+ * The draw data for an open popup: the panel, the highlight under
+ * `highlightIndex` (when that item is selectable), then per visible row the
+ * mark (check mark or radio dot when checked), the label, the shortcut and
+ * the separator rules, and on a scrollable popup an arrow on each strip that
+ * has rows beyond it.
+ */
+export declare function buildMenuPopup(items: readonly MenuItemSpec[], style: MenuStyle, metrics: UIKitFontMetrics, layout: MenuPopupLayout, highlightIndex: number): {
+    rects: RectData[];
+    lines: LineData[];
+    text: UIKitTextItem[];
+};

package/dist/menuOverlay.d.ts

@@ -0,0 +1,149 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { ButtonLayout, ButtonStyle } from './button';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { MenuBounds, MenuButtonSpec, MenuItemSpec, MenuPopupLayout, MenuStyle } from './menu';
+import { UIKitFont } from './text/font';
+export interface UIKitMenuOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default button style for every menu; a spec's `buttonStyle` overrides per key. */
+    buttonStyle?: Partial<ButtonStyle>;
+    /** Default popup style for every menu; a spec's `style` overrides per key. */
+    style?: Partial<MenuStyle>;
+    /**
+     * 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 UIKitMenuOverlay implements UIKitOverlayRenderer, UIKitInteractive {
+    readonly hoverCursor = "pointer";
+    private readonly font;
+    private readonly rects;
+    private readonly lines;
+    private readonly labels;
+    private readonly popupRects;
+    private readonly popupLines;
+    private readonly popupText;
+    private readonly entries;
+    private baseButtonStyle;
+    private baseStyle;
+    private readonly cssUnits;
+    private requestRedraw;
+    private layer;
+    private inLayer;
+    private scale;
+    private geometryDirty;
+    private popupDirty;
+    private bounds;
+    private openId;
+    private popup;
+    private highlight;
+    /** First visible row of a scrolled popup (the layout clamps it). */
+    private firstRow;
+    private wheelCarry;
+    /** The button the pointer went down on and still holds. */
+    private pressedId;
+    /** Whether the held press opened the menu (a release then keeps it open). */
+    private pressOpened;
+    private hoverId;
+    private focusedId;
+    constructor(font: UIKitFont, options?: UIKitMenuOverlayOptions);
+    /**
+     * Add a menu, or replace the one with the same id. A replacement takes the
+     * new spec's items and their `checked` states. An open menu stays open and
+     * is laid out again (it may have moved) unless the replacement disables it
+     * or changes its items' ids or kinds: then it closes.
+     */
+    addMenu(spec: MenuButtonSpec): void;
+    /** Replace the whole menu set. */
+    setMenus(specs: readonly MenuButtonSpec[]): void;
+    removeMenu(id: string): void;
+    /** Patch one menu's spec. Items are kept unless the patch sets `items`. */
+    updateMenu(id: string, patch: Partial<Omit<MenuButtonSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Replace a menu's items (closing it if open and the ids or kinds change). */
+    setItems(id: string, items: readonly MenuItemSpec[]): void;
+    /** The current items of a menu (with live `checked` states), or an empty list. */
+    getItems(id: string): readonly MenuItemSpec[];
+    /** A check or radio item's current state. */
+    isItemChecked(menuId: string, itemId: string): boolean;
+    /**
+     * Set a check or radio item's state from code. Fires no callbacks. Checking
+     * a radio unchecks the rest of its group; unchecking one leaves the group empty.
+     */
+    setItemChecked(menuId: string, itemId: string, checked: boolean): void;
+    /** The ids of all menus, in draw order. */
+    get ids(): string[];
+    /** A menu button's box in spec units (canvas pixels, or CSS pixels with `cssUnits`). */
+    getLayout(id: string): ButtonLayout | null;
+    /** The open popup's panel and rows in spec units, or null when no menu is open. */
+    getPopupLayout(): MenuPopupLayout | null;
+    /** The id of the open menu, if any. */
+    get openMenu(): string | null;
+    isOpen(id: string): boolean;
+    /** The index of the highlighted item in the open menu, or -1. */
+    get highlightedIndex(): number;
+    /** The menu button with keyboard focus, if any. */
+    get focusedMenu(): string | null;
+    /** Close an open popup without choosing (the control layer's outside-press hook). */
+    dismiss(): void;
+    /** True while a popup is open: the overlay then wants every event first. */
+    isModal(): boolean;
+    /**
+     * The area popups must stay inside, in canvas pixels. `drawOverlay` refreshes
+     * it from every frame; call it yourself when driving the overlay without one.
+     */
+    setBounds(bounds: MenuBounds | null): void;
+    /**
+     * Open a menu's popup (closing any other) with `highlightIndex` highlighted,
+     * or nothing by default. Opening the already open menu only moves the highlight.
+     */
+    open(id: string, highlightIndex?: number): void;
+    /** Close the open popup, if any, without activating anything. */
+    close(): void;
+    /** Give a menu button keyboard focus, or null to clear. Disabled buttons refuse. */
+    focus(id: string | null): void;
+    hitTest(x: number, y: number): boolean;
+    pointerDown(x: number, y: number): boolean;
+    pointerMove(x: number, y: number): boolean;
+    /** Activates the highlighted row when released over it; a release on the button keeps the menu open. */
+    pointerUp(x: number, y: number): boolean;
+    pointerCancel(): void;
+    /**
+     * While a popup is open the wheel scrolls it by rows (a trackpad's small
+     * deltas add up) and the row under the pointer takes the highlight. Every
+     * wheel turn is consumed while a menu is up; a closed menu ignores it.
+     */
+    wheel(x: number, y: number, _deltaX: number, deltaY: number): boolean;
+    /**
+     * Open: arrows, Home and End move the highlight, Enter or Space activate it,
+     * Escape closes; every other key is swallowed while the menu is up. Closed
+     * and focused: Enter, Space or ArrowDown open the menu on its first item,
+     * ArrowUp on its last.
+     */
+    keyDown(e: UIKitKeyEvent): boolean;
+    blur(): void;
+    bindLayer(layer: UIKitRedrawSource): void;
+    drawOverlay(frame: UIKitOverlayFrame): void;
+    /** Draw the open popup; a control layer calls this after every widget. */
+    drawPopup(frame: UIKitOverlayFrame): void;
+    /** Release GPU resources on both backends. */
+    destroy(): void;
+    private invalidate;
+    /**
+     * Scroll the open popup by `rows` (negative is up), drop a highlight that
+     * scrolled out of view, and re-highlight whatever row is now under (x, y).
+     */
+    private scrollBy;
+    private setHighlight;
+    /** Apply an item's state change, fire the callbacks, and close the menu. */
+    private activate;
+    private scaled;
+    private layoutOf;
+    private popupLayout;
+    /** The topmost (last added) enabled menu button under a canvas point. */
+    private hitEntry;
+    private rebuild;
+    private rebuildPopup;
+}

package/dist/numberInput.d.ts

@@ -0,0 +1,172 @@
+import { LineData } from './line';
+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 number input. All lengths are in canvas pixels. */
+export interface NumberInputStyle {
+    /** 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;
+    /** Border color while the typed text is not a number. */
+    invalidBorder: RGBA;
+    borderWidth: number;
+    radius: number;
+    textColor: RGBA;
+    disabledTextColor: RGBA;
+    /** Label and value 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;
+    /** Width of the spinner column (the up and down buttons) inside the field. */
+    spinnerWidth: number;
+    spinnerFill: RGBA;
+    spinnerHoverFill: RGBA;
+    spinnerPressedFill: RGBA;
+    /** Color of the lines separating the spinner from the text and its two halves. */
+    dividerColor: RGBA;
+    /** Spinner chevron width, stroke width and color. */
+    arrowSize: number;
+    arrowWidth: number;
+    arrowColor: RGBA;
+    caretColor: RGBA;
+    caretWidth: number;
+    /** Color behind selected text. */
+    selectionFill: RGBA;
+}
+export declare const DEFAULT_NUMBER_INPUT_STYLE: NumberInputStyle;
+export interface NumberInputSpec {
+    /** 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;
+    /** Lower bound; omit for none. */
+    min?: number;
+    /** Upper bound; omit for none. */
+    max?: number;
+    /**
+     * Value granularity, counted from `min` (or 0). Omit for any number; the
+     * spinner and arrow keys then move by 1.
+     */
+    step?: number;
+    /** Initial value (clamped and snapped). */
+    value: number;
+    /** Formatter for the displayed value. Default: the step's decimal places. */
+    format?: (value: number) => string;
+    /**
+     * Parser for typed text, returning NaN for text that is not a number.
+     * Default: `Number` on the trimmed text, with empty text invalid.
+     */
+    parse?: (text: string) => number;
+    /** A disabled input draws dimmed and ignores input. Default true. */
+    enabled?: boolean;
+    /** Per-input overrides of the overlay's default style. */
+    style?: Partial<NumberInputStyle>;
+    /**
+     * Fired while the user edits: for every keystroke that leaves a valid
+     * number different from the last one reported, and for every step.
+     */
+    onInput?: (value: number, id: string) => void;
+    /**
+     * Fired once when a changed value is committed: on Enter, on losing focus,
+     * and on every step (spinner, arrow keys, wheel).
+     */
+    onChange?: (value: number, id: string) => void;
+}
+/** The control's boxes in canvas pixels. */
+export interface NumberInputLayout {
+    /** 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: the field left of the spinner. */
+    textArea: UIKitBox;
+    spinUp: UIKitBox;
+    spinDown: UIKitBox;
+    /** Baseline of the label and the field text. */
+    baseline: number;
+}
+/** The transient state that changes how a number input looks. */
+export interface NumberInputVisual {
+    /** The text shown: the formatted value, 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;
+    /** False while the text is not a number. */
+    valid: boolean;
+    hover: boolean;
+    /** The spinner half under the pointer: 1 up, -1 down, 0 neither. */
+    spinHover: 1 | -1 | 0;
+    /** The spinner half held down. */
+    spinPressed: 1 | -1 | 0;
+    enabled: boolean;
+}
+export declare function resolveNumberInputStyle(base: NumberInputStyle, override?: Partial<NumberInputStyle>): NumberInputStyle;
+type Range = Pick<NumberInputSpec, 'min' | 'max' | 'step'>;
+/** Clamp `value` into the spec's bounds and snap it to its step grid. NaN clamps to the low end, or 0. */
+export declare function snapNumberInput(spec: Range, value: number): number;
+/** Move `value` by one step (ten with `big`) in `direction`, snapped. */
+export declare function stepNumberInput(spec: Range, value: number, direction: 1 | -1, big?: boolean): number;
+/** The displayed text for a value: the spec's formatter, else the step's precision. */
+export declare function formatNumberInput(spec: Pick<NumberInputSpec, 'step' | 'format'>, value: number): string;
+/** The number typed text means, or NaN when it is not one. */
+export declare function parseNumberInput(spec: Pick<NumberInputSpec, 'parse'>, text: string): number;
+/** True for a character a number field accepts from the keyboard. */
+export declare function acceptNumberChar(ch: string): boolean;
+/** The control's boxes for a spec. */
+export declare function layoutNumberInput(spec: NumberInputSpec, style: NumberInputStyle, metrics: UIKitFontMetrics): NumberInputLayout;
+/** Scale every length in a spec and style by `k` (CSS pixels to canvas pixels). */
+export declare function scaleNumberInput(spec: NumberInputSpec, style: NumberInputStyle, k: number): {
+    spec: NumberInputSpec;
+    style: NumberInputStyle;
+};
+/** True when canvas point (px, py) lies inside the field (the label is not interactive). */
+export declare function numberInputContains(layout: NumberInputLayout, px: number, py: number): boolean;
+/** The spinner half under a canvas point: 1 up, -1 down, 0 neither. */
+export declare function numberInputSpinAt(layout: NumberInputLayout, px: number, py: number): 1 | -1 | 0;
+/**
+ * The run of glyphs the text area shows, starting at `firstGlyph` but
+ * scrolled the least distance that keeps `caret` in view.
+ */
+export declare function numberInputTextWindow(layout: NumberInputLayout, style: NumberInputStyle, metrics: UIKitFontMetrics, text: string, firstGlyph: number, caret: number): ScrollWindow;
+/** The caret index for a canvas x over text shown from `firstGlyph`. */
+export declare function numberInputCaretAt(layout: NumberInputLayout, style: NumberInputStyle, metrics: UIKitFontMetrics, text: string, firstGlyph: number, px: number): number;
+/**
+ * The draw data for one number input in one visual state: the field, the
+ * spinner with its chevrons, the selection, the visible run of text, the
+ * caret and the label.
+ */
+export declare function buildNumberInput(spec: NumberInputSpec, style: NumberInputStyle, layout: NumberInputLayout, metrics: UIKitFontMetrics, visual: NumberInputVisual): {
+    rects: RectData[];
+    lines: LineData[];
+    text: UIKitTextItem[];
+};
+export {};

package/dist/numberInputOverlay.d.ts

@@ -0,0 +1,131 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { NumberInputLayout, NumberInputSpec, NumberInputStyle } from './numberInput';
+import { UIKitFont } from './text/font';
+export interface UIKitNumberInputOverlayOptions {
+    /** 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<NumberInputStyle>;
+    /**
+     * 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;
+    /** Wheel pixels per step over a focused field. Default 40. */
+    wheelStepPx?: number;
+}
+export declare class UIKitNumberInputOverlay implements UIKitOverlayRenderer, UIKitInteractive {
+    private readonly font;
+    private readonly rects;
+    private readonly lines;
+    private readonly labels;
+    private readonly entries;
+    private baseStyle;
+    private readonly cssUnits;
+    private readonly wheelCarry;
+    private requestRedraw;
+    private layer;
+    private scale;
+    private geometryDirty;
+    private hoverId;
+    private cursor;
+    private focusedId;
+    /** The held press: which input and what part of it. */
+    private pressId;
+    private pressPart;
+    constructor(font: UIKitFont, options?: UIKitNumberInputOverlayOptions);
+    /** CSS cursor for the hovered part: a text beam over the field, a pointer over the spinner. */
+    get hoverCursor(): string;
+    /** Replace the default style for every input (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<NumberInputStyle>): void;
+    /**
+     * Add an input, or replace the one with the same id. The spec's `value` is
+     * clamped and snapped; a replacement takes the new spec's value and ends
+     * any edit in progress.
+     */
+    addNumberInput(spec: NumberInputSpec): void;
+    /** Replace the whole input set. */
+    setNumberInputs(specs: readonly NumberInputSpec[]): void;
+    removeNumberInput(id: string): void;
+    /**
+     * Patch one input's spec (label, position, range, step, enabled, ...). The
+     * committed value is kept (re-snapped to the new range) unless the patch
+     * sets `value`.
+     */
+    updateNumberInput(id: string, patch: Partial<Omit<NumberInputSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Set an input's value from code (clamped and snapped). Fires neither callback. */
+    setValue(id: string, value: number): void;
+    /** The committed value. */
+    getValue(id: string): number | undefined;
+    /** The text the field shows: the edit in progress, or the formatted value. */
+    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): NumberInputLayout | null;
+    /** The input with keyboard focus (being edited), if any. */
+    get focusedInput(): string | null;
+    /**
+     * Give an input keyboard focus with its whole number 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;
+    /**
+     * On the spinner: steps and commits. On the text: focuses (selecting all),
+     * or places the caret when already focused, and starts a drag selection.
+     */
+    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; Escape reverts; ArrowUp and
+     * ArrowDown step (Shift: ten steps), as do PageUp and PageDown.
+     */
+    /** Enter commits the field and, in a dialog, submits it. */
+    submitsForm(e: UIKitKeyEvent): boolean;
+    keyDown(e: UIKitKeyEvent): boolean;
+    /** The wheel over a focused field steps it (the page scrolls elsewhere). */
+    wheel(x: number, y: number, _deltaX: number, deltaY: number): 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;
+    private display;
+    /** The edit state for a freshly focused (or reverted) input: all selected. */
+    private freshEdit;
+    /** The typed text as a snapped value, or NaN while it is not a number. */
+    private typedValue;
+    /** Fire `onInput` when the typed number differs from the last one reported. */
+    private reportInput;
+    /**
+     * Commit the edit: a valid number becomes the value (firing `onChange` if
+     * it changed), invalid text reverts. The text is re-formatted and, when the
+     * input stays focused, selected again.
+     */
+    private commit;
+    /** Step from the typed number (or the value when the text is invalid) and commit. */
+    private step;
+    /** 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, step, commit).
+     */
+    private firstShown;
+    private scaled;
+    private layoutOf;
+    /** The topmost (last added) enabled input whose field is under a canvas point. */
+    private hitEntry;
+    private rebuild;
+}