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

package/dist/dialog.d.ts

@@ -0,0 +1,138 @@
+import { ButtonStyle } from './button';
+import { RectData } from './rect';
+import { UIKitBox } from './scroll';
+import { UIKitFontMetrics } from './text/font';
+import { RGBA } from './text/layout';
+import { UIKitTextItem } from './textOverlay';
+/** Every visual knob on a dialog. All lengths are in canvas pixels. */
+export interface DialogStyle {
+    /** Color laid over the whole canvas behind the panel. */
+    scrim: RGBA;
+    fill: RGBA;
+    border: RGBA;
+    borderWidth: number;
+    radius: number;
+    /** Panel width when the spec gives none. */
+    width: number;
+    /** Space between the panel edge and its contents. */
+    padding: number;
+    /** Vertical space between the title, message, content box and buttons. */
+    gap: number;
+    titleColor: RGBA;
+    titleSizePx: number;
+    textColor: RGBA;
+    textSizePx: number;
+    /** Message line height as a multiple of `textSizePx`. */
+    lineHeight: number;
+    /** Space between action buttons. */
+    buttonGap: number;
+    /** Style overrides for the action buttons. */
+    button: Partial<ButtonStyle>;
+    /** Further overrides for the button with the `default` role. */
+    defaultButton: Partial<ButtonStyle>;
+}
+export declare const DEFAULT_DIALOG_STYLE: DialogStyle;
+export type DialogButtonRole = 'default' | 'cancel' | 'normal';
+export interface DialogButtonSpec {
+    /** The result `onClose` reports when this button closes the dialog. */
+    id: string;
+    label: string;
+    /**
+     * `default` is what Enter presses (drawn in the accent style); `cancel` is
+     * what Escape presses. Default `normal`.
+     */
+    role?: DialogButtonRole;
+    enabled?: boolean;
+}
+/** The panel's boxes the host needs to place widgets, in spec units. */
+export interface DialogBoxes {
+    panel: UIKitBox;
+    /** The space reserved by `contentHeight`, between the message and the buttons. */
+    content: UIKitBox;
+}
+export interface DialogSpec {
+    /** Stable key: the handle for opening, closing and the callbacks. */
+    id: string;
+    title?: string;
+    /** Body text; wrapped to the panel width, with '\n' forcing a line break. */
+    message?: string;
+    /** Top-left corner of the panel. Omit both to center it in the canvas. */
+    x?: number;
+    y?: number;
+    /** Panel width. Default: the style's `width`. */
+    width?: number;
+    /** Height reserved for hosted widgets between the message and the buttons. */
+    contentHeight?: number;
+    /** Action buttons, drawn right-aligned in the order given. */
+    buttons?: readonly DialogButtonSpec[];
+    /** A press on the scrim closes the dialog with a null result. Default false. */
+    closeOnScrim?: boolean;
+    /** Per-dialog overrides of the overlay's default style. */
+    style?: Partial<DialogStyle>;
+    /**
+     * Fired when the panel is placed or moves (first draw, a canvas resize),
+     * with its boxes in spec units: position hosted widgets here.
+     */
+    onLayout?: (boxes: DialogBoxes, id: string) => void;
+    /** Fired when the dialog closes: the button id, or null for Escape and the scrim. */
+    onClose?: (result: string | null, id: string) => void;
+}
+/** The dialog's boxes in canvas pixels. */
+export interface DialogLayout {
+    panel: UIKitBox;
+    /** Title baseline, or null without a title. */
+    title: {
+        x: number;
+        y: number;
+    } | null;
+    /** Wrapped message lines with their baselines. */
+    lines: {
+        str: string;
+        x: number;
+        y: number;
+    }[];
+    content: UIKitBox;
+    /** Resting boxes for the action buttons, right-aligned. */
+    buttons: {
+        id: string;
+        box: UIKitBox;
+    }[];
+}
+/** What `layoutDialog` needs to know about each button: its resting size. */
+export interface DialogButtonSize {
+    id: string;
+    width: number;
+    height: number;
+}
+export declare function resolveDialogStyle(base: DialogStyle, override?: Partial<DialogStyle>): DialogStyle;
+/**
+ * Break `text` into lines no wider than `maxWidth`: at '\n', else at the last
+ * space that fits; a single word wider than the line stays whole.
+ */
+export declare function wrapText(metrics: UIKitFontMetrics, text: string, sizePx: number, maxWidth: number): string[];
+/**
+ * The panel's boxes for a spec, centered in `bounds` unless the spec gives a
+ * position. `buttonSizes` are the action buttons' resting sizes in order.
+ */
+export declare function layoutDialog(spec: DialogSpec, style: DialogStyle, metrics: UIKitFontMetrics, buttonSizes: readonly DialogButtonSize[], bounds: {
+    width: number;
+    height: number;
+}): DialogLayout;
+/** Scale every length in a spec and style by `k` (CSS pixels to canvas pixels). */
+export declare function scaleDialog(spec: DialogSpec, style: DialogStyle, k: number): {
+    spec: DialogSpec;
+    style: DialogStyle;
+};
+/** True when canvas point (px, py) lies inside the panel. */
+export declare function dialogContains(layout: DialogLayout, px: number, py: number): boolean;
+/**
+ * The draw data for an open dialog: the scrim over `bounds`, the panel, the
+ * title and the message lines. The action buttons are a button overlay's.
+ */
+export declare function buildDialog(spec: DialogSpec, style: DialogStyle, layout: DialogLayout, bounds: {
+    width: number;
+    height: number;
+}): {
+    rects: RectData[];
+    text: UIKitTextItem[];
+};

package/dist/dialogOverlay.d.ts

@@ -0,0 +1,115 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { DialogBoxes, DialogSpec, DialogStyle } from './dialog';
+import { UIKitFont } from './text/font';
+export interface UIKitDialogOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default style for every dialog; a spec's `style` overrides per key. */
+    style?: Partial<DialogStyle>;
+    /**
+     * 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;
+    /** Clock for the button press animation. Default `performance.now`. */
+    now?: () => number;
+}
+export declare class UIKitDialogOverlay implements UIKitOverlayRenderer, UIKitInteractive {
+    private readonly font;
+    private readonly rects;
+    private readonly labels;
+    private readonly entries;
+    private baseStyle;
+    private readonly cssUnits;
+    private readonly now;
+    private requestRedraw;
+    private layer;
+    private childLayer;
+    private inLayer;
+    private scale;
+    private bounds;
+    private geometryDirty;
+    private openId;
+    /** The member (a child or the button row) owning the pointer, and the focused one. */
+    private captured;
+    private focused;
+    private hovered;
+    constructor(font: UIKitFont, options?: UIKitDialogOverlayOptions);
+    /** CSS cursor: the captured or hovered member's, else the default over the panel. */
+    get hoverCursor(): string | undefined;
+    /** Replace the default style for every dialog (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<DialogStyle>): void;
+    /** Add a dialog, or replace the one with the same id (keeping its children). */
+    addDialog(spec: DialogSpec): void;
+    removeDialog(id: string): void;
+    /** Patch one dialog's spec (title, message, buttons, position, ...). */
+    updateDialog(id: string, patch: Partial<Omit<DialogSpec, 'id'>>): void;
+    /** Host a widget in a dialog: routed and drawn while the dialog is open. */
+    addChild(id: string, child: UIKitInteractive): void;
+    removeChild(id: string, child: UIKitInteractive): void;
+    /** The ids of all dialogs. */
+    get ids(): string[];
+    /** The open dialog's id, if any. */
+    get openDialog(): string | null;
+    isOpen(id: string): boolean;
+    /** Open a dialog (closing any other with a null result). */
+    open(id: string): void;
+    /** Close the open dialog, reporting `result` through its `onClose`. */
+    close(result?: string | null): void;
+    /**
+     * Press an action button of the open dialog from code, as a click would:
+     * the dialog closes at once and fires `onClose` with the button's id.
+     */
+    click(buttonId: string): void;
+    /** The open dialog's boxes in spec units, once it has been laid out. */
+    getBoxes(id: string): DialogBoxes | null;
+    /**
+     * The area the panel centers in, in canvas pixels. `drawOverlay` refreshes
+     * it from every frame; call it yourself when driving the overlay without one.
+     */
+    setBounds(bounds: {
+        width: number;
+        height: number;
+    }): void;
+    isModal(): boolean;
+    /** A press or focus elsewhere in the page: the children lose focus, the dialog stays. */
+    dismiss(): void;
+    blur(): void;
+    /** The whole canvas while open (the dialog is modal), else nothing. */
+    hitTest(_x: number, _y: number): boolean;
+    pointerDown(x: number, y: number): boolean;
+    pointerMove(x: number, y: number): boolean;
+    pointerUp(x: number, y: number): boolean;
+    pointerCancel(): void;
+    /**
+     * A modal child sees the key first and keeps what it takes. Then the
+     * focused child keeps what it takes, unless it says the key submits the
+     * form (Enter in a text or number field, as in an HTML form). Otherwise
+     * Enter presses the default button and Escape the cancel button (or
+     * closes with null). Every other key is swallowed while open.
+     */
+    keyDown(e: UIKitKeyEvent): boolean;
+    /** A modal child, else the child under the point, may scroll; the page never does. */
+    wheel(x: number, y: number, deltaX: number, deltaY: number): boolean;
+    bindLayer(layer: UIKitRedrawSource): void;
+    drawOverlay(frame: UIKitOverlayFrame): void;
+    /** Draw the open dialog; a control layer calls this after every widget. */
+    drawPopup(frame: UIKitOverlayFrame): void;
+    /** Release the surfaces, the action buttons and every hosted child. */
+    destroy(): void;
+    private invalidate;
+    private openEntry;
+    /** The routing order, topmost first: the button row, then the children last added first. */
+    private members;
+    private modalChild;
+    private setFocus;
+    private scaled;
+    private boxesOf;
+    /**
+     * Lay the panel out (sizing the buttons first), place the buttons, and
+     * report the boxes to `onLayout` when they changed. The button overlay
+     * shares the dialog's units, so it is fed spec-unit positions.
+     */
+    private layoutOf;
+}

package/dist/filePicker.d.ts

@@ -0,0 +1,95 @@
+import { ButtonLayout, ButtonStyle } from './button';
+import { UIKitFontMetrics } from './text/font';
+import { RGBA } from './text/layout';
+import { UIKitTextItem } from './textOverlay';
+/** Every visual knob on a file picker. All lengths are in canvas pixels. */
+export interface FilePickerStyle {
+    /** Overrides for the "Choose file" button. */
+    button: Partial<ButtonStyle>;
+    /** Space between the button and the readout. */
+    gap: number;
+    /** Readout color once something was chosen. */
+    textColor: RGBA;
+    /** Readout color while nothing is chosen (the placeholder). */
+    emptyTextColor: RGBA;
+    disabledTextColor: RGBA;
+    /** Readout em size. */
+    textSizePx: number;
+    /** Halo outline width around the readout (it sits on the scene); 0 draws none. */
+    textOutlineWidth: number;
+    /** Halo color; null picks black or white against the readout color. */
+    textOutlineColor: RGBA | null;
+    /** Readout width when the spec gives no width. */
+    readoutWidth: number;
+}
+export declare const DEFAULT_FILE_PICKER_STYLE: FilePickerStyle;
+export interface FilePickerSpec {
+    /** Stable key: the handle for updates and the callbacks. */
+    id: string;
+    /** Button label. Default "Choose file...". */
+    label?: string;
+    /** Top-left corner of the row, in canvas pixels. */
+    x: number;
+    y: number;
+    /** Width of the whole row; the readout gets what the button leaves. */
+    width?: number;
+    /** Readout while nothing is chosen. Default "No file chosen". */
+    placeholder?: string;
+    /** `accept` for the host chooser: ".nii,.nii.gz" or MIME types. */
+    accept?: string;
+    multiple?: boolean;
+    /** Choose a directory (every file inside it) instead of files. */
+    directory?: boolean;
+    /** A disabled picker draws dimmed and ignores the pointer. Default true. */
+    enabled?: boolean;
+    /** Per-picker overrides of the overlay's default style. */
+    style?: Partial<FilePickerStyle>;
+    /** Fired with the chosen files once the chooser closes with a choice. */
+    onPick?: (files: File[], id: string) => void;
+    /** Fired when the chooser closes without a choice. */
+    onCancel?: (id: string) => void;
+}
+export declare const DEFAULT_FILE_PICKER_LABEL = "Choose file...";
+export declare const DEFAULT_FILE_PICKER_PLACEHOLDER = "No file chosen";
+/** The resting boxes of a picker, in canvas pixels. */
+export interface FilePickerLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    button: ButtonLayout;
+    /** Left edge and baseline of the readout. */
+    textX: number;
+    baseline: number;
+    /** Space available to the readout. */
+    readoutWidth: number;
+}
+export interface FilePickerVisual {
+    /** Names of the chosen files; empty shows the placeholder. */
+    names: readonly string[];
+    enabled: boolean;
+}
+export declare function resolveFilePickerStyle(base: FilePickerStyle, override?: Partial<FilePickerStyle>): FilePickerStyle;
+/** The button style a picker's button is laid out and drawn with. */
+export declare function filePickerButtonStyle(style: FilePickerStyle): ButtonStyle;
+/** What the readout says for a set of chosen names. */
+export declare function filePickerSummary(names: readonly string[], placeholder?: string): string;
+/**
+ * Trim a string to `maxWidth` at `sizePx`, keeping its tail (a file's
+ * extension is the informative end) behind a leading "...".
+ */
+export declare function ellipsizeStart(metrics: UIKitFontMetrics, str: string, sizePx: number, maxWidth: number): string;
+export declare function layoutFilePicker(spec: FilePickerSpec, style: FilePickerStyle, metrics: UIKitFontMetrics): FilePickerLayout;
+/**
+ * Scale a spec and style by `k` (CSS to device pixels). The button overrides
+ * come back as a full button style, so a layout of the result agrees with a
+ * button overlay scaling the same picker.
+ */
+export declare function scaleFilePicker(spec: FilePickerSpec, style: FilePickerStyle, k: number): {
+    spec: FilePickerSpec;
+    style: FilePickerStyle;
+};
+/** The readout text of a picker; its button is drawn by a button overlay. */
+export declare function buildFilePicker(spec: FilePickerSpec, style: FilePickerStyle, layout: FilePickerLayout, metrics: UIKitFontMetrics, visual: FilePickerVisual): {
+    text: UIKitTextItem[];
+};

package/dist/filePickerOverlay.d.ts

@@ -0,0 +1,75 @@
+import { UIKitOverlayFrame, UIKitOverlayRenderer } from '@niivue/niivue';
+import { UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource } from './controls';
+import { FilePickerLayout, FilePickerSpec, FilePickerStyle } from './filePicker';
+import { FilePickerBridge } from './host';
+import { UIKitFont } from './text/font';
+export interface UIKitFilePickerOverlayOptions {
+    /** Called whenever the overlay needs another frame. A control layer fills it in. */
+    requestRedraw?: () => void;
+    /** Default style for every picker; a spec's `style` overrides per key. */
+    style?: Partial<FilePickerStyle>;
+    /**
+     * 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;
+    /** The host's file chooser. Defaults to a hidden `<input type="file">`. */
+    pickFiles?: FilePickerBridge;
+}
+export declare class UIKitFilePickerOverlay implements UIKitOverlayRenderer, UIKitInteractive {
+    readonly hoverCursor = "pointer";
+    private readonly font;
+    private readonly buttons;
+    private readonly labels;
+    private readonly entries;
+    private baseStyle;
+    private readonly cssUnits;
+    private requestRedraw;
+    private pickFiles;
+    private scale;
+    private geometryDirty;
+    constructor(font: UIKitFont, options?: UIKitFilePickerOverlayOptions);
+    /** Replace the default style for every picker (per-spec overrides still win). */
+    setDefaultStyle(style: Partial<FilePickerStyle>): void;
+    /** Add a picker, or replace the one with the same id (keeping its files). */
+    addFilePicker(spec: FilePickerSpec): void;
+    setFilePickers(specs: readonly FilePickerSpec[]): void;
+    removeFilePicker(id: string): void;
+    /** Patch one picker's spec (label, position, accept, callbacks, ...). */
+    updateFilePicker(id: string, patch: Partial<Omit<FilePickerSpec, 'id'>>): void;
+    setEnabled(id: string, enabled: boolean): void;
+    /** Show these files (or names) as chosen without firing callbacks. */
+    setFiles(id: string, files: readonly (File | string)[]): void;
+    /** The names a picker shows as chosen. */
+    getFiles(id: string): string[] | undefined;
+    get ids(): string[];
+    /** A picker's boxes in spec units, or null for an unknown id. */
+    getLayout(id: string): FilePickerLayout | null;
+    /** True while the host chooser is open for the picker. */
+    isPending(id: string): boolean;
+    /**
+     * Open the host chooser for a picker as if its button were pressed. Call it
+     * from a pointer or key handler: browsers only open a chooser inside a user
+     * activation.
+     */
+    open(id: string): void;
+    hitTest(x: number, y: number): boolean;
+    pointerDown(x: number, y: number): boolean;
+    pointerMove(x: number, y: number): boolean;
+    pointerUp(x: number, y: number): boolean;
+    pointerCancel(): void;
+    /** Enter or Space presses the last-pressed button. */
+    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 rebuild;
+    private layoutOf;
+    /** Create or move a picker's button, in spec units. */
+    private placeButton;
+    /** Ask the host for files and report the outcome to the picker's callbacks. */
+    private pick;
+}

package/dist/host.d.ts

@@ -0,0 +1,87 @@
+/** What a file picker asks the host for, mirroring `<input type="file">`. */
+export interface FilePickerOptions {
+    /** Comma-separated extensions or MIME types, as the `accept` attribute. */
+    accept?: string;
+    multiple?: boolean;
+    /** Pick a directory (every file inside it) instead of files. */
+    directory?: boolean;
+}
+/**
+ * Open the host's file chooser and resolve with the files picked, or with an
+ * empty array when the user cancels. Call it synchronously from a pointer or
+ * key handler: browsers only open a chooser inside a user activation.
+ */
+export type FilePickerBridge = (options: FilePickerOptions) => Promise<File[]>;
+/** Save a blob to the host under a file name (a browser "download"). */
+export type DownloadBridge = (blob: Blob, filename: string) => void;
+/** The subset of a Document the browser file picker uses. */
+export interface FilePickerDocument {
+    createElement(tagName: 'input'): HTMLInputElement;
+    body: Pick<HTMLElement, 'appendChild' | 'removeChild'>;
+}
+/** The subset of a Window the browser bridges use: timers and focus. */
+export interface BridgeWindow {
+    setTimeout(handler: () => void, ms: number): number;
+    clearTimeout(id: number): void;
+    addEventListener(type: 'focus', listener: () => void): void;
+    removeEventListener(type: 'focus', listener: () => void): void;
+}
+/**
+ * How long after the window regains focus a chooser with neither a `change`
+ * nor a `cancel` event counts as cancelled. A pick's `change` can trail the
+ * focus, so this leaves it room.
+ */
+export declare const FILE_PICKER_CANCEL_GRACE_MS = 1000;
+/**
+ * How long a download keeps its object URL: revoking it in the tick that
+ * clicks the anchor can cancel the download before it starts.
+ */
+export declare const DOWNLOAD_REVOKE_DELAY_MS = 40000;
+/**
+ * A file picker that drives a hidden `<input type="file">`. The input is
+ * attached to the body while the chooser is open (some browsers ignore a
+ * detached input) and removed once it settles. Cancelling resolves to an
+ * empty array through the input's `cancel` event or, where there is none
+ * (Safari before 16.4, Chrome before 113), once the window has had focus
+ * back for `FILE_PICKER_CANCEL_GRACE_MS` with no pick. `directory` sets
+ * `webkitdirectory`, which every current engine honours.
+ */
+export declare function createBrowserFilePicker(doc?: FilePickerDocument, win?: BridgeWindow): FilePickerBridge;
+/** The subset of a Document and URL the browser download uses. */
+export interface DownloadDocument {
+    createElement(tagName: 'a'): HTMLAnchorElement;
+    body: Pick<HTMLElement, 'appendChild' | 'removeChild'>;
+}
+export interface DownloadUrlFactory {
+    createObjectURL(blob: Blob): string;
+    revokeObjectURL(url: string): void;
+}
+/**
+ * A download that clicks a temporary anchor with a `download` name over an
+ * object URL of the blob, then revokes the URL `DOWNLOAD_REVOKE_DELAY_MS`
+ * later.
+ */
+export declare function createBrowserDownload(doc?: DownloadDocument, urls?: DownloadUrlFactory, win?: Pick<BridgeWindow, 'setTimeout'>): DownloadBridge;
+/** A `.ext` list or MIME list from file extensions, for `FilePickerOptions.accept`. */
+export declare function acceptExtensions(extensions: readonly string[]): string;
+/**
+ * The clipboard a text widget copies to and pastes from. `write` puts text
+ * on it; `read` resolves with its text, or with an empty string when it
+ * holds none or the host refuses. Browsers grant both only inside a user
+ * activation, so the widgets call them synchronously from a key handler.
+ */
+export interface ClipboardBridge {
+    write(text: string): void;
+    read(): Promise<string>;
+}
+/** The subset of `navigator.clipboard` the browser clipboard bridge uses. */
+export interface ClipboardSource {
+    readText(): Promise<string>;
+    writeText(text: string): Promise<void>;
+}
+/**
+ * A clipboard bridge over the async clipboard API. Without a source (an
+ * insecure context, or no navigator) writes are dropped and reads resolve
+ * empty; a refused read also resolves empty.
+ */
+export declare function createBrowserClipboard(source?: ClipboardSource | undefined): ClipboardBridge;

package/dist/index.d.ts

@@ -1,19 +1,80 @@
 export type { AnnotationGeometryOptions } from './annotationOverlay';
 export { buildAnnotationGeometry, UIKitAnnotationOverlay, } from './annotationOverlay';
+export type { ButtonLayout, ButtonSpec, ButtonStyle, ButtonVisual, } from './button';
+export { DEFAULT_BUTTON_STYLE } from './button';
+export type { UIKitButtonHost, UIKitButtonOverlayOptions, } from './buttonOverlay';
+export { UIKitButtonOverlay } from './buttonOverlay';
+export type { ColorChannel, ColorControlLayout, ColorControlSpec, ColorControlStyle, ColorControlVisual, ColorSwatch, } from './colorControl';
+export { DEFAULT_COLOR_CONTROL_STYLE } from './colorControl';
+export type { UIKitColorControlOverlayOptions } from './colorControlOverlay';
+export { UIKitColorControlOverlay } from './colorControlOverlay';
+export type { UIKitControlsOptions, UIKitHost, UIKitInteractive, UIKitKeyEvent, UIKitRedrawSource, } from './controls';
+export { UIKitControls } from './controls';
 export type { CrosshairGeometry, CrosshairSpec } from './crosshair';
 export { buildCrosshair } from './crosshair';
 export type { CrosshairPlacement } from './crosshairOverlay';
 export { UIKitCrosshairOverlay } from './crosshairOverlay';
+export type { DialogBoxes, DialogButtonRole, DialogButtonSize, DialogButtonSpec, DialogLayout, DialogSpec, DialogStyle, } from './dialog';
+export { DEFAULT_DIALOG_STYLE } from './dialog';
+export type { UIKitDialogOverlayOptions } from './dialogOverlay';
+export { UIKitDialogOverlay } from './dialogOverlay';
+export type { FilePickerLayout, FilePickerSpec, FilePickerStyle, FilePickerVisual, } from './filePicker';
+export { DEFAULT_FILE_PICKER_LABEL, DEFAULT_FILE_PICKER_PLACEHOLDER, DEFAULT_FILE_PICKER_STYLE, } from './filePicker';
+export type { UIKitFilePickerOverlayOptions } from './filePickerOverlay';
+export { UIKitFilePickerOverlay } from './filePickerOverlay';
+export type { BridgeWindow, ClipboardBridge, ClipboardSource, DownloadBridge, DownloadDocument, DownloadUrlFactory, FilePickerBridge, FilePickerDocument, FilePickerOptions, } from './host';
+export { acceptExtensions, createBrowserClipboard, createBrowserDownload, createBrowserFilePicker, DOWNLOAD_REVOKE_DELAY_MS, FILE_PICKER_CANCEL_GRACE_MS, } from './host';
 export type { LineData, LineTerminators } from './line';
 export { buildLine, buildTerminatedLine, LineTerminator } from './line';
 export { UIKitLineOverlay } from './lineOverlay';
+export type { MenuBounds, MenuButtonSpec, MenuButtonVisual, MenuItemKind, MenuItemSpec, MenuPopupLayout, MenuRowLayout, MenuStyle, } from './menu';
+export { DEFAULT_MENU_BUTTON_STYLE, DEFAULT_MENU_STYLE, } from './menu';
+export type { UIKitMenuOverlayOptions } from './menuOverlay';
+export { UIKitMenuOverlay } from './menuOverlay';
+export type { NumberInputLayout, NumberInputSpec, NumberInputStyle, NumberInputVisual, } from './numberInput';
+export { DEFAULT_NUMBER_INPUT_STYLE } from './numberInput';
+export type { UIKitNumberInputOverlayOptions } from './numberInputOverlay';
+export { UIKitNumberInputOverlay } from './numberInputOverlay';
+export type { PointLabelBounds, PointLabelGeometry, PointLabelSpec, } from './pointLabel';
+export { buildPointLabel } from './pointLabel';
+export type { MMPoint, MMProjector, PointLabelPlacement, } from './pointLabelOverlay';
+export { UIKitPointLabelOverlay } from './pointLabelOverlay';
+export type { RectData, RectSpec } from './rect';
+export { buildRect } from './rect';
+export { UIKitRectOverlay } from './rectOverlay';
 export type { RulerGeometry, RulerSpec, Vec2 } from './ruler';
 export { buildRuler } from './ruler';
 export { UIKitRulerOverlay } from './rulerOverlay';
+export type { ScrollRange, ScrollStripStyle, ScrollWindow, UIKitBox, } from './scroll';
+export type { SegmentedLayout, SegmentedSpec, SegmentedStyle, SegmentedVisual, SegmentLayout, SegmentSpec, } from './segmented';
+export { DEFAULT_SEGMENTED_STYLE } from './segmented';
+export type { UIKitSegmentedOverlayOptions } from './segmentedOverlay';
+export { UIKitSegmentedOverlay } from './segmentedOverlay';
+export type { SelectOption, SelectSpec } from './select';
+export type { UIKitSelectOverlayOptions } from './selectOverlay';
+export { UIKitSelectOverlay } from './selectOverlay';
+export type { SliderLayout, SliderSpec, SliderStyle, SliderVisual, } from './slider';
+export { DEFAULT_SLIDER_STYLE } from './slider';
+export type { UIKitSliderOverlayOptions } from './sliderOverlay';
+export { UIKitSliderOverlay } from './sliderOverlay';
 export { loadDefaultFont } from './text/defaultFont';
 export type { RawFontFile, UIKitFont, UIKitFontMetrics, UIKitGlyph, } from './text/font';
 export { parseFont, screenPxRange } from './text/font';
 export type { RGBA, TextLayoutOptions } from './text/layout';
 export { autoOutlineColor, layoutText, measureWidth, readableAngle, } from './text/layout';
+export type { TextAreaLayout, TextAreaSpec, TextAreaStyle, TextAreaVisual, TextRow, } from './textArea';
+export { DEFAULT_TEXT_AREA_STYLE } from './textArea';
+export type { UIKitTextAreaOverlayOptions } from './textAreaOverlay';
+export { UIKitTextAreaOverlay } from './textAreaOverlay';
+export type { TextEditState } from './textEdit';
+export type { TextFieldStyle } from './textField';
+export type { TextInputLayout, TextInputSpec, TextInputStyle, TextInputVisual, } from './textInput';
+export { DEFAULT_TEXT_INPUT_STYLE } from './textInput';
+export type { UIKitTextInputOverlayOptions } from './textInputOverlay';
+export { UIKitTextInputOverlay } from './textInputOverlay';
 export type { UIKitTextItem } from './textOverlay';
 export { UIKitTextOverlay } from './textOverlay';
+export type { ToggleLayout, ToggleSpec, ToggleStyle, ToggleVisual, } from './toggle';
+export { DEFAULT_TOGGLE_STYLE } from './toggle';
+export type { UIKitToggleOverlayOptions } from './toggleOverlay';
+export { UIKitToggleOverlay } from './toggleOverlay';