@jimka/typescript-ui 0.4.1 → 0.6.0

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;
@@ -75,6 +92,7 @@ declare class Body extends VirtualRowView<Row> {
     protected onScrollerTick(): void;
     private onFocus;
     getEditorPool(): CellEditorPool;
+    protected destructor(): void;
     doLayout(): this;
     renderWindow(bodyWidth?: number, columnWidths?: number[]): void;
     private renderWindowPass;
@@ -83,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[];
@@ -104,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 };

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

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

@@ -46,6 +46,7 @@ declare class HeaderCell extends DefaultCell {
     setTooltip(text: string): this;
     getTooltip(): string;
     private onSortClick;
+    private onContextMenu;
     private onResizeDragStart;
     private onResizeDrag;
     private onResizeDragStop;

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

@@ -5,7 +5,7 @@ interface SortPriorityBadgeOptions extends ComponentOptions {
 }
 declare class SortPriorityBadge extends Component<SortPriorityBadgeOptions> {
     private _priority;
-    constructor(options?: SortPriorityBadgeOptions);
+    constructor(options?: SortPriorityBadgeOptions, subclassDefaults?: Partial<SortPriorityBadgeOptions>);
     protected applyOptions(options: SortPriorityBadgeOptions): this;
     protected render(): Handle;
     getPriority(): number | null;

package/dist/lib/types/component/table/cell/editor/CellEditor.d.ts

@@ -19,4 +19,5 @@ export declare abstract class CellEditor<T> extends Component {
     setCommitRequestHandler(handler: () => void): void;
     protected requestCommit(): void;
     getContentX(): number;
+    getDisplayText(): string;
 }

package/dist/lib/types/component/table/cell/editor/CellEditorPool.d.ts

@@ -9,5 +9,6 @@ export declare class CellEditorPool {
     register(key: string, factory: CellEditorFactory): this;
     acquire(key: string, cell: Cell<any>): CellEditor<unknown> | null;
     release(): void;
+    dispose(): void;
     private wireListeners;
 }

package/dist/lib/types/component/table/cell/editor/Date.d.ts

@@ -5,6 +5,7 @@ declare class DateEditor extends TextInputCellEditor<Date | null> {
     private _animated;
     private _text;
     constructor();
+    protected destructor(): void;
     isEmpty(): boolean;
     getValue(): Date | null;
     setValue(value: Date | null): this;

package/dist/lib/types/component/table/cell/editor/DateTime.d.ts

@@ -7,6 +7,7 @@ declare class DateTimeEditor extends TextInputCellEditor<Date | null> {
     private _animated;
     private _text;
     constructor(showSeconds?: boolean);
+    protected destructor(): void;
     retainsFocus(relatedTarget: Handle | null): boolean;
     isEmpty(): boolean;
     getValue(): Date | null;

package/dist/lib/types/component/table/cell/editor/Time.d.ts

@@ -6,6 +6,7 @@ declare class TimeEditor extends TextInputCellEditor<Date | null> {
     private _animated;
     private _text;
     constructor(showSeconds?: boolean);
+    protected destructor(): void;
     isEmpty(): boolean;
     getValue(): Date | null;
     setValue(value: Date | null): this;

package/dist/lib/types/component/table/cell/renderer/CellRenderer.d.ts

@@ -4,5 +4,6 @@ export declare abstract class CellRenderer<T> extends Component {
     abstract getValue(): T;
     abstract setValue(t: T): void;
     getContentX(): number;
+    getDisplayText(): string;
     doLayout(): this;
 }

package/dist/lib/types/component/table/cell/renderer/Combo.d.ts

@@ -5,10 +5,12 @@ declare class ComboRenderer extends CellRenderer<String | null> {
     private _text;
     private _map;
     private _value;
+    private _display;
     constructor(optionList: Array<ComboOption | string>);
     getText(): Text;
     getValue(): String | null;
     setValue(value: String | null): this;
+    getDisplayText(): string;
     setOptions(optionList: Array<ComboOption | string>): this;
 }
 declare const ComboRendererCallable: import("../../../../core/Callable.js").Callable<typeof ComboRenderer>;

package/dist/lib/types/component/table/cell/renderer/Date.d.ts

@@ -2,9 +2,11 @@ import { CellRenderer } from "../../../../component/table/cell/renderer/CellRend
 declare class DateRenderer extends CellRenderer<Date | null> {
     private _text;
     private _value;
+    private _display;
     constructor();
     getValue(): Date | null;
     setValue(value: Date | null): this;
+    getDisplayText(): string;
 }
 declare const DateRendererCallable: import("../../../../core/Callable.js").Callable<typeof DateRenderer>;
 type DateRendererCallable = DateRenderer;

package/dist/lib/types/component/table/cell/renderer/DateTime.d.ts

@@ -3,9 +3,11 @@ declare class DateTimeRenderer extends CellRenderer<Date | null> {
     private _text;
     private _value;
     private _showSeconds;
+    private _display;
     constructor(showSeconds?: boolean);
     getValue(): Date | null;
     setValue(value: Date | null): this;
+    getDisplayText(): string;
 }
 declare const DateTimeRendererCallable: import("../../../../core/Callable.js").Callable<typeof DateTimeRenderer>;
 type DateTimeRendererCallable = DateTimeRenderer;

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

@@ -0,0 +1,16 @@
+import { CellRenderer } from "../../../../component/table/cell/renderer/CellRenderer.js";
+import { TextField } from "../../../../component/input/TextField.js";
+import { MenuButton } from "../../../../component/button/MenuButton.js";
+declare class FilterCellRenderer extends CellRenderer<string | null> {
+    private _input;
+    private _operatorButton;
+    constructor();
+    getInput(): TextField;
+    getOperatorButton(): MenuButton;
+    setMenuOpenPredicate(predicate: (() => boolean) | null): this;
+    getValue(): string | null;
+    setValue(value: string | null): void;
+}
+declare const FilterCellRendererCallable: import("../../../../core/Callable.js").Callable<typeof FilterCellRenderer>;
+type FilterCellRendererCallable = FilterCellRenderer;
+export { FilterCellRenderer as _FilterCellRenderer, FilterCellRendererCallable as FilterCellRenderer };

package/dist/lib/types/component/table/cell/renderer/Glyph.d.ts

@@ -4,6 +4,7 @@ declare class GlyphRenderer extends CellRenderer<String | null> {
     private _glyph;
     getValue(): String | null;
     setValue(value: String | null): this;
+    getDisplayText(): string;
 }
 declare const GlyphRendererCallable: import("../../../../core/Callable.js").Callable<typeof GlyphRenderer>;
 type GlyphRendererCallable = GlyphRenderer;

package/dist/lib/types/component/table/cell/renderer/Link.d.ts

@@ -6,10 +6,12 @@ export interface LinkCellRendererOptions {
 declare class LinkCellRenderer extends CellRenderer<String | null> {
     private readonly _text;
     private _value;
+    private _display;
     constructor(options?: LinkCellRendererOptions);
     getText(): Text;
     getValue(): String | null;
     setValue(value: String | null): void;
+    getDisplayText(): string;
 }
 declare const LinkCellRendererCallable: import("../../../../core/Callable.js").Callable<typeof LinkCellRenderer>;
 type LinkCellRendererCallable = LinkCellRenderer;

package/dist/lib/types/component/table/cell/renderer/Number.d.ts

@@ -2,9 +2,11 @@ import { CellRenderer } from "../../../../component/table/cell/renderer/CellRend
 declare class NumberRenderer extends CellRenderer<Number | null> {
     private _text;
     private _value;
-    constructor();
+    private _display;
+    constructor(align?: "left" | "right");
     getValue(): Number | null;
     setValue(value: Number | null): this;
+    getDisplayText(): string;
 }
 declare const NumberRendererCallable: import("../../../../core/Callable.js").Callable<typeof NumberRenderer>;
 type NumberRendererCallable = NumberRenderer;

package/dist/lib/types/component/table/cell/renderer/String.d.ts

@@ -3,10 +3,12 @@ import { Text } from "../../../../component/input/Text.js";
 declare class StringRenderer extends CellRenderer<String | null> {
     private _text;
     private _value;
+    private _display;
     constructor();
     getText(): Text;
     getValue(): String | null;
     setValue(value: String | null): this;
+    getDisplayText(): string;
 }
 declare const StringRendererCallable: import("../../../../core/Callable.js").Callable<typeof StringRenderer>;
 type StringRendererCallable = StringRenderer;