@webority/ui-elements 0.149.0 → 0.150.0

package/types/WuiCarousel.d.ts

@@ -0,0 +1,64 @@
+import { ElementBase } from "./elementBase.ts";
+/** The words the element says on its own. */
+export declare const CAROUSEL_TEXT: Readonly<{
+    slide: (n: number, total: number) => string;
+    status: (first: number, last: number, total: number) => string;
+    dot: "Go to slide";
+    pause: "Pause";
+    play: "Play";
+}>;
+export declare class WuiCarousel extends ElementBase {
+    _page: number;
+    _pages: number;
+    _perView: number;
+    _paused: boolean;
+    _hover: boolean;
+    _focus: boolean;
+    _timer: ReturnType<typeof setTimeout> | null;
+    _settleTimer: ReturnType<typeof setTimeout> | null;
+    _status: string;
+    _ready: boolean;
+    _motion: MediaQueryList | null;
+    _mutations: MutationObserver | null;
+    _resizer: ResizeObserver | null;
+    _doc: Document | null;
+    _track: HTMLElement | null;
+    _onClick: (e: MouseEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onScroll: () => void;
+    _onEnter: () => void;
+    _onLeave: () => void;
+    _onFocusIn: () => void;
+    _onFocusOut: (e: FocusEvent) => void;
+    _onVisibility: () => void;
+    _onMotion: () => void;
+    _tick: () => void;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    /** Whether the user stopped the autoplay with the pause control. */
+    get paused(): boolean;
+    set paused(value: unknown);
+    next(): void;
+    prev(): void;
+    goTo(page: unknown): void;
+    _interval(): number;
+    _slides(): HTMLElement[];
+    _playing(): boolean;
+    _hold({ hover, focus }: {
+        hover?: boolean;
+        focus?: boolean;
+    }): void;
+    _click(e: MouseEvent): void;
+    _key(e: KeyboardEvent): void;
+    _perViewNow(): number;
+    _start(page: number): number;
+    _label(): number;
+    _refresh(): void;
+    _settle(): void;
+    _go(page: number): void;
+    _render(announce: boolean): void;
+    _sync(): void;
+}

package/types/WuiChart.d.ts

@@ -0,0 +1,77 @@
+import type { ChartTheme } from "./chartAdapter.ts";
+import { mountChart } from "./chartAdapter.ts";
+import { type NormalizedSpec, type NormalizeResult } from "./chartSpec.ts";
+import { ElementBase } from "./elementBase.ts";
+type ChartState = "ready" | "loading" | "empty" | "error";
+type ChartEngine = ReturnType<typeof mountChart>;
+type Focus = {
+    series: number;
+    index: number;
+};
+type ChartParts = {
+    legend: HTMLDivElement;
+    surface: HTMLDivElement;
+    canvas: HTMLDivElement;
+    state: HTMLDivElement;
+    tableWrap: HTMLDivElement;
+    summary: HTMLParagraphElement;
+    live: HTMLDivElement;
+};
+export declare class WuiChart extends ElementBase {
+    uid: string;
+    _spec: unknown;
+    _normal: NormalizeResult | null;
+    _hidden: Set<string>;
+    _focus: Focus | null;
+    _awaitingSpec: boolean;
+    _parts: ChartParts | null;
+    _theme: ChartTheme | null;
+    _width: number | null;
+    _visible: boolean;
+    _resizeObserver: ResizeObserver | null;
+    _intersection: IntersectionObserver | null;
+    _engine: ChartEngine | null;
+    _drawn: boolean;
+    _drawnType: string | null;
+    _announcedReady: boolean;
+    _legendSignature: string | null;
+    _tableSpec: NormalizedSpec | null;
+    static get observedAttributes(): string[];
+    constructor();
+    get spec(): unknown;
+    set spec(v: unknown);
+    get view(): "chart" | "table";
+    set view(v: string | null | undefined);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, oldValue: string | null, newValue: string | null): void;
+    /** The data as CSV text (every row; see chartSpec.toCsv). Empty when there is no drawable spec. */
+    toCsv(): string;
+    /** The chart as a PNG data URL at twice its size, on the surface colour. Empty without a drawable spec. */
+    toPng(): string;
+    /** Download the CSV, named after the title unless `name` is given. */
+    exportCsv(name?: string): void;
+    /** Download the PNG, named after the title unless `name` is given. */
+    exportPng(name?: string): void;
+    _readScript(): unknown;
+    _normalized(): NormalizeResult;
+    _build(): void;
+    _size(spec: NormalizedSpec): {
+        width: number;
+        height: number;
+    };
+    _update(): void;
+    _renderState(state: ChartState, message: string | null | undefined, height: string, live: boolean): void;
+    _colour(spec: NormalizedSpec, index: number): string | undefined;
+    _renderLegend(spec: NormalizedSpec | null, show: boolean): void;
+    _renderTable(spec: NormalizedSpec): void;
+    _draw(): void;
+    _themeChanged(): void;
+    _resized(): void;
+    _toggle(key: string | null | undefined): void;
+    _onKey(e: KeyboardEvent): void;
+    _announce(text: string): void;
+    _clearFocus(): void;
+    _select(seriesIndex: number, dataIndex: number): void;
+}
+export {};

package/types/WuiCodeBlock.d.ts

@@ -0,0 +1,27 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiCodeBlock extends ElementBase {
+    private readonly _title;
+    private readonly _view;
+    private readonly _codeEl;
+    private readonly _copyIcon;
+    private readonly _copyText;
+    private _chrome;
+    private _copied;
+    private _observer;
+    private _timer;
+    private _cancelFrame;
+    constructor();
+    static get observedAttributes(): string[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    _source(): Element | undefined;
+    _code(): string;
+    _schedule(): void;
+    _cancelPending(): void;
+    _render(): void;
+    _build(doc: Document): void;
+    _bar(doc: Document): HTMLDivElement;
+    _setCopied(copied: boolean): void;
+    _copyLabel(): string;
+}

package/types/WuiCommandPalette.d.ts

@@ -0,0 +1,135 @@
+/**
+ * <wui-command-palette>: the keyboard and pointer behaviour of a "search and jump" list.
+ *
+ * Like <wui-dock>, this element renders no markup of its own. The wrappers (React
+ * AppCommandPalette, Razor <app-command-palette>) author the input, the grouped listbox and
+ * the footer, because item icons and trailing text can be arbitrary nodes. The overlay is the
+ * library's modal on both surfaces, which already owns Escape, the backdrop, the focus trap
+ * and returning focus, so none of that lives here. This element only:
+ *
+ *   - keeps one ACTIVE option: `aria-selected="true"` on it, `aria-activedescendant` on the
+ *     combobox input. Focus never leaves the input, so the options are not focusable.
+ *   - moves it with ArrowUp / ArrowDown across every group, wrapping at both ends, and
+ *     scrolls it into view. A disabled option (`aria-disabled="true"`) stays listed but is
+ *     never active, skipped by the arrow keys, and ignored by Enter, click and the pointer.
+ *   - lets the pointer set it (mousemove, not mouseenter, so a list scrolling under a still
+ *     pointer does not steal it).
+ *   - marks keyboard use: `data-keyboard` on the element while an arrow key chose the active
+ *     option, cleared when the pointer picks one, when the first result takes over (a new query
+ *     or list), and when the modal closes. The theme draws the keyboard ring only under it.
+ *   - selects on Enter or click: dispatches a cancelable `wui-command-palette:select` event
+ *     with `{ key, groupKey, id }`. If nothing cancels it and the option carries `data-href`,
+ *     the page navigates there (the server-rendered path).
+ *
+ * The wrapper calls `refresh()` after it changes the options. A query that differs from the
+ * one seen at the last refresh moves the active option back to the first result. Under the
+ * same query, an option the user chose (arrow keys or pointer) is kept while it still exists;
+ * an option that was only active by default follows the list, so results arriving late for
+ * the same query make their first row the one Enter picks.
+ *
+ * With the `filter` attribute the element also filters the options itself, on their
+ * `data-label`, as the user types: for a server-rendered list with no script of its own.
+ * Each option also matches on its `data-keywords` (space-separated), the same way as its label.
+ * Matching text in each label is wrapped in <mark> unless `highlight="false"`, groups left
+ * with no match are hidden, and the `.wui-cmd-empty` status region shows `empty-text`.
+ * Without `filter` the caller filters and renders the emphasis itself.
+ *
+ * With `group-filter` (which needs `filter`) the markup's `.wui-cmd-tabs` strip picks one
+ * group: each `[data-group-tab]` button carries a group's `data-group-key`, and the empty value
+ * is All. Tab and Shift+Tab in the input cycle the strip while focus stays in the input. The
+ * pick resets when the query changes, and the strip is hidden on a nested page, where the
+ * groups are not the root's.
+ *
+ * Nested pages. An option with `data-opens="<page key>"` opens a page instead of acting. The
+ * current page is a path of `{ key, label }`, shown by the element in the wrappers' empty
+ * `.wui-cmd-crumbs` bar (Back button, trail). Opening a page, Back, a click on a trail entry
+ * and Backspace in an empty input all dispatch a cancelable `wui-command-palette:navigate`
+ * with `{ path }`. A caller that owns the path (React) sets the `path` attribute (JSON) and
+ * cancels the event; otherwise the element keeps the path itself, and with `.wui-cmd-page`
+ * containers (`data-page`, `data-label`) in the markup it shows only the current page's options
+ * (the root options when the path is empty). Every navigation clears the search. The path
+ * resets when the enclosing Bootstrap modal closes.
+ *
+ * Recents. With `recents-key` (a localStorage key; make it per user), each chosen option is
+ * remembered by its `data-group-key` and `data-key`, newest first, up to `recents-limit`
+ * (default 5). While the search is empty on the root page, the element copies the remembered
+ * options that still exist into the wrappers' empty `.wui-cmd-recents` container, under a
+ * `recents-label` heading (default "Recent"), so they are listed first. A copy keeps its
+ * original's `data-group-key`, `data-key` and `data-href`, so choosing it does what the
+ * original does. A page-opening or disabled option is never remembered.
+ */
+import { ElementBase } from "./elementBase.ts";
+interface PathEntry {
+    key: string;
+    label: string;
+}
+interface RecentEntry {
+    g: string;
+    k: string;
+}
+export declare class WuiCommandPalette extends ElementBase {
+    _path: PathEntry[];
+    _group: string | null;
+    _crumbSig: string | null;
+    _modal: Element | null;
+    _recentsId: string;
+    _onModalHidden: () => void;
+    _activeId: string | null;
+    _lastQuery: string | null;
+    _lastIds: string | null;
+    _userChose: boolean;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onClick: (e: MouseEvent) => void;
+    _onMouseDown: (e: MouseEvent) => void;
+    _onMouseMove: (e: MouseEvent) => void;
+    _onInput: (e: Event) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    get filter(): boolean;
+    set filter(v: boolean);
+    get highlight(): boolean;
+    set highlight(v: boolean);
+    get emptyText(): string;
+    set emptyText(v: string | null | undefined);
+    /**
+     * Re-read the options after the wrapper changed them. Keeps the active option while the
+     * query is unchanged and it is still listed, and either the user chose it or the listed
+     * options are the same as last time. Otherwise activates the first result.
+     */
+    refresh(): void;
+    _input(): HTMLInputElement | null;
+    _optionFrom(target: EventTarget | null, includeDisabled?: boolean): HTMLElement | null;
+    _isDisabled(opt: Element): boolean;
+    _isHidden(opt: HTMLElement): boolean;
+    _selectableOptions(): HTMLElement[];
+    _setActive(opt: HTMLElement | null, scroll: boolean): void;
+    _move(step: number): void;
+    _setKeyboard(on: boolean): void;
+    _handleKeyDown(e: KeyboardEvent): void;
+    _select(opt: HTMLElement): void;
+    _open(pageKey: string): void;
+    _goTo(path: PathEntry[]): void;
+    _tabs(): HTMLElement[];
+    _groupActive(): boolean;
+    _pickGroup(groupKey: string | null): void;
+    _cycleGroup(step: number): void;
+    _syncTabs(): void;
+    _restart(): void;
+    _reset(): void;
+    _readPath(): void;
+    _renderCrumbs(): void;
+    _recentsHost(): HTMLElement | null;
+    _realOptions(): HTMLElement[];
+    _recentEntries(): RecentEntry[];
+    _recentsLimit(): number;
+    _remember(opt: HTMLElement): void;
+    _renderRecents(): void;
+    _inScope(opt: HTMLElement, paged: boolean): boolean;
+    _navigate(href: string): void;
+    _applyFilter(): void;
+    _teardown(): void;
+}
+export {};

package/types/WuiCommentThread.d.ts

@@ -0,0 +1,77 @@
+import { type CommentIntent } from "./commentText.ts";
+import { ElementBase } from "./elementBase.ts";
+import type { HttpKind } from "./server/wuiHttp.ts";
+import { WuiMentionInput } from "./WuiMentionInput.ts";
+type CommentPerson = {
+    value: string;
+    label: string;
+    description?: string;
+    src?: string;
+};
+type CommentFields = {
+    commentId?: string | null;
+    parentId?: string | null;
+    body?: string;
+    emoji?: string | null;
+};
+type CommentRequest = CommentFields & {
+    intent: CommentIntent;
+};
+type PersistOutcome = {
+    ok: true;
+    html: string | null;
+} | {
+    ok: false;
+    kind: HttpKind;
+    message: string;
+};
+export declare class WuiCommentThread extends ElementBase {
+    private _wired;
+    private _busy;
+    private _peopleProp;
+    private _pickerFor;
+    private _onDocClick;
+    private _repositionPicker;
+    private _openers?;
+    submit?: (request: CommentRequest) => Promise<unknown>;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** The people every mention box offers: [{ value, label, description?, src? }]. */
+    get people(): CommentPerson[];
+    set people(list: CommentPerson[]);
+    _handPeople(box: WuiMentionInput | null): void;
+    _applyComposerPlaceholder(box: WuiMentionInput | null): void;
+    _reactionChoices(): readonly string[];
+    _onClick(e: MouseEvent): void;
+    _onKeyDown(e: KeyboardEvent): void;
+    _onSubmitKey(e: Event): void;
+    _openReply(comment: Element | null, opener: HTMLElement): void;
+    _openEditor(comment: Element | null, opener: HTMLElement): void;
+    _fillSlot(slot: HTMLElement, { label, placeholder, value, send, opener, }: {
+        label: string;
+        placeholder: string;
+        value: string;
+        send: string;
+        opener: HTMLElement;
+    }): void;
+    _button(tone: string, variant: string, size: "sm" | "md" | "lg", action: string, text: string): HTMLButtonElement;
+    _closeSlot(slot: HTMLElement | null, restoreFocus: boolean): void;
+    _askDelete(comment: Element | null): void;
+    _closeConfirm(comment: Element | null, restoreFocus: boolean): void;
+    _openPicker(comment: Element | null, button: HTMLElement): void;
+    _closePicker(restoreFocus: boolean): void;
+    _react(comment: Element, emoji: string | null): void;
+    _sendFrom(button: HTMLElement): void;
+    _send(intent: CommentIntent, fields: CommentFields, { comment, scope, form }: {
+        comment?: Element | null;
+        scope: Element;
+        form?: HTMLElement;
+    }): Promise<void>;
+    _persist(request: CommentRequest): Promise<PersistOutcome>;
+    _swapItems(html: string): void;
+    _restoreFocus(intent: CommentIntent, fields: CommentFields, form: HTMLElement | undefined): void;
+    _showError(scope: ParentNode | null | undefined, message: string | null): void;
+    _announce(message: string | null): void;
+}
+export {};

package/types/WuiConsentBanner.d.ts

@@ -0,0 +1,73 @@
+import { ElementBase } from "./elementBase.ts";
+type Category = "analytics" | "functional" | "marketing";
+type Choice = Record<Category, boolean>;
+export declare class WuiConsentBanner extends ElementBase {
+    _uid: string;
+    _preferences: Choice;
+    _settings: boolean;
+    _onDocumentClick: (e: MouseEvent) => void;
+    _tourWatch: MutationObserver | null;
+    _roomObserver: ResizeObserver | null;
+    _onWindowResize: () => void;
+    _rendered?: boolean;
+    static get observedAttributes(): string[];
+    constructor();
+    get position(): "bottom-left" | "bottom-right" | "bar";
+    set position(v: unknown);
+    get standalone(): boolean;
+    set standalone(v: unknown);
+    get preview(): boolean;
+    set preview(v: unknown);
+    get heading(): string;
+    set heading(v: unknown);
+    get description(): string;
+    set description(v: unknown);
+    get policyHref(): string;
+    set policyHref(v: unknown);
+    get policyLabel(): string;
+    set policyLabel(v: unknown);
+    get analyticsDescription(): string;
+    set analyticsDescription(v: unknown);
+    get functionalDescription(): string;
+    set functionalDescription(v: unknown);
+    get marketingDescription(): string;
+    set marketingDescription(v: unknown);
+    /** The optional categories shown, in display order. Unknown names are ignored; none known means all. */
+    get categories(): Category[];
+    set categories(v: string[] | string | null | undefined);
+    /** The current choice. The host sets it; the switches start from it when settings open. A category not shown reads false. */
+    get preferences(): {
+        [name: string]: boolean;
+    };
+    set preferences(v: Partial<Record<Category, unknown>> | null | undefined);
+    /** True while the banner is showing. Read-only: use open()/close(). */
+    get isOpen(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    _syncTour(): void;
+    attributeChangedCallback(): void;
+    render(): void;
+    /**
+     * Show the banner. `settings: true` opens straight into the per-category switches, the way
+     * a "Cookie settings" link should; `focus: true` moves focus into it, which only a deliberate
+     * reopen should do: never the first show on page load.
+     */
+    open({ settings, focus }?: {
+        settings?: boolean;
+        focus?: boolean;
+    }): void;
+    close(): void;
+    _trackRoom(): void;
+    _untrackRoom(): void;
+    _reserveRoom(): void;
+    _root(): ShadowRoot | this;
+    _panel(): HTMLElement | null;
+    _requirePanel(): HTMLElement;
+    _wire(): void;
+    _save(choice: Choice): void;
+    _choiceForShown(granted: boolean): Choice;
+    _switchValues(): Choice;
+    _applyPreferences(): void;
+    _showSettings(on: boolean): void;
+}
+export {};

package/types/WuiContextMenu.d.ts

@@ -0,0 +1,90 @@
+import { ElementBase } from "./elementBase.ts";
+import { type ListboxKeyNav } from "./listboxKeyNav.ts";
+export declare class WuiContextMenu extends ElementBase {
+    _region: Element | null;
+    _origin: Element | null;
+    _returnFocus: HTMLElement | SVGElement | null;
+    _press: {
+        x: number;
+        y: number;
+        timer: ReturnType<typeof setTimeout>;
+    } | null;
+    _swallowClick: boolean;
+    _navPanel: HTMLElement | null;
+    _nav: ListboxKeyNav;
+    _onContextMenu: (e: MouseEvent) => void;
+    _onContextMenuCapture: (e: MouseEvent) => void;
+    _onDocKeyDown: (e: KeyboardEvent) => void;
+    _onDocClick: (e: MouseEvent) => void;
+    _onPointerDown: (e: PointerEvent) => void;
+    _onPressMove: (e: PointerEvent) => void;
+    _onPressEnd: () => void;
+    _onClickCapture: (e: MouseEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onClick: (e: MouseEvent) => void;
+    _onInput: (e: Event) => void;
+    _onMouseMove: (e: MouseEvent) => void;
+    _onDismiss: (e: Event) => void;
+    _onPointerDownCapture: (e: PointerEvent) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    get target(): string | null;
+    set target(v: string | null | undefined);
+    get disabled(): boolean;
+    set disabled(v: boolean);
+    get isOpen(): boolean;
+    /**
+     * Show the menu with its top-left corner at the viewport point (x, y), moved as needed to stay
+     * on screen. Closes any other open menu first. Fires `wui-context-menu:beforeopen` first; a
+     * cancel leaves the menu closed and returns false.
+     * @param x
+     * @param y
+     * @param opts `keyboard` puts focus on the first row instead of on the panel.
+     * @returns whether the menu is shown
+     */
+    open(x: number, y: number, { region, origin, trigger, keyboard, }?: {
+        region?: Element;
+        origin?: Element | null;
+        trigger?: HTMLElement | null;
+        keyboard?: boolean;
+    }): boolean;
+    _syncOpen(): void;
+    _regionRect(region: Element): {
+        left: number;
+        top: number;
+    } | null;
+    /** Hide the menu and every submenu in it. `restoreFocus` returns focus to what held it when the menu opened. */
+    close(restoreFocus?: boolean): void;
+    _panel(): HTMLElement | null;
+    _inPanel(node: EventTarget | null): boolean;
+    _rowsOf(panel: HTMLElement | null): HTMLElement[];
+    _isDisabled(item: Element): boolean;
+    _regionFor(node: EventTarget | null): Element | null;
+    _triggerFor(node: EventTarget | null): {
+        trigger: HTMLElement;
+        region: Element;
+    } | null;
+    _isKeyEcho(): boolean;
+    _handleContextMenu(e: MouseEvent): void;
+    _handleDocKeyDown(e: KeyboardEvent): void;
+    _handleDocClick(e: MouseEvent): void;
+    _handlePointerDown(e: PointerEvent): void;
+    _cancelPress(): void;
+    _handleMenuKey(e: KeyboardEvent): void;
+    _handleSearchKey(e: KeyboardEvent, input: Element): void;
+    _step(panel: HTMLElement, item: HTMLElement | null, step: number): void;
+    _subOf(item: HTMLElement): HTMLElement | null;
+    _openSubOf(panel: HTMLElement): HTMLElement | null;
+    _openSub(sub: HTMLElement, focusFirst: boolean): void;
+    _closeSub(sub: HTMLElement): void;
+    _closeSubByKey(sub: HTMLElement): void;
+    _setSub(sub: HTMLElement, open: boolean): void;
+    _filter(sub: HTMLElement, text: string): void;
+    _handleInput(e: Event): void;
+    _decorate(panel: HTMLElement): void;
+    _handleClick(e: MouseEvent): void;
+    _teardown(): void;
+}

package/types/WuiDataTable.d.ts

@@ -0,0 +1,90 @@
+/**
+ * <wui-data-table>: the scroller of a data table (it carries `.table-wrap`) with resizable and pinned
+ * columns, and on Razor grouped and virtual rows. React AppDataTable and Razor <app-data-table>
+ * render it in place of the plain wrap once one of those features is on.
+ *
+ * - `resizable`: each header cell but the last gets a drag handle (React renders its own; on Razor
+ *   one is added). Drag, or focus it and press the arrow keys (Shift for bigger steps, Home to undo).
+ *   The table then lays out at fixed widths measured from its rows; the last column takes what is
+ *   left. With `view-key` the widths are remembered in this browser.
+ * - Pinned columns: a header cell with `data-pin="start"` or `"end"` stays put while the table
+ *   scrolls sideways. This measures the offsets onto the table (`--wui-pin-start-<n>`) and, on rows
+ *   that lack them, adds the pin classes and offset reference React renders itself.
+ * - `group-by="<data-key>"` (Razor): rows are gathered under a header row per value of that column
+ *   (or a row's own `data-group`), in first-seen order, with a collapse toggle and a count.
+ * - `virtual` (Razor): only the rows in view, plus a margin, are laid out; the others are hidden
+ *   between two spacer rows sized to them. Needs a height cap (the theme's `.wui-table-scroll`).
+ */
+import { virtualRange } from "./dataTable.ts";
+import { ElementBase } from "./elementBase.ts";
+interface DragState {
+    th: HTMLTableCellElement;
+    x: number;
+    from: number;
+    dir: number;
+    moved: boolean;
+}
+export declare class WuiDataTable extends ElementBase {
+    _frame: number;
+    _headDirty: boolean;
+    _rowsDirty: boolean;
+    _frozenSig: string | null;
+    _natural: number[];
+    _widths: Record<string, number>;
+    _collapsed: Set<string | undefined>;
+    _groupOrder: string[];
+    _items: HTMLTableRowElement[];
+    _range: ReturnType<typeof virtualRange> | null;
+    _drag: DragState | null;
+    _userSized: boolean;
+    _swallowClick: boolean;
+    _mo: MutationObserver | null;
+    _ro: ResizeObserver | null;
+    _fonts: FontFaceSet | null;
+    _onPointerDown: (e: PointerEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onClick: (e: MouseEvent) => void;
+    _onDblClick: (e: MouseEvent) => void;
+    _onScroll: () => void;
+    _onFonts: () => void;
+    _top: HTMLTableRowElement | null;
+    _bottom: HTMLTableRowElement | null;
+    _rowHeight: number;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Re-reads the table now: after a page script changed its header or rows outside a mutation. */
+    refresh(): void;
+    get _table(): HTMLTableElement | null;
+    _headCells(table: HTMLTableElement): HTMLTableCellElement[];
+    _schedule(): void;
+    _mutated(records: MutationRecord[]): void;
+    _run(): void;
+    _pins(table: HTMLTableElement, stamp: boolean): void;
+    _setVar(table: HTMLElement, name: string, px: number): void;
+    _resizable(cells: HTMLTableCellElement[]): boolean[];
+    _handles(table: HTMLTableElement): void;
+    _hasRows(table: HTMLTableElement): boolean;
+    _signature(cells: HTMLTableCellElement[]): string;
+    _layout(table: HTMLTableElement): void;
+    _applyRemembered(cells: HTMLTableCellElement[]): void;
+    _freeze(table: HTMLTableElement, cells: HTMLTableCellElement[], sig: string): void;
+    _setWidth(th: HTMLTableCellElement, px: unknown): number;
+    _handleValue(handle: Element, px: number): void;
+    _fitTable(table: HTMLTableElement, cells: HTMLTableCellElement[]): void;
+    _ensureFrozen(table: HTMLTableElement): HTMLTableCellElement[];
+    _resizeTo(th: HTMLTableCellElement, px: number, remember: boolean): void;
+    _remember(th: HTMLTableCellElement): void;
+    _reset(th: HTMLTableCellElement | null): void;
+    _rtl(): boolean;
+    _startDrag(e: PointerEvent): void;
+    _key(e: KeyboardEvent): void;
+    _click(e: MouseEvent): void;
+    _group(table: HTMLTableElement): void;
+    _groupRow(doc: Document, key: string): HTMLTableRowElement;
+    _showGroup(header: HTMLTableRowElement | null, open: boolean): void;
+    _spacer(body: HTMLTableSectionElement, row: HTMLTableRowElement | null): HTMLTableRowElement;
+    _virtual(table: HTMLTableElement, recollect: boolean): void;
+    _measureRow(table: HTMLTableElement): number;
+}
+export {};