@jimka/typescript-ui 0.5.0 → 0.6.0

package/dist/lib/types/component/container/Scrollbar.d.ts

@@ -1,6 +1,7 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
 import type { AxisOrientation } from "../../primitive/Axis.js";
 export type ScrollbarEvent = "scroll";
+export declare const TRACK_WIDTH = 12;
 export type ScrollbarListener = (position: number) => void;
 export interface ScrollbarOptions extends ComponentOptions {
     arrowsEnabled?: boolean;
@@ -9,6 +10,7 @@ export interface ScrollbarOptions extends ComponentOptions {
         scroll?: ScrollbarListener;
     };
 }
+export declare function isScrollbarTarget(e: Event): boolean;
 declare class Scrollbar extends Component<ScrollbarOptions> {
     private _orientation;
     private _thumb;
@@ -19,6 +21,8 @@ declare class Scrollbar extends Component<ScrollbarOptions> {
     private _thumbPos;
     private _dragStartClient;
     private _dragStartScroll;
+    private _thumbHovered;
+    private _thumbDragging;
     private _listeners;
     private _arrowsEnabled;
     private _arrowStep;
@@ -32,6 +36,7 @@ declare class Scrollbar extends Component<ScrollbarOptions> {
     private disposeArrows;
     private _onThumbMouseOver;
     private _onThumbMouseOut;
+    private updateThumbFill;
     on(event: "scroll", listener: ScrollbarListener): this;
     off(event: ScrollbarEvent, listener: Function): this;
     protected emit(event: "scroll", position: number): void;

package/dist/lib/types/component/container/SplitGutter.d.ts

@@ -1,20 +1,22 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
-import { CollapseDirection } from "../../component/container/CollapseButton.js";
+import { CollapseDirection, CollapseTrigger } from "../../component/container/CollapseButton.js";
 import { Event } from "../../core/Event.js";
-export type SplitGutterEvent = "dragstart" | "drag" | "dragend" | "collapse";
+export type SplitGutterEvent = "dragstart" | "drag" | "dragend" | "collapse" | "contextmenu";
 export interface SplitGutterOptions extends ComponentOptions {
     orientation?: string;
     collapsible?: boolean;
     movable?: boolean;
     opaque?: boolean;
     collapseDirection?: CollapseDirection;
+    collapseTrigger?: CollapseTrigger;
     expandedBackground?: string;
     listeners?: {
         dragstart?: (position: number) => void;
         drag?: (position: number) => void;
         dragend?: () => void;
         collapse?: () => void;
+        contextmenu?: (x: number, y: number) => void;
     };
 }
 declare class SplitGutter extends Component<SplitGutterOptions> {
@@ -24,6 +26,7 @@ declare class SplitGutter extends Component<SplitGutterOptions> {
     private _collapseButton;
     private _opaque;
     private _collapseDirection;
+    private _collapseTrigger;
     private _expandedBackground;
     private _tooltipText;
     private _listeners;
@@ -45,11 +48,13 @@ declare class SplitGutter extends Component<SplitGutterOptions> {
     on(event: "drag", listener: (position: number) => void): this;
     on(event: "dragend", listener: () => void): this;
     on(event: "collapse", listener: () => void): this;
+    on(event: "contextmenu", listener: (x: number, y: number) => void): this;
     off(event: SplitGutterEvent, listener: Function): this;
     protected emit(event: "dragstart", position: number): void;
     protected emit(event: "drag", position: number): void;
     protected emit(event: "dragend"): void;
     protected emit(event: "collapse"): void;
+    protected emit(event: "contextmenu", x: number, y: number): void;
     protected destructor(): void;
     private _dispatchDrag;
     onDragStart(evnt: MouseEvent): void;

package/dist/lib/types/component/container/TabBar.d.ts

@@ -110,6 +110,8 @@ declare class TabBar extends Container<TabBarOptions> {
     isEntryCloseable(id: string): boolean;
     getEntryName(id: string): string;
     setEntryContentId(id: string, contentId: string): this;
+    setEntryBusy(id: string, busy: boolean): this;
+    isEntryBusy(id: string): boolean;
     getEntryButtonId(id: string): string;
     private entryById;
     private activeEntry;

package/dist/lib/types/component/container/WindowBorder.d.ts

@@ -34,7 +34,7 @@ declare class WindowBorder extends Component<WindowBorderOptions> {
     private _dispatchDrag;
     isSnapTarget(): boolean;
     setSnapTarget(value: boolean): this;
-    onDragStart(): void;
+    onDragStart(e?: MouseEvent): void;
     onDragStop(): Event.ListenerResult;
     private dragCursor;
     render(): import("../../core/DOM.js").Handle;

package/dist/lib/types/component/container/index.d.ts

@@ -8,8 +8,13 @@ export { Legend } from '../../component/container/Legend.js';
 export type { LegendOptions } from '../../component/container/Legend.js';
 export { MenuItem } from '../../component/container/MenuItem.js';
 export type { MenuItemConfig, MenuConfig, MenuItemCSSVarPrefix, MenuItemOptions } from '../../component/container/MenuItem.js';
+export { MenuRow } from '../../component/container/MenuRow.js';
 export { MenuSeparator } from '../../component/container/MenuSeparator.js';
 export type { MenuSeparatorOptions } from '../../component/container/MenuSeparator.js';
+export { CheckboxMenuRow } from '../../component/container/CheckboxMenuRow.js';
+export type { CheckboxMenuRowOptions, CheckboxMenuRowEvent } from '../../component/container/CheckboxMenuRow.js';
+export { RadioMenuRow } from '../../component/container/RadioMenuRow.js';
+export type { RadioMenuRowOptions, RadioMenuRowEvent } from '../../component/container/RadioMenuRow.js';
 export { Scrollbar } from '../../component/container/Scrollbar.js';
 export type { ScrollbarListener, ScrollbarOptions, ScrollbarEvent } from '../../component/container/Scrollbar.js';
 export { ScrollStrip } from '../../component/container/ScrollStrip.js';
@@ -31,7 +36,7 @@ export type { AccordionHeaderOptions } from '../../component/container/Accordion
 export { AccordionIndicator } from '../../component/container/AccordionIndicator.js';
 export type { AccordionIndicatorOptions } from '../../component/container/AccordionIndicator.js';
 export { CollapseButton } from '../../component/container/CollapseButton.js';
-export type { CollapseButtonOptions, CollapseButtonEvent, CollapseDirection } from '../../component/container/CollapseButton.js';
+export type { CollapseButtonOptions, CollapseButtonEvent, CollapseDirection, CollapseTrigger } from '../../component/container/CollapseButton.js';
 export { TabBar } from '../../component/container/TabBar.js';
 export type { TabBarOptions, TabBarEvent, TabToolDescriptor } from '../../component/container/TabBar.js';
 export { TabPanel } from '../../component/container/TabPanel.js';

package/dist/lib/types/component/display/WebGLCanvas.d.ts

@@ -16,6 +16,7 @@ declare class WebGLCanvas extends Component<WebGLCanvasOptions> {
     private _elapsedMs;
     private _animationRequested;
     private _contextLost;
+    private readonly _onContextLost;
     private _contextInitialised;
     private _syncedWidth;
     private _syncedHeight;

package/dist/lib/types/component/input/AbstractCalendarDropdown.d.ts

@@ -22,10 +22,12 @@ declare class PickerBlankCell extends Component {
 }
 declare class PickerNavButton extends Component {
     constructor(glyphName: string, onClick: () => void);
+    private onPointerDown;
     protected render(): Handle;
 }
 declare class PickerMonthLabel extends Text {
     constructor(onClick: () => void);
+    private onPointerDown;
     protected render(): Handle;
 }
 declare class PickerDay extends Text {

package/dist/lib/types/component/input/AbstractPickerField.d.ts

@@ -3,6 +3,7 @@ import { AnimatedDropdown } from "../../core/AnimatedDropdown.js";
 import type { Handle } from "../../core/DOM.js";
 import { PickerInput } from "../../component/input/PickerInput.js";
 import { PickerButton } from "../../component/input/PickerButton.js";
+import { Event } from "../../core/Event.js";
 export interface AbstractPickerFieldOptions extends AbstractInputOptions {
     dropdownAnimated?: boolean;
 }
@@ -33,11 +34,11 @@ declare abstract class AbstractPickerField<TValue, TDropdown extends AnimatedDro
     protected applyEnabled(value: boolean): void;
     protected applyReadOnly(value: boolean): void;
     protected onButtonClick(): void;
-    protected onButtonPointerDown(e: PointerEvent): void;
+    protected onButtonPointerDown(_e: PointerEvent): Event.ListenerResult;
     protected onInput(): void;
     protected onBlur(): void;
     protected setInvalid(invalid: boolean): void;
-    protected onKeyDown(e: KeyboardEvent): void;
+    protected onKeyDown(e: KeyboardEvent): Event.ListenerResult;
     protected ensureDropdown(): TDropdown;
     protected openDropdown(): void;
     protected closeDropdown(): void;

package/dist/lib/types/component/list/AbstractSelectableList.d.ts

@@ -128,7 +128,7 @@ declare abstract class AbstractSelectableList<TValue, TOptions extends AbstractS
     getFocusedIndex(): number;
     getFocusedRowId(): string | null;
     handleKey(e: KeyboardEvent): boolean;
-    protected handleKeyDown(e: KeyboardEvent): void;
+    protected handleKeyDown(e: KeyboardEvent): Event.ListenerResult;
     protected handleNavigationKey(e: KeyboardEvent, ctrl: boolean): boolean;
     protected moveFocus(idx: number, ctrl: boolean, shift: boolean): void;
     protected commitFocusedRow(ctrl: boolean, shift: boolean): void;

package/dist/lib/types/component/list/MultiSelectList.d.ts

@@ -1,5 +1,6 @@
 import { AbstractSelectableList, AbstractSelectableListOptions } from "../../component/list/AbstractSelectableList.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
+import { Event } from "../../core/Event.js";
 export interface MultiSelectListOptions extends AbstractSelectableListOptions {
     selectedIndices?: number[];
 }
@@ -16,7 +17,7 @@ declare class MultiSelectList extends AbstractSelectableList<string[], MultiSele
         shift: boolean;
     }): void;
     protected notifyUserChange(): void;
-    protected handleKeyDown(e: KeyboardEvent): void;
+    protected handleKeyDown(e: KeyboardEvent): Event.ListenerResult;
     protected selectAll(): void;
     private applyInitialSelection;
 }

package/dist/lib/types/component/shared/VirtualRowView.d.ts

@@ -11,6 +11,7 @@ declare abstract class VirtualRowView<TRow extends Component, TOptions extends C
     } | null>;
     protected _rowDisplayed: boolean[];
     protected _scroller: VirtualScroller | null;
+    private _lastWindowStart;
     private _renderDeferred;
     private _renderResumed;
     private _pendingScrollX;
@@ -34,6 +35,7 @@ declare abstract class VirtualRowView<TRow extends Component, TOptions extends C
     protected computePoolTarget(windowSize: number, visibleHeight: number, totalRows: number): number;
     protected computePageSize(): number;
     protected growRowPool(poolTarget: number): void;
+    protected alignPoolWindow(firstRow: number): void;
     protected positionRow(slot: number, targetY: number, rowWidth: number): boolean;
     protected hideExcessPoolRows(windowSize: number): void;
     protected invalidateGeom(): void;

package/dist/lib/types/component/table/Body.d.ts

@@ -4,6 +4,7 @@ import { AbstractStore } from "../../data/AbstractStore.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
 import { Row } from "../../component/table/Row.js";
 import { CellEditorPool } from "../../component/table/cell/editor/CellEditorPool.js";
+import { Event } from "../../core/Event.js";
 import { VirtualRowView } from "../../component/shared/VirtualRowView.js";
 import type { ColumnConfig } from "../../component/table/ColumnConfig.js";
 import { Column } from "../../component/table/Column.js";
@@ -25,12 +26,22 @@ export interface ColumnWindow {
     lefts: number[];
 }
 export declare function computeColumnWindow(widths: number[], scrollX: number, viewportWidth: number): ColumnWindow;
+export declare function buildTsv(rows: string[][], startRow: number, startCol: number, startOffset: number | null, endRow: number, endCol: number, endOffset: number | null): string;
+export declare function locateCellInGrid(grid: Array<Array<{
+    element: Handle;
+}>>, target: Handle): {
+    row: number;
+    col: number;
+} | null;
 declare class Body extends VirtualRowView<Row> {
     private _store;
     private _hiddenColumns;
     private _columns;
     private _columnConfigs;
     private _rowReadOnly;
+    private _rowVisible;
+    private _rowSeparator;
+    private _rowIndented;
     private _cellGeom;
     private _lastBodyWidth;
     private _lastColumnWidths;
@@ -67,6 +78,12 @@ declare class Body extends VirtualRowView<Row> {
     setHiddenColumns(hidden: Set<string>): this;
     setColumns(columns: Column[]): this;
     setRowReadOnly(predicate: ((record: ModelRecord) => boolean) | null): this;
+    setRowSeparator(predicate: ((record: ModelRecord) => {
+        label: string;
+        color: string | null;
+    } | null) | null): this;
+    setRowIndented(predicate: ((record: ModelRecord) => boolean) | null): this;
+    setRowVisible(predicate: ((record: ModelRecord) => boolean) | null): this;
     setColumnConfigs(configs: Map<string, ColumnConfig>): this;
     private registerComboEditors;
     private syncPoolCells;
@@ -84,6 +101,9 @@ declare class Body extends VirtualRowView<Row> {
     protected bindAndPositionRows(firstRow: number, windowSize: number, rowWidth: number, records: ModelRecord[], columns: ColumnWindow): void;
     protected onSubtreeClick(e: MouseEvent): void;
     private onRowClick;
+    private onCopy;
+    private buildSelectionText;
+    private renderedCellGrid;
     selectRecord(record: ModelRecord | null): void;
     getSelectedRecord(): ModelRecord | null;
     getSelectedRecords(): ModelRecord[];
@@ -105,7 +125,8 @@ declare class Body extends VirtualRowView<Row> {
     setHeader(header: TableHeader): this;
     protected _updateFocusStyle(): void;
     protected _updateActiveDescendant(): void;
-    protected onKeyDown(e: KeyboardEvent): void;
+    private skipSeparators;
+    protected onKeyDown(e: KeyboardEvent): Event.ListenerResult;
     protected scrollRecordIntoView(record: ModelRecord): void;
     protected scrollColumnIntoView(colIndex: number): void;
 }

package/dist/lib/types/component/table/Column.d.ts

@@ -14,7 +14,8 @@ export declare class Column {
     private _group;
     private _groupColor;
     private _required;
-    constructor(field: Field, config?: ColumnConfig);
+    private _filterable;
+    constructor(field: Field, config?: ColumnConfig, specFilterable?: boolean);
     getField(): Field;
     getMinWidth(): number | undefined;
     getMaxWidth(): number | undefined;
@@ -30,5 +31,6 @@ export declare class Column {
     getGroup(): string | null;
     getGroupColor(): string | null;
     isRequired(): boolean;
+    isFilterable(): boolean;
     static resolve(fields: Field[], spec?: ColumnSpec): Column[];
 }

package/dist/lib/types/component/table/ColumnConfig.d.ts

@@ -16,6 +16,7 @@ export interface ColumnConfig {
     hidden?: boolean;
     unhideable?: boolean;
     readOnly?: boolean;
+    filterable?: boolean;
     cellReadOnly?: (record: ModelRecord) => boolean;
     showSeconds?: boolean;
     values?: Array<ComboOption | string>;
@@ -34,4 +35,5 @@ export interface ColumnSpec {
     appendUnlisted?: boolean;
     rowReadOnly?: (record: ModelRecord) => boolean;
     autoSizeColumns?: boolean;
+    filterable?: boolean;
 }

package/dist/lib/types/component/table/ColumnFilter.d.ts

@@ -0,0 +1,27 @@
+import type { FieldType } from "../../data/Field.js";
+import type { FilterDescriptor } from "../../data/FilterDescriptor.js";
+import type { ComboOption } from "../../component/table/ColumnConfig.js";
+import type { CellTextResolver } from "../../component/table/cell/CellText.js";
+export type ColumnFilterOperator = 'contains' | 'startsWith' | 'endsWith' | 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'isEmpty' | 'isNotEmpty';
+export interface ColumnFilterClause {
+    operator: ColumnFilterOperator;
+    text: string;
+}
+export interface ColumnFilterState {
+    clauses: ColumnFilterClause[];
+}
+export interface ColumnFilterTarget {
+    type: FieldType;
+    values?: Array<ComboOption | string>;
+    showSeconds?: boolean;
+}
+export declare function columnFilterOperators(type: FieldType): ColumnFilterOperator[];
+export declare function columnFilterOperatorLabel(operator: ColumnFilterOperator): string;
+export declare function columnFilterOperatorGlyph(operator: ColumnFilterOperator): string;
+export declare function columnFilterTakesOperand(operator: ColumnFilterOperator): boolean;
+export declare function isClauseEffective(clause: ColumnFilterClause): boolean;
+export declare function effectiveClauseCount(clauses: ColumnFilterClause[]): number;
+export declare function columnFilterTakesNumericOperand(target: ColumnFilterTarget): boolean;
+export declare function columnFilterAcceptsNumericKey(key: string): boolean;
+export declare function buildColumnFilter(field: string, target: ColumnFilterTarget, state: ColumnFilterState, display: CellTextResolver): FilterDescriptor | null;
+export declare function columnFilterStatesEqual(a: ColumnFilterState, b: ColumnFilterState): boolean;

package/dist/lib/types/component/table/Header.d.ts

@@ -1,15 +1,17 @@
 import { Component } from "../../core/Component.js";
-import type { Handle } from "../../core/DOM.js";
 import { Row } from "../../component/table/Row.js";
 import { AbstractModel } from "../../data/AbstractModel.js";
 import { AbstractStore } from "../../data/AbstractStore.js";
 import { Column } from "../../component/table/Column.js";
+import type { ColumnConfig } from "../../component/table/ColumnConfig.js";
+import { Button } from "../../component/button/Button.js";
 export type TableHeaderEvent = "columnresizestart" | "columnresize" | "columncontextmenu";
 export interface HeaderColumnGeometry {
     columnWidths: number[];
     viewportWidth: number;
     columnHeight: number;
     parentRowHeight: number;
+    filterRowHeight: number;
 }
 declare class TableHeader extends Component {
     private _model;
@@ -17,7 +19,8 @@ declare class TableHeader extends Component {
     private _hiddenColumns;
     private _columns;
     private _listeners;
-    private _scrollbarCover;
+    private _menuButton;
+    private _boundOnMenuButtonAction;
     private _visibleFields;
     private _windowFirst;
     private _scrollX;
@@ -25,12 +28,22 @@ declare class TableHeader extends Component {
     private _columnsDirty;
     private _geometry;
     private _cellGeom;
+    private _filterRowVisible;
+    private _filterStates;
+    private _filterCellsDirty;
+    private _filterWindowFirst;
+    private _pendingFilterField;
+    private _filterTimer;
+    private _boundOnStoreFilterChange;
+    private _columnConfigs;
+    private _cellText;
     constructor(model: AbstractModel, store: AbstractStore);
     getModel(): AbstractModel;
     setStore(store: AbstractStore): this;
     setModel(model: AbstractModel): this;
     setHiddenColumns(hidden: Set<string>): this;
     setColumns(columns: Column[]): this;
+    setColumnConfigs(configs: Map<string, ColumnConfig>): this;
     on(event: "columnresizestart", listener: (colIndex: number, clientX: number) => void): this;
     on(event: "columnresize", listener: (colIndex: number, clientX: number) => void): this;
     on(event: "columncontextmenu", listener: (fieldName: string, x: number, y: number) => void): this;
@@ -42,7 +55,12 @@ declare class TableHeader extends Component {
     getColumnWindowStart(): number;
     getParentRow(): Row;
     hasParentRow(): boolean;
-    getScrollbarCover(): Handle;
+    getFilterRow(): Row;
+    hasFilterRow(): boolean;
+    setFilterRowVisible(visible: boolean): this;
+    private clearFilterRowState;
+    getMenuButton(): Button;
+    private onMenuButtonAction;
     addRow(row: Row): this;
     addComponent(row: Row): this;
     setHeight(height: number): this;
@@ -54,13 +72,22 @@ declare class TableHeader extends Component {
     private columnIndexOf;
     private handleSortClick;
     private syncSortIndicators;
+    private filterState;
+    private onFilterCellChange;
+    private filterTarget;
+    private applyPendingFilter;
+    private onStoreFilterChange;
+    private wireFilterCell;
+    private reconcileFilterCells;
     renderColumnWindow(geometry?: HeaderColumnGeometry): this;
+    private positionFilterCells;
     private positionColumnCells;
     private positionParentCells;
     setScrollX(scrollLeft: number): this;
     getScrollX(): number;
     setFocusedColumn(colIndex: number | null): this;
     private applyFocusedColumn;
+    protected destructor(): void;
 }
 declare const TableHeaderCallable: import("../../core/Callable.js").Callable<typeof TableHeader>;
 type TableHeaderCallable = TableHeader;

package/dist/lib/types/component/table/Row.d.ts

@@ -17,10 +17,13 @@ declare class Row extends Component {
     private _cellKeys;
     private _fieldNames;
     private _columnsDirty;
+    private _separatorMode;
     constructor(model?: AbstractModel, data?: ModelRecord, hiddenColumns?: Set<string>, columnConfigs?: Map<string, ColumnConfig>, onCellCommit?: (record: ModelRecord) => void, treeFieldName?: string);
     getTreeCell(): Cell<any> | null;
     getColumnWindowStart(): number;
     getFieldNames(): string[];
+    isSeparator(): boolean;
+    setFieldIndent(indented: boolean): void;
     getData(): ModelRecord | undefined;
     setData(record: ModelRecord): this;
     setStripe(striped: boolean): void;
@@ -28,6 +31,7 @@ declare class Row extends Component {
     addColumn(cell: Cell<any>, constraints?: LayoutConstraints): this;
     addComponent(cell: Cell<any>, constraints?: LayoutConstraints): this;
     setColumnFields(model: AbstractModel, hiddenColumns: Set<string>, columnConfigs: Map<string, ColumnConfig>, treeFieldName?: string): this;
+    renderSeparator(label: string, color: string | null): void;
     setColumnWindow(firstCol: number, lastCol: number): boolean;
     private commitCellValue;
     private static cellKey;

package/dist/lib/types/component/table/Table.d.ts

@@ -19,6 +19,7 @@ declare class Table extends Component<TableOptions> {
     private _resolvedColumns;
     private _hiddenColumns;
     private _columnContextMenu;
+    private _columnDialog;
     private _headerVisible;
     private _header;
     private _body;
@@ -32,18 +33,25 @@ declare class Table extends Component<TableOptions> {
     private _savedColumnWidths;
     private _columnConfigs;
     private _exportMenuEnabled;
+    private _filterRowVisible;
     private _listeners;
     private _displayMode;
     private _rotatedRecord;
+    private _rowVisible;
+    private _quickSearch;
     private _rotatedStore;
     private _rotatedColumns;
     private _rotatedConfigs;
     private _rotatedFieldByName;
+    private _rotatedSeparatorRecords;
+    private _rotatedIndentedRecords;
     private _sourceRefresh;
+    private _sourceUpdate;
     private _suppressSelectionForward;
     private _autoWidthsSampled;
     private _widthRefs;
     private _sampledCandidates;
+    private _cellText;
     constructor(store: AbstractStore, spec?: ColumnSpec, bodyFactory?: (store: AbstractStore) => Body);
     on(event: "selection", listener: (records: ModelRecord[]) => void): this;
     on(event: "cellclick", listener: (e: CellClickEvent) => void): this;
@@ -54,9 +62,16 @@ declare class Table extends Component<TableOptions> {
     private getSourceColumns;
     getDisplayMode(): TableDisplayMode;
     setDisplayMode(mode: TableDisplayMode): this;
+    setRowVisible(predicate: ((record: ModelRecord) => boolean) | null): this;
+    setQuickSearch(text: string | null, fields?: readonly string[] | null): this;
+    private resolveSearchFields;
+    private quickSearchMatches;
+    private composeRowVisible;
+    private applyRowVisible;
     getStore(): AbstractStore;
     getModel(): import("../../data").AbstractModel;
     setStore(store: AbstractStore): this;
+    private refreshQuickSearch;
     getColumnWidths(): number[];
     setColumnWidths(widths: number[]): this;
     getAvailableColumnWidth(): number;
@@ -64,6 +79,8 @@ declare class Table extends Component<TableOptions> {
     setColumnVisible(fieldName: string, visible: boolean): this;
     getHeader(): import("../../component/table/Header.js")._TableHeader;
     isHeaderVisible(): boolean;
+    isFilterRowVisible(): boolean;
+    setFilterRowVisible(visible: boolean): this;
     getBody(): import("../../component/table/Body.js")._Body;
     isBodyVisible(): boolean;
     getFooter(): import("../../component/table/Footer.js")._FooterRow;
@@ -83,17 +100,27 @@ declare class Table extends Component<TableOptions> {
     private bindSourceStore;
     private unbindSourceStore;
     private onSourceStoreChange;
+    private onSourceRecordUpdate;
     private ensureRotatedStore;
     private rebuildRotatedStore;
+    private computeGroupRuns;
     private rotatedCellType;
     private rotatedCellValues;
     private bindView;
     protected destructor(): void;
     private showColumnMenu;
+    private columnsInMenuOrder;
+    private buildColumnMenuItems;
+    private showColumnDialog;
+    private dialogColumnCount;
+    private splitIntoDialogColumns;
+    private buildColumnDialogBody;
+    private buildColumnDialogColumn;
     setExportMenuEnabled(enabled: boolean): this;
     exportCSV(options?: ExportOptions): void;
     exportJSON(options?: ExportOptions): void;
     private getExportColumns;
+    getCellText(field: string, record: ModelRecord): string;
     private onColumnResizeStart;
     private onColumnResize;
     private resetColumns;
@@ -105,6 +132,8 @@ declare class Table extends Component<TableOptions> {
     private measureHeaders;
     private measureContent;
     private resolveContentCandidates;
+    private resolveRotatedContentCandidates;
+    private formatRotatedValueText;
     private collectCandidates;
     private keepLongest;
     private samplesRecordText;

package/dist/lib/types/component/table/TableExporter.d.ts

@@ -1,14 +1,15 @@
 import { Column } from "../../component/table/Column.js";
 import { ColumnConfig } from "../../component/table/ColumnConfig.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
+import type { CellTextResolver } from "../../component/table/cell/CellText.js";
 export interface ExportOptions {
     includeHidden?: boolean;
     filename?: string;
 }
 export declare class TableExporter {
-    static exportCSV(columns: Column[], records: ModelRecord[], columnConfigs: Map<string, ColumnConfig>, options?: ExportOptions): void;
-    static exportJSON(columns: Column[], records: ModelRecord[], columnConfigs: Map<string, ColumnConfig>, options?: ExportOptions): void;
-    static formatValue(column: Column, value: any, columnConfigs: Map<string, ColumnConfig>): any;
+    static exportCSV(columns: Column[], records: ModelRecord[], columnConfigs: Map<string, ColumnConfig>, display: CellTextResolver, options?: ExportOptions): void;
+    static exportJSON(columns: Column[], records: ModelRecord[], columnConfigs: Map<string, ColumnConfig>, display: CellTextResolver, options?: ExportOptions): void;
+    static formatValue(column: Column, value: any, columnConfigs: Map<string, ColumnConfig>, display: CellTextResolver): any;
     private static escapeCSVField;
     private static download;
 }

package/dist/lib/types/component/table/TreeBody.d.ts

@@ -1,6 +1,7 @@
 import { _Body } from "../../component/table/Body.js";
 import { AbstractStore } from "../../data/AbstractStore.js";
 import type { Handle } from "../../core/DOM.js";
+import { Event } from "../../core/Event.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
 import { Row } from "../../component/table/Row.js";
 type TreeBodyReparentHandler = (dragged: ModelRecord, newParent: ModelRecord | null) => boolean;
@@ -61,7 +62,7 @@ declare class TreeBody extends _Body {
     setReparentHandlers(validator: TreeBodyReparentValidator, handler: TreeBodyReparentHandler): this;
     private ensureEmptyAreaDropTarget;
     protected onSubtreeClick(e: MouseEvent): void;
-    protected onKeyDown(e: KeyboardEvent): void;
+    protected onKeyDown(e: KeyboardEvent): Event.ListenerResult;
     private handleArrowRight;
     private handleArrowLeft;
     private moveFocusTo;

package/dist/lib/types/component/table/cell/CellText.d.ts

@@ -0,0 +1,9 @@
+import { CellRenderer } from "../../../component/table/cell/renderer/CellRenderer.js";
+import type { CellType, ComboOption } from "../../../component/table/ColumnConfig.js";
+export declare function buildCellRenderer(type: CellType, showSeconds: boolean, numberAlign?: "left" | "right"): CellRenderer<any>;
+export declare class CellTextResolver {
+    private _renderers;
+    private _comboOptions;
+    text(type: CellType, showSeconds: boolean, values: Array<ComboOption | string> | undefined, value: any): string;
+    dispose(): void;
+}

package/dist/lib/types/component/table/cell/Filter.d.ts

@@ -0,0 +1,54 @@
+import { Cell, CellEvent } from "../../../component/table/cell/Cell.js";
+import type { ColumnFilterOperator, ColumnFilterState } from "../../../component/table/ColumnFilter.js";
+import type { Handle } from "../../../core/DOM.js";
+export type FilterCellEvent = CellEvent | "filterchange";
+declare class FilterCell extends Cell<string | null> {
+    private _fieldName;
+    private _operators;
+    private _numericOnly;
+    private _clauses;
+    private _badge;
+    private _clausesPopover;
+    private _columnLabel;
+    constructor(fieldName: string, operators: ColumnFilterOperator[]);
+    private filterRenderer;
+    private applyOperatorFace;
+    private applyOperandAvailability;
+    setFieldName(name: string): this;
+    getFieldName(): string;
+    setOperators(operators: ColumnFilterOperator[]): this;
+    setNumericOnly(numeric: boolean): this;
+    setColumnLabel(label: string): this;
+    setFilterState(state: ColumnFilterState): this;
+    getFilterState(): ColumnFilterState;
+    private selectOperator;
+    private numericKeyDisposition;
+    private onInputKeyDown;
+    private onOperatorButtonClick;
+    private addConditionAndOpenPopover;
+    private ensureClausesPopover;
+    private pruneBlankClauses;
+    private openClausesPopover;
+    private refreshClausesPopoverBody;
+    private buildClausesBody;
+    private buildClauseRow;
+    private selectRowOperator;
+    private onRowTextChange;
+    private onAddConditionButtonClick;
+    private removeClause;
+    private syncBadge;
+    private describeClauses;
+    private fireFilterChange;
+    protected init(element?: Handle): this;
+    on(event: "commit", listener: (value: string | null) => void): this;
+    on(event: "editend", listener: () => void): this;
+    on(event: "filterchange", listener: (fieldName: string, state: ColumnFilterState, immediate: boolean) => void): this;
+    off(event: FilterCellEvent, listener: Function): this;
+    protected emit(event: "commit", value: string | null): void;
+    protected emit(event: "editend"): void;
+    protected emit(event: "filterchange", fieldName: string, state: ColumnFilterState, immediate: boolean): void;
+    protected destructor(): void;
+}
+declare const FilterCellCallable: import("../../../core/Callable.js").Callable<typeof FilterCell>;
+type FilterCellCallable = FilterCell;
+export { FilterCell as _FilterCell, FilterCellCallable as FilterCell };