@jimka/typescript-ui 0.2.0 → 0.4.0

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

@@ -4,8 +4,8 @@ export { DiagramNode } from '../../component/diagram/DiagramNode.js';
 export type { DiagramNodeOptions } from '../../component/diagram/DiagramNode.js';
 export { DiagramGroupNode } from '../../component/diagram/DiagramGroupNode.js';
 export type { DiagramGroupNodeOptions } from '../../component/diagram/DiagramGroupNode.js';
-export { DiagramEdgeLayer } from '../../component/diagram/DiagramEdgeLayer.js';
+export { DiagramEdgeLayer, EDGE_MARKER_EXTENT } from '../../component/diagram/DiagramEdgeLayer.js';
 export type { DiagramEdgeRoute } from '../../component/diagram/DiagramEdgeLayer.js';
 export { ElkLayoutEngine } from '../../component/diagram/ElkLayoutEngine.js';
-export type { DiagramLayoutResult, ElkEdgeSection, ElkPoint } from '../../component/diagram/ElkLayoutEngine.js';
+export type { DiagramLayoutResult, ElkEdgeSection, ElkPoint, ElkLayoutEngineOptions } from '../../component/diagram/ElkLayoutEngine.js';
 export type { DiagramData, DiagramNodeData, DiagramEdgeData, DiagramPortData, DiagramEdgeMarker, DiagramEdgeStyle } from '../../component/diagram/DiagramModel.js';

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

@@ -1,19 +1,23 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
-export type CanvasDrawCallback = (ctx: CanvasRenderingContext2D, width: number, height: number) => void;
+export type CanvasDrawCallback = (ctx: CanvasRenderingContext2D, width: number, height: number, elapsedMs: number) => void;
 export interface CanvasOptions extends ComponentOptions {
     onDraw?: CanvasDrawCallback;
     animateWhenHidden?: boolean;
+    maxFps?: number;
 }
 declare class Canvas extends Component<CanvasOptions> {
     private _ctx;
     private _rafId;
+    private _animationStartMs;
+    private _lastDrawMs;
+    private _elapsedMs;
     private _animationRequested;
     private _syncedWidth;
     private _syncedHeight;
     private _syncedDpr;
     private _dprToken;
-    constructor(options?: CanvasOptions);
+    constructor(options?: CanvasOptions, subclassDefaults?: Partial<CanvasOptions>);
     protected applyOptions(options: CanvasOptions): this;
     getContext(): CanvasRenderingContext2D | null;
     setOnDraw(handler: CanvasDrawCallback | null): this;
@@ -23,6 +27,8 @@ declare class Canvas extends Component<CanvasOptions> {
     stopAnimation(): this;
     isAnimating(): boolean;
     setAnimateWhenHidden(value: boolean): this;
+    setMaxFps(fps: number): this;
+    getMaxFps(): number;
     getAnimateWhenHidden(): boolean;
     protected syncBackingStore(): void;
     doLayout(): this;

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

@@ -18,7 +18,7 @@ declare class Glyph extends Component<GlyphOptions> {
     private _animatedRef;
     static register(...defs: NamedGlyphDef[]): void;
     static unregister(name: string): void;
-    constructor(name: string, options?: GlyphOptions);
+    constructor(name: string, options?: GlyphOptions, subclassDefaults?: Partial<GlyphOptions>);
     setPreferredSize(size: Size): this;
     getBaseline(): number | null;
     getGlyphName(): string;
@@ -31,6 +31,7 @@ declare class Glyph extends Component<GlyphOptions> {
     getAnimated(): GlyphAnimation | null;
     setAnimated(kind: GlyphAnimation | null): this;
     clearAnimated(): this;
+    protected onEffectiveVisibilityChange(effective: boolean): void;
     getAnimationDuration(): number;
     setAnimationDuration(ms: number): this;
     _syncReducedMotion(): void;

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

@@ -4,7 +4,7 @@ export interface HeaderOptions extends TextOptions {
 }
 declare class Header<TOptions extends HeaderOptions = HeaderOptions> extends Container<TOptions> {
     private _text;
-    constructor(text: string, options?: TOptions);
+    constructor(text: string, options?: TOptions, subclassDefaults?: Partial<TOptions>);
     protected applyOptions(options: TOptions): this;
     protected updatePreferredSize(): void;
     getText(): Text;

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

@@ -10,7 +10,7 @@ export interface IconLabelOptions extends ComponentOptions {
 declare class IconLabel extends Component<IconLabelOptions> {
     private _glyph;
     private _label;
-    constructor(glyph: string, text: string, forId: string, options?: IconLabelOptions);
+    constructor(glyph: string, text: string, forId: string, options?: IconLabelOptions, subclassDefaults?: Partial<IconLabelOptions>);
     protected applyOptions(options: IconLabelOptions): this;
     setGlyph(name: string): this;
     setText(text: string): this;

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

@@ -9,7 +9,7 @@ export interface IconTextOptions extends ComponentOptions {
 declare class IconText extends Component<IconTextOptions> {
     private _glyph;
     private _text;
-    constructor(glyph: string, text: string, options?: IconTextOptions);
+    constructor(glyph: string, text: string, options?: IconTextOptions, subclassDefaults?: Partial<IconTextOptions>);
     protected applyOptions(options: IconTextOptions): this;
     setGlyph(name: string): this;
     setText(text: string): this;

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

@@ -5,7 +5,7 @@ export interface ImageOptions extends ComponentOptions {
 }
 declare class Image extends Component<ImageOptions> {
     private _src;
-    constructor(src: String, options?: ImageOptions);
+    constructor(src: String, options?: ImageOptions, subclassDefaults?: Partial<ImageOptions>);
     getElement(createIfMissing?: boolean): Handle | undefined;
     getPreferredSize(): Size | null;
     getMinSize(): Size | null;

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

@@ -24,7 +24,7 @@ export interface VideoOptions extends ComponentOptions {
 declare class Video extends Component<VideoOptions> {
     private _listeners;
     private readonly _mediaHandlers;
-    constructor(options?: VideoOptions);
+    constructor(options?: VideoOptions, subclassDefaults?: Partial<VideoOptions>);
     protected applyOptions(options: VideoOptions): this;
     getSrc(): string | null;
     setSrc(src: string): this;

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

@@ -1,15 +1,19 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
 export type WebGLContextInitCallback = (gl: WebGL2RenderingContext) => void;
-export type WebGLFrameCallback = (gl: WebGL2RenderingContext, width: number, height: number) => void;
+export type WebGLFrameCallback = (gl: WebGL2RenderingContext, width: number, height: number, elapsedMs: number) => void;
 export interface WebGLCanvasOptions extends ComponentOptions {
     onContextInit?: WebGLContextInitCallback;
     onFrame?: WebGLFrameCallback;
     animateWhenHidden?: boolean;
+    maxFps?: number;
 }
 declare class WebGLCanvas extends Component<WebGLCanvasOptions> {
     private _gl;
     private _rafId;
+    private _animationStartMs;
+    private _lastDrawMs;
+    private _elapsedMs;
     private _animationRequested;
     private _contextLost;
     private _contextInitialised;
@@ -17,7 +21,7 @@ declare class WebGLCanvas extends Component<WebGLCanvasOptions> {
     private _syncedHeight;
     private _syncedDpr;
     private _dprToken;
-    constructor(options?: WebGLCanvasOptions);
+    constructor(options?: WebGLCanvasOptions, subclassDefaults?: Partial<WebGLCanvasOptions>);
     protected applyOptions(options: WebGLCanvasOptions): this;
     getContext(): WebGL2RenderingContext | null;
     setOnContextInit(handler: WebGLContextInitCallback | null): this;
@@ -29,6 +33,8 @@ declare class WebGLCanvas extends Component<WebGLCanvasOptions> {
     isAnimating(): boolean;
     setAnimateWhenHidden(value: boolean): this;
     getAnimateWhenHidden(): boolean;
+    setMaxFps(fps: number): this;
+    getMaxFps(): number;
     protected syncBackingStore(): void;
     doLayout(): this;
     protected render(): Handle;

package/dist/lib/types/component/editor/CodeEditor.d.ts

@@ -1,4 +1,5 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
 export interface CodeEditorChange {
     value: string;
 }
@@ -20,8 +21,8 @@ declare class CodeEditor extends Component<CodeEditorOptions> {
     private readonly _themeCompartment;
     private readonly _listeners;
     private readonly _unsubscribeTheme;
-    private readonly _onWheelClaim;
-    constructor(value?: string, options?: CodeEditorOptions);
+    private _scrollElement;
+    constructor(value?: string, options?: CodeEditorOptions, subclassDefaults?: Partial<CodeEditorOptions>);
     protected applyOptions(options: CodeEditorOptions): this;
     getValue(): string;
     setValue(value: string): this;
@@ -40,7 +41,7 @@ declare class CodeEditor extends Component<CodeEditorOptions> {
     protected emit(event: "change", payload: CodeEditorChange): void;
     protected emit(event: "readonlyedit"): void;
     protected destructor(): void;
-    private claimScrollableWheel;
+    protected getScrollElement(): Handle | undefined;
     private mount;
     private mountFlashOverlay;
     private onThemeChange;

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

@@ -15,7 +15,7 @@ declare abstract class AbstractPickerField<TValue, TDropdown extends AnimatedDro
     protected _value: TValue | null;
     protected _invalid: boolean;
     protected _showSeconds: boolean;
-    constructor(options?: TOptions);
+    constructor(options?: AbstractPickerFieldOptions, subclassDefaults?: Partial<AbstractPickerFieldOptions>);
     protected abstract formatValue(value: TValue): string;
     protected abstract parseRaw(raw: string): TValue | null;
     protected abstract createDropdown(): TDropdown;

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

@@ -7,7 +7,7 @@ declare class AutoCompleteDropdown extends AnimatedDropdown<AutoCompleteDropdown
     private readonly _list;
     private readonly _onSelect;
     private readonly _onHide;
-    constructor(onSelect: (value: string) => void, onHide: () => void, options?: AutoCompleteDropdownOptions);
+    constructor(onSelect: (value: string) => void, onHide: () => void, options?: AutoCompleteDropdownOptions, subclassDefaults?: Partial<AutoCompleteDropdownOptions>);
     show(anchorEl: Handle, suggestions: string[]): this;
     hide(): this;
     handleKey(e: KeyboardEvent): boolean;

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

@@ -8,7 +8,7 @@ export interface LinkOptions extends TextOptions {
     };
 }
 declare class Link extends Text<LinkOptions> {
-    constructor(text?: String, options?: LinkOptions);
+    constructor(text?: String, options?: LinkOptions, subclassDefaults?: Partial<LinkOptions>);
     protected applyOptions(options: LinkOptions): this;
     isInteractive(): boolean;
     setInteractive(value: boolean): this;

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

@@ -11,7 +11,7 @@ declare class NumberSpinner extends AbstractInput<number, NumberSpinnerOptions>
     private _upBtn;
     private _downBtn;
     private _btnBox;
-    constructor(options?: NumberSpinnerOptions);
+    constructor(options?: NumberSpinnerOptions, subclassDefaults?: Partial<NumberSpinnerOptions>);
     protected applyOptions(options: NumberSpinnerOptions): this;
     getBaseline(): number | null;
     private updateHeight;

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

@@ -3,7 +3,7 @@ export interface PasswordFieldOptions extends TextInputOptions {
     newPassword?: boolean;
 }
 declare class PasswordField extends TextInput<PasswordFieldOptions> {
-    constructor(options?: PasswordFieldOptions);
+    constructor(options?: PasswordFieldOptions, subclassDefaults?: Partial<PasswordFieldOptions>);
     private updateHeight;
 }
 declare const PasswordFieldCallable: import("../../core/Callable.js").Callable<typeof PasswordField>;

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

@@ -9,7 +9,7 @@ export interface SpinButtonOptions extends ButtonOptions {
 declare class SpinButton extends Button<SpinButtonOptions> {
     private _listeners;
     private _repeat;
-    constructor(symbol: "▲" | "▼", options?: SpinButtonOptions);
+    constructor(symbol: "▲" | "▼", options?: SpinButtonOptions, subclassDefaults?: Partial<SpinButtonOptions>);
     private updateSize;
     on(event: "action", listener: ClickListener): this;
     on(event: "tick", listener: () => void): this;

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

@@ -29,6 +29,7 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     private _measuredMinSize;
     private _autoMeasure;
     private _measurementDirty;
+    private _measuredGeneration;
     private _wordBreak;
     private _lineClamp;
     private _textOverflow;
@@ -41,6 +42,7 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     setPreferredSize(size: Size): this;
     private setCalculatedSize;
     private calculateSize;
+    private needsMeasure;
     measure(): void;
     getBaseline(): number | null;
     private measureOptions;
@@ -74,7 +76,7 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     setFontVariant(value: string): this;
     getFontWeight(): string | null;
     setFontWeight(value: string): this;
-    getLineHeight(): number | null;
+    getLineHeight(): number;
     setLineHeight(value: number | string): this;
     centerInHeight(px: number | null): this;
     getTextOverflow(): string | null;

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

@@ -6,7 +6,7 @@ export interface TextAreaOptions extends TextInputOptions {
     wrap?: string;
 }
 declare class TextArea extends TextInput<TextAreaOptions> {
-    constructor(text?: string, options?: TextAreaOptions);
+    constructor(text?: string, options?: TextAreaOptions, subclassDefaults?: Partial<TextAreaOptions>);
     protected applyOptions(options: TextAreaOptions): this;
     getRows(): number | null;
     setRows(value: number): this;

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

@@ -1,9 +1,11 @@
 import { TextInput, TextInputOptions } from "../../component/input/TextInput.js";
+import { BorderOptions } from "../../primitive/Border.js";
 export interface TextFieldOptions extends TextInputOptions {
 }
 declare class TextField extends TextInput<TextFieldOptions> {
-    constructor(options?: TextFieldOptions);
+    constructor(options?: TextFieldOptions, subclassDefaults?: Partial<TextFieldOptions>);
     private updateHeight;
+    setBorder(options: BorderOptions | string): this;
 }
 declare const TextFieldCallable: import("../../core/Callable.js").Callable<typeof TextField>;
 type TextFieldCallable = TextField;

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

@@ -3,7 +3,7 @@ export interface UsernameFieldOptions extends TextInputOptions {
     email?: boolean;
 }
 declare class UsernameField extends TextInput<UsernameFieldOptions> {
-    constructor(options?: UsernameFieldOptions);
+    constructor(options?: UsernameFieldOptions, subclassDefaults?: Partial<UsernameFieldOptions>);
     private updateHeight;
 }
 declare const UsernameFieldCallable: import("../../core/Callable.js").Callable<typeof UsernameField>;

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

@@ -1,4 +1,4 @@
-import { Component, ComponentOptions } from "../../core/Component.js";
+import { Comparator, Component, ComponentOptions } from "../../core/Component.js";
 import { LayoutConstraints } from "../../layout/LayoutConstraints.js";
 import { BulletedListItemStyle } from "../../component/list/BulletedListItemStyle.js";
 import { NumberedListItemStyle } from "../../component/list/NumberedListItemStyle.js";
@@ -8,10 +8,18 @@ export interface AbstractMarkerListOptions<U extends BulletedListItemStyle | Num
 }
 export declare abstract class AbstractMarkerList<U extends BulletedListItemStyle | NumberedListItemStyle> extends Component<AbstractMarkerListOptions<U>> {
     private _style;
+    private _markerColumnWidth;
     constructor(tag: string, style: U, options?: AbstractMarkerListOptions<U>, subclassDefaults?: Partial<AbstractMarkerListOptions<U>>);
     protected applyOptions(options: AbstractMarkerListOptions<U>): this;
     getStyle(): U | undefined;
     setStyle(style: U): this;
+    getMarkerColumnWidth(): number;
+    doLayout(): this;
+    protected syncMarkerColumn(): void;
+    protected abstract markerText(index: number): string;
+    protected renumber(): void;
     addComponent(component: ListItem, constraints?: LayoutConstraints): this;
+    insertComponent(component: ListItem, index: number, constraints?: LayoutConstraints): this;
     removeComponent(component: ListItem): LayoutConstraints | undefined;
+    sortComponents(comparator: Comparator<Component, Component> | undefined): this;
 }

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

@@ -4,6 +4,7 @@ export interface BulletedListOptions extends AbstractMarkerListOptions<BulletedL
 }
 declare class BulletedList extends AbstractMarkerList<BulletedListItemStyle> {
     constructor(options?: BulletedListOptions);
+    protected markerText(_index: number): string;
 }
 declare const BulletedListCallable: import("../../core/Callable.js").Callable<typeof BulletedList>;
 type BulletedListCallable = BulletedList;

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

@@ -4,12 +4,18 @@ export interface ListItemOptions extends ComponentOptions {
 }
 declare class ListItem extends Component<ListItemOptions> {
     private _key;
-    private _value;
-    constructor(key: string, value: string, options?: ListItemOptions);
+    private _marker;
+    private _text;
+    constructor(key: string, value: string, options?: ListItemOptions, subclassDefaults?: Partial<ListItemOptions>);
     protected applyOptions(options: ListItemOptions): this;
-    applyStyle(): this;
     getKey(): string;
-    render(): import("../../core/DOM.js").Handle;
+    getText(): string;
+    setText(text: string): this;
+    getMarker(): string;
+    setMarker(text: string): this;
+    getMarkerWidth(): number;
+    setMarkerColumnWidth(width: number): this;
+    protected render(): import("../../core/DOM.js").Handle;
 }
 declare const ListItemCallable: import("../../core/Callable.js").Callable<typeof ListItem>;
 type ListItemCallable = ListItem;

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

@@ -4,6 +4,7 @@ export interface NumberedListOptions extends AbstractMarkerListOptions<NumberedL
 }
 declare class NumberedList extends AbstractMarkerList<NumberedListItemStyle> {
     constructor(options?: NumberedListOptions);
+    protected markerText(index: number): string;
 }
 declare const NumberedListCallable: import("../../core/Callable.js").Callable<typeof NumberedList>;
 type NumberedListCallable = NumberedList;

package/dist/lib/types/component/menubar/MenuBarButton.d.ts

@@ -5,7 +5,7 @@ export declare const MENU_BAR_BUTTON_HEIGHT: number;
 declare class MenuBarButton extends Button<MenuBarButtonOptions> {
     private readonly _onClickHandler;
     private readonly _onMouseOverHandler;
-    constructor(text: string, onClick: () => void, onHover: () => void, options?: MenuBarButtonOptions);
+    constructor(text: string, onClick: () => void, onHover: () => void, options?: MenuBarButtonOptions, subclassDefaults?: Partial<MenuBarButtonOptions>);
     protected computePreferredSize(): {
         width: number;
         height: number;

package/dist/lib/types/component/menubar/ToolBar.d.ts

@@ -21,7 +21,7 @@ declare class ToolBar<TOptions extends ToolBarOptions = ToolBarOptions> extends
     private _overflowButton;
     private _overflowMenu;
     private _overflowSpacer;
-    constructor(options?: ToolBarOptions);
+    constructor(options?: ToolBarOptions, subclassDefaults?: Partial<ToolBarOptions>);
     protected applyOptions(options: TOptions): this;
     setOrientation(value: AxisOrientation): this;
     getOrientation(): AxisOrientation;

package/dist/lib/types/component/menubar/ToolBarSeparator.d.ts

@@ -6,7 +6,7 @@ export interface ToolBarSeparatorOptions extends ComponentOptions {
 declare class ToolBarSeparator extends Component<ToolBarSeparatorOptions> {
     static readonly THICKNESS: number;
     private readonly _orientation;
-    constructor(options?: ToolBarSeparatorOptions);
+    constructor(options?: ToolBarSeparatorOptions, subclassDefaults?: Partial<ToolBarSeparatorOptions>);
     getOrientation(): AxisOrientation;
 }
 declare const ToolBarSeparatorCallable: import("../../core/Callable.js").Callable<typeof ToolBarSeparator>;

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

@@ -11,14 +11,21 @@ declare abstract class VirtualRowView<TRow extends Component, TOptions extends C
     } | null>;
     protected _rowDisplayed: boolean[];
     protected _scroller: VirtualScroller | null;
+    private _renderDeferred;
+    private _renderResumed;
+    private _pendingScrollX;
+    private _pendingScrollY;
+    private _pendingScrollRow;
     protected abstract getRowHeight(): number;
     protected abstract createPoolRow(): TRow;
     protected abstract renderWindow(): void;
     protected initScroller(element: Handle): void;
     protected onScrollerTick(): void;
-    protected onPoolRowAdded(): void;
+    protected destructor(): void;
     setScrollX(x: number): this;
     setScrollY(y: number): this;
+    private holdScrollWhileFirstLayoutHeld;
+    private applyPendingScroll;
     protected computeVisibleWindow(scrollY: number, visibleHeight: number, totalRows: number): {
         firstRow: number;
         lastRow: number;
@@ -30,6 +37,11 @@ declare abstract class VirtualRowView<TRow extends Component, TOptions extends C
     protected positionRow(slot: number, targetY: number, rowWidth: number): boolean;
     protected hideExcessPoolRows(windowSize: number): void;
     protected invalidateGeom(): void;
+    protected deferRenderWhileFirstLayoutHeld(): boolean;
+    protected wasRenderDeferred(): boolean;
+    protected finishResumedRender(): boolean;
+    protected renderWindowIfDeferred(): boolean;
+    protected onThemeReflow(): void;
     protected scrollRowIntoView(index: number): void;
 }
 export { VirtualRowView };

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

@@ -0,0 +1 @@
+export declare function selectionsEqual<T>(a: ReadonlySet<T>, b: ReadonlySet<T>): boolean;

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

@@ -18,6 +18,13 @@ export interface CellClickEvent {
     event: MouseEvent;
 }
 export declare function resolveClickedColumn(cells: Component[], target: Handle | null): number;
+export interface ColumnWindow {
+    firstCol: number;
+    lastCol: number;
+    widths: number[];
+    lefts: number[];
+}
+export declare function computeColumnWindow(widths: number[], scrollX: number, viewportWidth: number): ColumnWindow;
 declare class Body extends VirtualRowView<Row> {
     private _store;
     private _hiddenColumns;
@@ -29,6 +36,8 @@ declare class Body extends VirtualRowView<Row> {
     private _lastColumnWidths;
     private _lastAriaRowCount;
     private _rowHeight;
+    private _colWindow;
+    private _reconciling;
     private _storeRefresh;
     private _selectedRecords;
     private _anchorRecord;
@@ -37,10 +46,11 @@ declare class Body extends VirtualRowView<Row> {
     private _header;
     private _listeners;
     constructor(store: AbstractStore);
+    protected onThemeReflow(): void;
     private computeRowHeight;
     protected getRowHeight(): number;
     protected createPoolRow(): Row;
-    protected onPoolRowAdded(): void;
+    private wireRowCells;
     private bindStore;
     protected onStoreChange(): void;
     protected getVisibleRecords(): ModelRecord[];
@@ -65,9 +75,12 @@ declare class Body extends VirtualRowView<Row> {
     protected onScrollerTick(): void;
     private onFocus;
     getEditorPool(): CellEditorPool;
+    doLayout(): this;
     renderWindow(bodyWidth?: number, columnWidths?: number[]): void;
+    private renderWindowPass;
     private updateColumnWidthCache;
-    protected bindAndPositionRows(firstRow: number, windowSize: number, rowWidth: number, fallback: number, records: ModelRecord[]): void;
+    private commitEditsOutsideWindow;
+    protected bindAndPositionRows(firstRow: number, windowSize: number, rowWidth: number, records: ModelRecord[], columns: ColumnWindow): void;
     protected onSubtreeClick(e: MouseEvent): void;
     private onRowClick;
     selectRecord(record: ModelRecord | null): void;

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

@@ -0,0 +1,6 @@
+import { Component } from "../../core/Component.js";
+export declare class CellGeometryCache {
+    private _geometry;
+    clear(): void;
+    apply(cell: Component, x: number, w: number, h: number): void;
+}

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

@@ -4,10 +4,13 @@ export declare class Column {
     private _field;
     private _minWidth;
     private _maxWidth;
+    private _width;
+    private _maxContentLength;
     private _hidden;
     private _unhideable;
     private _readOnly;
     private _headerGlyph;
+    private _headerText;
     private _group;
     private _groupColor;
     private _required;
@@ -15,10 +18,13 @@ export declare class Column {
     getField(): Field;
     getMinWidth(): number | undefined;
     getMaxWidth(): number | undefined;
+    getWidth(): number | undefined;
+    getMaxContentLength(): number | undefined;
     isInitiallyHidden(): boolean;
     isUnhideable(): boolean;
     isReadOnly(): boolean;
     getHeaderGlyph(): string | null;
+    getHeaderText(): string | null;
     setHeaderGlyph(name: string | null): this;
     clearHeaderGlyph(): this;
     getGroup(): string | null;

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

@@ -11,6 +11,8 @@ export interface ColumnConfig {
     field: string;
     minWidth?: number;
     maxWidth?: number;
+    width?: number;
+    maxContentLength?: number;
     hidden?: boolean;
     unhideable?: boolean;
     readOnly?: boolean;
@@ -21,6 +23,7 @@ export interface ColumnConfig {
     cellValues?: (record: ModelRecord) => Array<ComboOption | string> | undefined;
     renderer?: () => CellRenderer<any>;
     headerGlyph?: string;
+    headerText?: string;
     group?: string;
     groupColor?: string;
     required?: boolean;
@@ -30,4 +33,5 @@ export interface ColumnSpec {
     columns: ColumnConfig[];
     appendUnlisted?: boolean;
     rowReadOnly?: (record: ModelRecord) => boolean;
+    autoSizeColumns?: boolean;
 }

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

@@ -5,6 +5,12 @@ import { AbstractModel } from "../../data/AbstractModel.js";
 import { AbstractStore } from "../../data/AbstractStore.js";
 import { Column } from "../../component/table/Column.js";
 export type TableHeaderEvent = "columnresizestart" | "columnresize" | "columncontextmenu";
+export interface HeaderColumnGeometry {
+    columnWidths: number[];
+    viewportWidth: number;
+    columnHeight: number;
+    parentRowHeight: number;
+}
 declare class TableHeader extends Component {
     private _model;
     private _store;
@@ -12,8 +18,16 @@ declare class TableHeader extends Component {
     private _columns;
     private _listeners;
     private _scrollbarCover;
+    private _visibleFields;
+    private _windowFirst;
+    private _scrollX;
+    private _focusedCol;
+    private _columnsDirty;
+    private _geometry;
+    private _cellGeom;
     constructor(model: AbstractModel, store: AbstractStore);
     getModel(): AbstractModel;
+    setStore(store: AbstractStore): this;
     setModel(model: AbstractModel): this;
     setHiddenColumns(hidden: Set<string>): this;
     setColumns(columns: Column[]): this;
@@ -25,19 +39,28 @@ declare class TableHeader extends Component {
     protected emit(event: "columnresize", colIndex: number, clientX: number): void;
     protected emit(event: "columncontextmenu", fieldName: string, x: number, y: number): void;
     getColumns(): import("../../core/Component.js")._Component<import("../../core/Component.js").ComponentOptions>[];
+    getColumnWindowStart(): number;
     getParentRow(): Row;
     hasParentRow(): boolean;
     getScrollbarCover(): Handle;
-    sortColumns(): void;
     addRow(row: Row): this;
     addComponent(row: Row): this;
-    setWidth(width: number): this;
     setHeight(height: number): this;
     private rebuildCells;
+    private computeVisibleFields;
+    private reconcileColumnCells;
     private rebuildParentCells;
     private wireCell;
+    private columnIndexOf;
     private handleSortClick;
     private syncSortIndicators;
+    renderColumnWindow(geometry?: HeaderColumnGeometry): this;
+    private positionColumnCells;
+    private positionParentCells;
+    setScrollX(scrollLeft: number): this;
+    getScrollX(): number;
+    setFocusedColumn(colIndex: number | null): this;
+    private applyFocusedColumn;
 }
 declare const TableHeaderCallable: import("../../core/Callable.js").Callable<typeof TableHeader>;
 type TableHeaderCallable = TableHeader;

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

@@ -8,11 +8,18 @@ declare class Row extends Component {
     private _model?;
     private _data?;
     private _onCellCommit?;
-    private _fieldNames;
     private _treeCell;
     private _stripe;
+    private _visibleFields;
+    private _columnConfigs;
+    private _treeFieldName;
+    private _windowFirst;
+    private _cellKeys;
+    private _fieldNames;
+    private _columnsDirty;
     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[];
     getData(): ModelRecord | undefined;
     setData(record: ModelRecord): this;
@@ -20,7 +27,11 @@ declare class Row extends Component {
     updateVisualState(): void;
     addColumn(cell: Cell<any>, constraints?: LayoutConstraints): this;
     addComponent(cell: Cell<any>, constraints?: LayoutConstraints): this;
-    syncCells(model: AbstractModel, hiddenColumns: Set<string>, columnConfigs: Map<string, ColumnConfig>, treeFieldName?: string): this;
+    setColumnFields(model: AbstractModel, hiddenColumns: Set<string>, columnConfigs: Map<string, ColumnConfig>, treeFieldName?: string): this;
+    setColumnWindow(firstCol: number, lastCol: number): boolean;
+    private commitCellValue;
+    private static cellKey;
+    private cellKeyFor;
     private bindCell;
     private static createCellForField;
     doLayout(): this;