@jimka/typescript-ui 0.5.0 → 0.7.0

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

@@ -3,12 +3,14 @@ import type { Handle } from "../../core/DOM.js";
 import { AbstractStore } from "../../data/AbstractStore.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
 import { Row } from "../../component/table/Row.js";
+import type { ColumnWindowSlidePlan } 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";
 import type { TableHeader } from "../../component/table/Header.js";
-export type BodyEvent = "verticalscroll" | "horizontalscroll" | "selection" | "cellclick";
+export type BodyEvent = "verticalscroll" | "horizontalscroll" | "selection" | "cellclick" | "cellcontextmenu";
 export interface CellClickEvent {
     record: ModelRecord;
     field: string;
@@ -17,6 +19,19 @@ export interface CellClickEvent {
     rowIndex: number;
     event: MouseEvent;
 }
+export interface BodyViewState {
+    store: AbstractStore;
+    columns: Column[];
+    columnConfigs: Map<string, ColumnConfig>;
+    hiddenColumns: Set<string>;
+    rowReadOnly: ((record: ModelRecord) => boolean) | null;
+    rowVisible: ((record: ModelRecord) => boolean) | null;
+    rowSeparator: ((record: ModelRecord) => {
+        label: string;
+        color: string | null;
+    } | null) | null;
+    rowIndented: ((record: ModelRecord) => boolean) | null;
+}
 export declare function resolveClickedColumn(cells: Component[], target: Handle | null): number;
 export interface ColumnWindow {
     firstCol: number;
@@ -31,7 +46,9 @@ declare class Body extends VirtualRowView<Row> {
     private _columns;
     private _columnConfigs;
     private _rowReadOnly;
-    private _cellGeom;
+    private _rowVisible;
+    private _rowSeparator;
+    private _rowIndented;
     private _lastBodyWidth;
     private _lastColumnWidths;
     private _lastAriaRowCount;
@@ -42,6 +59,10 @@ declare class Body extends VirtualRowView<Row> {
     private _selectedRecords;
     private _anchorRecord;
     private _focusedColIndex;
+    private _rangeAnchor;
+    private _rangeFocus;
+    private _contextMenuCell;
+    private _cellText;
     private _editorPool;
     private _header;
     private _listeners;
@@ -54,6 +75,7 @@ declare class Body extends VirtualRowView<Row> {
     private bindStore;
     protected onStoreChange(): void;
     protected getVisibleRecords(): ModelRecord[];
+    private computeVisibleFields;
     protected createRow(): Row;
     protected getTreeFieldName(): string | undefined;
     protected computeRowAria(row: Row, dataIndex: number): void;
@@ -63,14 +85,22 @@ declare class Body extends VirtualRowView<Row> {
     protected getHiddenColumns(): Set<string>;
     protected getColumnConfigs(): Map<string, ColumnConfig>;
     protected getRowPool(): Row[];
-    protected invalidateGeom(): void;
     setHiddenColumns(hidden: Set<string>): this;
+    private filterUnhideable;
     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;
     setStore(store: AbstractStore): this;
+    private rebindStore;
+    bindViewState(state: BodyViewState): this;
     protected init(element?: Handle): this;
     protected onScrollerTick(): void;
     private onFocus;
@@ -78,12 +108,26 @@ declare class Body extends VirtualRowView<Row> {
     protected destructor(): void;
     doLayout(): this;
     renderWindow(bodyWidth?: number, columnWidths?: number[]): void;
+    private computeColumnWindowSlidePlan;
     private renderWindowPass;
     private updateColumnWidthCache;
     private commitEditsOutsideWindow;
-    protected bindAndPositionRows(firstRow: number, windowSize: number, rowWidth: number, records: ModelRecord[], columns: ColumnWindow): void;
+    protected bindAndPositionRows(firstRow: number, windowSize: number, rowWidth: number, records: ModelRecord[], columns: ColumnWindow, slidePlan?: ColumnWindowSlidePlan): void;
     protected onSubtreeClick(e: MouseEvent): void;
     private onRowClick;
+    private locateCellFromTarget;
+    private getCellRangeBounds;
+    private isCellWithinBounds;
+    private refreshCellRangeHighlight;
+    private updateCellRangeVisualState;
+    private buildCopyText;
+    copySelectionToClipboard(): void;
+    copyContextMenuSelection(): void;
+    protected onCellMouseDown(e: MouseEvent): void;
+    protected onCellDragMove(e: MouseEvent): Event.ListenerResult;
+    protected onCellDragEnd(): Event.ListenerResult;
+    private onCellDragSelectStart;
+    protected onCellContextMenu(e: MouseEvent): Event.ListenerResult;
     selectRecord(record: ModelRecord | null): void;
     getSelectedRecord(): ModelRecord | null;
     getSelectedRecords(): ModelRecord[];
@@ -92,10 +136,12 @@ declare class Body extends VirtualRowView<Row> {
     on(event: "horizontalscroll", listener: (scrollLeft: number) => void): this;
     on(event: "selection", listener: (records: ModelRecord[]) => void): this;
     on(event: "cellclick", listener: (e: CellClickEvent) => void): this;
+    on(event: "cellcontextmenu", listener: (x: number, y: number) => void): this;
     off(event: BodyEvent, listener: Function): this;
     protected emit(event: "verticalscroll" | "horizontalscroll", offset: number): void;
     protected emit(event: "selection", records: ModelRecord[]): void;
     protected emit(event: "cellclick", detail: CellClickEvent): void;
+    protected emit(event: "cellcontextmenu", x: number, y: number): void;
     private notifySelectionChange;
     scrollToRecord(record: ModelRecord): void;
     private applyReadOnlyState;
@@ -105,7 +151,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,20 +19,30 @@ declare class TableHeader extends Component {
     private _hiddenColumns;
     private _columns;
     private _listeners;
-    private _scrollbarCover;
+    private _menuButton;
+    private _boundOnMenuButtonAction;
     private _visibleFields;
     private _windowFirst;
     private _scrollX;
     private _focusedCol;
     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 +54,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 +71,23 @@ 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 invalidateCellLayouts;
+    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

@@ -1,9 +1,20 @@
 import { Component } from "../../core/Component.js";
 import { AbstractModel } from "../../data/AbstractModel.js";
+import { Field } from "../../data/Field.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
 import { Cell } from "../../component/table/cell/Cell.js";
 import type { ColumnConfig } from "../../component/table/ColumnConfig.js";
 import { LayoutConstraints } from "../../layout/LayoutConstraints.js";
+export interface ColumnWindowSlidePlan {
+    prevFirstCol: number;
+    prevLastCol: number;
+    delta: number;
+    enteringKeys: Map<number, string>;
+}
+export interface RetargetedCell {
+    cell: Cell<any>;
+    fieldName: string;
+}
 declare class Row extends Component {
     private _model?;
     private _data?;
@@ -16,11 +27,17 @@ declare class Row extends Component {
     private _windowFirst;
     private _cellKeys;
     private _fieldNames;
+    private _cellCache;
+    private _lastRetargeted;
     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[];
+    getRetargetedCells(): RetargetedCell[];
+    isSeparator(): boolean;
+    setFieldIndent(indented: boolean): void;
     getData(): ModelRecord | undefined;
     setData(record: ModelRecord): this;
     setStripe(striped: boolean): void;
@@ -28,13 +45,18 @@ 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;
-    setColumnWindow(firstCol: number, lastCol: number): boolean;
+    renderSeparator(label: string, color: string | null): void;
+    setColumnWindow(firstCol: number, lastCol: number, plan?: ColumnWindowSlidePlan): boolean;
+    private reconcileWindowSlide;
     private commitCellValue;
-    private static cellKey;
+    static cellKey(field: Field, config: ColumnConfig | undefined, isTreeColumn: boolean): string;
     private cellKeyFor;
     private bindCell;
     private static createCellForField;
+    private retireCell;
+    private disposeCellCache;
     doLayout(): this;
+    protected destructor(): void;
 }
 declare const RowCallable: import("../../core/Callable.js").Callable<typeof Row>;
 type RowCallable = Row;

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,29 @@ 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 showCellMenu;
+    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;
+    exportTSV(options?: ExportOptions): void;
     private getExportColumns;
+    getCellText(field: string, record: ModelRecord): string;
     private onColumnResizeStart;
     private onColumnResize;
     private resetColumns;
@@ -105,6 +134,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,18 @@
 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 exportTSV(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;
+    static buildRectangularTSV(rows: string[][]): string;
+    private static escapeTSVField;
     private static download;
 }

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

@@ -19,6 +19,7 @@ declare class TablePanel extends Container {
     setExportMenuEnabled(enabled: boolean): this;
     exportCSV(options?: ExportOptions): void;
     exportJSON(options?: ExportOptions): void;
+    exportTSV(options?: ExportOptions): void;
     setPaginationBar(bar: PaginationBar): this;
     getPaginationBar(): PaginationBar | undefined;
 }

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/TreeTablePanel.d.ts

@@ -20,6 +20,7 @@ declare class TreeTablePanel extends Container {
     setExportMenuEnabled(enabled: boolean): this;
     exportCSV(options?: ExportOptions): void;
     exportJSON(options?: ExportOptions): void;
+    exportTSV(options?: ExportOptions): void;
     setPaginationBar(bar: PaginationBar): this;
     getPaginationBar(): PaginationBar | undefined;
 }

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

@@ -1,4 +1,5 @@
-import { Component } from "../../../core/Component.js";
+import { Component, ComponentOptions } from "../../../core/Component.js";
+import type { ClassStyleDefaults } from "../../../core/ClassStyleRules.js";
 import { ListenerBag } from "../../../core/ListenerBag.js";
 import { Card } from "../../../layout/Card.js";
 import { CellRenderer } from "../../../component/table/cell/renderer/CellRenderer.js";
@@ -8,8 +9,10 @@ import { CellEditorPool } from "../../../component/table/cell/editor/CellEditorP
 import { LayoutConstraints } from "../../../layout/LayoutConstraints.js";
 export type CellEvent = "commit" | "editend";
 export declare class Cell<T> extends Component {
+    protected static readonly ownClassStyleDefaults: ClassStyleDefaults;
     private _readOnly;
     private _requiredEmpty;
+    private _rangeSelected;
     private _baseBackground;
     private _renderer;
     private _editor;
@@ -17,8 +20,9 @@ export declare class Cell<T> extends Component {
     private _scrollIntoView;
     protected _activeEditor: CellEditor<T> | null;
     protected _listeners: ListenerBag<string>;
-    constructor(tag: string, renderer: CellRenderer<T>, editor?: CellEditor<T>, rendererConstraints?: LayoutConstraints, editorContraints?: LayoutConstraints);
+    constructor(tag: string, renderer: CellRenderer<T>, editor?: CellEditor<T>, rendererConstraints?: LayoutConstraints, editorContraints?: LayoutConstraints, subclassDefaults?: Partial<ComponentOptions>);
     protected clampsToContentSize(): boolean;
+    protected canSkipUnchangedLayout(): boolean;
     getEditorKey(): string | null;
     setEditorPool(pool: CellEditorPool | null): this;
     setScrollIntoViewHandler(handler: (() => void) | null): this;
@@ -30,6 +34,7 @@ export declare class Cell<T> extends Component {
     isReadOnly(): boolean;
     setReadOnly(value: boolean): this;
     setRequiredEmpty(value: boolean): this;
+    setRangeSelected(value: boolean): this;
     setBaseBackground(color: string | null): this;
     private _applyStateTint;
     onKeyDown(evnt: CustomEvent<ForwardedKeyDetail>): void;

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/Default.d.ts

@@ -1,7 +1,7 @@
 import { StringRenderer } from "../../../component/table/cell/renderer/String.js";
 import { Cell } from "../../../component/table/cell/Cell.js";
 declare class DefaultCell extends Cell<String | null> {
-    constructor(tag?: string);
+    constructor(tag?: string, renderer?: StringRenderer);
     getRenderer(): StringRenderer;
     setValue(value: String | null): this;
 }

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 };

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

@@ -0,0 +1,21 @@
+import { Component, ComponentOptions } from "../../../core/Component.js";
+import type { Handle } from "../../../core/DOM.js";
+interface FilterClauseBadgeOptions extends ComponentOptions {
+    count?: number | null;
+}
+declare class FilterClauseBadge extends Component<FilterClauseBadgeOptions> {
+    private _count;
+    private _description;
+    constructor(options?: FilterClauseBadgeOptions, subclassDefaults?: Partial<FilterClauseBadgeOptions>);
+    protected applyOptions(options: FilterClauseBadgeOptions): this;
+    protected render(): Handle;
+    getCount(): number | null;
+    getAccessibleDescription(): string | null;
+    setAccessibleDescription(text: string | null): this;
+    setCount(value: number | null): this;
+    private _countText;
+    private _shouldShow;
+}
+declare const FilterClauseBadgeCallable: import("../../../core/Callable.js").Callable<typeof FilterClauseBadge>;
+type FilterClauseBadgeCallable = FilterClauseBadge;
+export { FilterClauseBadge as _FilterClauseBadge, FilterClauseBadgeCallable as FilterClauseBadge };

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

@@ -0,0 +1,9 @@
+import { DefaultCell } from "../../../component/table/cell/Default.js";
+declare class GroupSeparatorCell extends DefaultCell {
+    private _color;
+    constructor(text: string, color: string | null);
+    getColor(): string | null;
+}
+declare const GroupSeparatorCellCallable: import("../../../core/Callable.js").Callable<typeof GroupSeparatorCell>;
+type GroupSeparatorCellCallable = GroupSeparatorCell;
+export { GroupSeparatorCell as _GroupSeparatorCell, GroupSeparatorCellCallable as GroupSeparatorCell };