@jimka/typescript-ui 0.1.1 → 0.3.0

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

@@ -1,23 +1,29 @@
 import { Panel, PanelOptions } from "../../core/Panel.js";
 import { Component } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
-import { DiagramData, DiagramNodeData } from "../../component/diagram/DiagramModel.js";
+import { DiagramData, DiagramEdgeData, DiagramNodeData } from "../../component/diagram/DiagramModel.js";
 import { ElkLayoutEngine } from "../../component/diagram/ElkLayoutEngine.js";
 export type DiagramNodeRenderer = (data: DiagramNodeData) => Component;
-export type DiagramViewEvent = "selection" | "activate" | "layout";
+export type DiagramViewEvent = "selection" | "activate" | "layout" | "contextmenu" | "edgehover" | "edgeleave";
 export interface DiagramViewOptions extends PanelOptions {
     data?: DiagramData;
     nodeRenderer?: DiagramNodeRenderer;
     groupRenderer?: DiagramNodeRenderer;
     layoutOptions?: Record<string, string>;
     elkWorkerUrl?: string;
+    elkWorkerFactory?: () => Worker;
     minZoom?: number;
     maxZoom?: number;
     zoom?: number;
+    controls?: boolean;
+    initialFocusNode?: string;
     listeners?: {
         selection?: (nodes: DiagramNodeData[]) => void;
         activate?: (node: DiagramNodeData) => void;
         layout?: () => void;
+        contextmenu?: (node: DiagramNodeData, event: MouseEvent) => void;
+        edgehover?: (edges: DiagramEdgeData[], event: MouseEvent) => void;
+        edgeleave?: () => void;
     };
 }
 declare class DiagramView extends Panel<DiagramViewOptions> {
@@ -27,53 +33,118 @@ declare class DiagramView extends Panel<DiagramViewOptions> {
     private _nodeComponents;
     private _nodeData;
     private _containerIds;
+    private _incomingComponents;
+    private _incomingData;
+    private _incomingContainerIds;
     private _selection;
+    private _nodeEmphasis;
     private _layoutGeneration;
+    private _layoutSettled;
+    private _busySpinner;
     private _graphWidth;
     private _graphHeight;
     private _listeners;
+    private _hoveredEdgeKey;
     private _panning;
     private _panStartX;
     private _panStartY;
-    private _panScrollLeft;
-    private _panScrollTop;
+    private _pressX;
+    private _pressY;
+    private _pointerMoved;
+    private _panOriginX;
+    private _panOriginY;
+    private _panX;
+    private _panY;
+    private _needsInitialCentre;
+    private _focusNodeId;
+    private _lastViewportWidth;
+    private _lastViewportHeight;
+    private _controls;
+    private _zoomInBtn;
+    private _zoomOutBtn;
+    private _fitBtn;
+    private _resetBtn;
+    private readonly _onZoomIn;
+    private readonly _onZoomOut;
+    private readonly _onFit;
+    private readonly _onReset;
     constructor(options?: DiagramViewOptions);
     protected createEngine(): ElkLayoutEngine;
+    protected destructor(): void;
     protected applyOptions(options: DiagramViewOptions): this;
     setData(data: DiagramData): this;
     getData(): DiagramData | null;
     private rebuildNodes;
+    private discardIncomingNodes;
+    private promoteIncomingNodes;
     private relayout;
+    private armLayoutSettled;
+    private settleLayout;
+    private syncBusyIndicator;
+    whenLaidOut(): Promise<void>;
     private collectNodeSizes;
     private applyLayout;
     private applyContainerZIndex;
     private joinEdgeStyles;
     private handleLayoutFailure;
-    private applyZoomToHost;
+    private applyTransformToHost;
     getZoom(): number;
     setZoom(zoom: number): this;
     zoomToFit(): this;
+    resetView(): this;
+    zoomIn(): this;
+    zoomOut(): this;
+    private tryInitialCentre;
+    private centreGraph;
+    private zoomAboutViewportPoint;
+    private effectiveMinZoom;
     private clampZoom;
+    private zoomFittingNode;
     getSelection(): DiagramNodeData[];
     selectNode(id: string | null): this;
+    setEdgeEmphasis(ids: readonly string[] | null): this;
+    getEdgeEmphasis(): string[];
+    setNodeEmphasis(ids: readonly string[] | null): this;
+    getNodeEmphasis(): string[];
+    private applyNodeEmphasis;
     revealNode(id: string): this;
+    private centreNode;
+    focusNode(id: string): this;
     private setSelection;
     private applySelectedVisual;
     on(event: "selection", listener: (nodes: DiagramNodeData[]) => void): this;
     on(event: "activate", listener: (node: DiagramNodeData) => void): this;
     on(event: "layout", listener: () => void): this;
+    on(event: "contextmenu", listener: (node: DiagramNodeData, event: MouseEvent) => void): this;
+    on(event: "edgehover", listener: (edges: DiagramEdgeData[], event: MouseEvent) => void): this;
+    on(event: "edgeleave", listener: () => void): this;
     off(event: DiagramViewEvent, listener: Function): this;
     protected emit(event: "selection", nodes: DiagramNodeData[]): void;
     protected emit(event: "activate", node: DiagramNodeData): void;
     protected emit(event: "layout"): void;
+    protected emit(event: "contextmenu", node: DiagramNodeData, mouseEvent: MouseEvent): void;
+    protected emit(event: "edgehover", edges: DiagramEdgeData[], mouseEvent: MouseEvent): void;
+    protected emit(event: "edgeleave"): void;
+    doLayout(): this;
+    private anchorCentreAcrossResize;
     protected init(element?: Handle): this;
     private _handleClick;
     private _handleDoubleClick;
     private nodeIdAt;
+    private _handleEdgeMouseMove;
+    private _handleEdgeMouseOut;
+    private leaveEdges;
+    private _handleContextMenu;
+    private isControlsTarget;
     private _handleWheel;
     private _handlePointerDown;
     private _handlePointerMove;
     private _handlePointerUp;
+    private buildControls;
+    private makeControlButton;
+    private wireControlListeners;
+    isControlsVisible(): boolean;
+    setControlsVisible(value: boolean): this;
 }
 declare const DiagramViewCallable: import("../../core/Callable.js").Callable<typeof DiagramView>;
 type DiagramViewCallable = DiagramView;

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

@@ -54,14 +54,27 @@ export declare function buildElkGraph(data: DiagramData, sizes: Map<string, {
     height: number;
 }>, defaults?: Record<string, string>): ElkNode;
 export declare function mapElkResult(result: ElkNode): DiagramLayoutResult;
+export interface ElkLayoutEngineOptions {
+    workerFactory?: () => Worker;
+    workerUrl?: string;
+}
 export declare class ElkLayoutEngine {
     private _elk;
+    private readonly _workerFactory?;
     private readonly _workerUrl?;
-    constructor(workerUrl?: string);
+    private _workerBacked;
+    private _disposed;
+    private _ownsWorker;
+    private _building;
+    constructor(options?: ElkLayoutEngineOptions);
     layout(data: DiagramData, sizes: Map<string, {
         width: number;
         height: number;
     }>, defaults?: Record<string, string>): Promise<DiagramLayoutResult>;
+    dispose(): void;
     private ensureElk;
+    private terminateOwnedWorker;
+    private createElk;
+    private createMainThreadElk;
 }
 export {};

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

@@ -1,5 +1,6 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
+import { Size } from "../../primitive/Size.js";
 import { NamedGlyphDef } from "../../component/display/Glyphs.js";
 export type GlyphAnimation = "spin" | "pulse" | "beat";
 export interface GlyphOptions extends ComponentOptions {
@@ -18,7 +19,7 @@ declare class Glyph extends Component<GlyphOptions> {
     static register(...defs: NamedGlyphDef[]): void;
     static unregister(name: string): void;
     constructor(name: string, options?: GlyphOptions);
-    setPreferredSize(width: number, height: number): this;
+    setPreferredSize(size: Size): this;
     getBaseline(): number | null;
     getGlyphName(): string;
     getFontSize(): number | null;

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

@@ -23,7 +23,7 @@ declare class Markdown extends Component<MarkdownOptions> {
     getMinSize(): Size | null;
     getPreferredSize(): Size | null;
     setWidth(width: number): this;
-    dispose(): void;
+    protected destructor(): void;
     private measureContentHeight;
     protected render(): Handle;
     private create;

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

@@ -15,7 +15,7 @@ declare class PaginationBar extends Component<PaginationBarOptions> {
     private readonly _onStoreUpdate;
     constructor(store: AbstractStore, options?: PaginationBarOptions);
     protected applyOptions(options: PaginationBarOptions): this;
-    dispose(): void;
+    protected destructor(): void;
     private refresh;
 }
 declare const PaginationBarCallable: import("../../core/Callable.js").Callable<typeof PaginationBar>;

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

@@ -0,0 +1,2 @@
+import { Component } from "../../core/Component.js";
+export declare function createSpinnerWrap(): Component;

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

@@ -50,7 +50,7 @@ declare class Video extends Component<VideoOptions> {
     off(event: VideoMediaEvent, listener: () => void): this;
     protected emit(event: VideoMediaEvent): void;
     protected init(element?: Handle): this;
-    dispose(): void;
+    protected destructor(): void;
     private buildMediaHandlers;
     private replayMediaOptions;
     private attachMediaListeners;

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

@@ -73,7 +73,7 @@ declare class VideoPlayer extends Component<VideoPlayerOptions> {
     off(event: VideoPlayerEvent, listener: () => void): this;
     protected emit(event: VideoPlayerEvent): void;
     protected init(element?: Handle): this;
-    dispose(): void;
+    protected destructor(): void;
     private syncFromState;
     private syncFromVideo;
     private buildControlBar;

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;
 }
@@ -14,12 +15,13 @@ export interface CodeEditorOptions extends ComponentOptions {
 declare class CodeEditor extends Component<CodeEditorOptions> {
     private _view;
     private _flashOverlay;
+    private _flashAnimation;
     private readonly _langCompartment;
     private readonly _readOnlyCompartment;
     private readonly _themeCompartment;
     private readonly _listeners;
     private readonly _unsubscribeTheme;
-    private readonly _onWheelClaim;
+    private _scrollElement;
     constructor(value?: string, options?: CodeEditorOptions);
     protected applyOptions(options: CodeEditorOptions): this;
     getValue(): string;
@@ -38,8 +40,8 @@ declare class CodeEditor extends Component<CodeEditorOptions> {
     off(event: "readonlyedit", listener: () => void): this;
     protected emit(event: "change", payload: CodeEditorChange): void;
     protected emit(event: "readonlyedit"): void;
-    dispose(): void;
-    private claimScrollableWheel;
+    protected destructor(): void;
+    protected getScrollElement(): Handle | undefined;
     private mount;
     private mountFlashOverlay;
     private onThemeChange;

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

@@ -47,7 +47,7 @@ declare class MarkdownEditor extends Component<MarkdownEditorOptions> {
     protected emit(event: MarkdownEditorEvent, payload: MarkdownEditorChange): void;
     setContentEditable(contentEditable: boolean): this;
     getContentEditable(): boolean;
-    dispose(): void;
+    protected destructor(): void;
     private ensureEditor;
     private mountWysiwyg;
     private handleChange;

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

@@ -1,5 +1,6 @@
 import { AbstractBooleanInput, AbstractBooleanInputOptions } from "../../component/input/AbstractBooleanInput.js";
 import { Component } from "../../core/Component.js";
+import { Event } from "../../core/Event.js";
 export interface CheckboxOptions extends AbstractBooleanInputOptions {
     selected?: boolean;
     value?: boolean;
@@ -25,7 +26,7 @@ declare class Checkbox<TOptions extends CheckboxOptions = CheckboxOptions> exten
     isIndeterminate(): boolean;
     setIndeterminate(value: boolean): this;
     setAnimated(value: boolean): this;
-    on(event: "action", listener: Function): this;
+    on(event: "action", listener: Event.Listener): this;
     on(event: "change", listener: (value: boolean) => void): this;
     on(event: "binding", listener: () => void): this;
     off(event: "action" | "change" | "binding", listener: Function): this;

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

@@ -15,7 +15,7 @@ declare class Link extends Text<LinkOptions> {
     on(event: "action", listener: ClickListener): this;
     off(event: "action", listener: ClickListener): this;
     click(): this;
-    dispose(): void;
+    protected destructor(): void;
     private handleKeyDown;
 }
 declare const LinkCallable: import("../../core/Callable.js").Callable<typeof Link>;

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

@@ -1,5 +1,6 @@
 import { AbstractBooleanInput, AbstractBooleanInputOptions } from "../../component/input/AbstractBooleanInput.js";
 import { Component } from "../../core/Component.js";
+import { Event } from "../../core/Event.js";
 export interface RadioButtonOptions extends AbstractBooleanInputOptions {
     selected?: boolean;
     value?: boolean;
@@ -25,7 +26,7 @@ declare class RadioButton<TOptions extends RadioButtonOptions = RadioButtonOptio
     setRadioName(name: string): this;
     clearRadioName(): this;
     getRadioName(): string | null;
-    on(event: "action", listener: Function): this;
+    on(event: "action", listener: Event.Listener): this;
     on(event: "change", listener: (value: boolean) => void): this;
     on(event: "binding", listener: () => void): this;
     off(event: "action" | "change" | "binding", listener: Function): this;

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

@@ -1,4 +1,5 @@
 import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
+import { Event } from "../../core/Event.js";
 import type { AxisOrientation } from "../../primitive/Axis.js";
 export interface SliderOptions extends AbstractInputOptions {
     value?: number;
@@ -41,7 +42,7 @@ declare class Slider<TOptions extends SliderOptions = SliderOptions> extends Abs
     setOrientation(orientation: AxisOrientation): this;
     isShowTicks(): boolean;
     setShowTicks(value: boolean): this;
-    on(event: "action", listener: Function): this;
+    on(event: "action", listener: Event.Listener): this;
     on(event: "change", listener: (value: number) => void): this;
     on(event: "binding", listener: () => void): this;
     off(event: "action" | "change" | "binding", listener: Function): this;

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

@@ -23,13 +23,13 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     private _hasExplicitPreferredSize;
     private _fontSizeCSSVar;
     private _fontSizeCSSRule;
-    private readonly _unsubscribeTheme;
     private _lineHeightCSSVar;
     private _lineHeightCSSRule;
     private _measuredBaseline;
     private _measuredMinSize;
     private _autoMeasure;
     private _measurementDirty;
+    private _measuredGeneration;
     private _wordBreak;
     private _lineClamp;
     private _textOverflow;
@@ -39,9 +39,10 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     private readThemeLineHeightPx;
     getElement(createIfMissing?: boolean): Handle | undefined;
     private resolveBoundFontSizePx;
-    setPreferredSize(width: number, height: number): this;
+    setPreferredSize(size: Size): this;
     private setCalculatedSize;
     private calculateSize;
+    private needsMeasure;
     measure(): void;
     getBaseline(): number | null;
     private measureOptions;
@@ -75,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;
@@ -89,7 +90,6 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     setLineClamp(lines: number): this;
     clearLineClamp(): this;
     applyStyle(element: Handle): this;
-    dispose(): void;
     protected render(): Handle;
 }
 declare const TextCallable: import("../../core/Callable.js").Callable<typeof Text>;

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

@@ -1,5 +1,6 @@
 import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
 import type { Handle } from "../../core/DOM.js";
+import { Event } from "../../core/Event.js";
 export interface TextInputOptions extends AbstractInputOptions {
     type?: string;
     text?: string;
@@ -18,8 +19,8 @@ declare class TextInput<TOptions extends TextInputOptions = TextInputOptions> ex
     constructor(options?: TOptions, subclassDefaults?: Partial<TOptions>);
     protected onInput(): void;
     protected applyOptions(options: TOptions): this;
-    on(event: "action", listener: Function): this;
-    on(event: "keydown", listener: (e: KeyboardEvent) => void): this;
+    on(event: "action", listener: Event.Listener): this;
+    on(event: "keydown", listener: (e: KeyboardEvent) => Event.ListenerResult): this;
     on(event: "change", listener: (value: string) => void): this;
     on(event: "binding", listener: () => void): this;
     off(event: "action" | "keydown" | "change" | "binding", listener: Function): this;

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

@@ -2,6 +2,7 @@ import { AbstractInput, AbstractInputOptions } from "../../component/input/Abstr
 import { Component } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
 import { Panel } from "../../core/Panel.js";
+import { Event } from "../../core/Event.js";
 import { AbstractStore } from "../../data/AbstractStore.js";
 import { ModelRecord } from "../../data/ModelRecord.js";
 import { ListItemRenderer } from "../../component/list/ListItemRenderer.js";
@@ -103,7 +104,7 @@ declare abstract class AbstractSelectableList<TValue, TOptions extends AbstractS
     getSelectedRecord(): ModelRecord | undefined;
     getSelectedIndex(): number;
     setSelectedIndex(idx: number, fireEvent?: boolean): this;
-    on(event: "action", listener: Function): this;
+    on(event: "action", listener: Event.Listener): this;
     on(event: "change", listener: (value: TValue) => void): this;
     on(event: "binding", listener: () => void): this;
     on(event: "contextmenu", listener: (index: number, event: MouseEvent) => void): this;

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

@@ -11,7 +11,7 @@ declare class MenuBarButton extends Button<MenuBarButtonOptions> {
         height: number;
     };
     setActive(active: boolean): this;
-    dispose(): void;
+    protected destructor(): void;
 }
 declare const MenuBarButtonCallable: import("../../core/Callable.js").Callable<typeof MenuBarButton>;
 type MenuBarButtonCallable = MenuBarButton;

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

@@ -8,6 +8,7 @@ export declare class Column {
     private _unhideable;
     private _readOnly;
     private _headerGlyph;
+    private _headerText;
     private _group;
     private _groupColor;
     private _required;
@@ -19,6 +20,7 @@ export declare class Column {
     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

@@ -21,6 +21,7 @@ export interface ColumnConfig {
     cellValues?: (record: ModelRecord) => Array<ComboOption | string> | undefined;
     renderer?: () => CellRenderer<any>;
     headerGlyph?: string;
+    headerText?: string;
     group?: string;
     groupColor?: string;
     required?: boolean;

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

@@ -14,6 +14,7 @@ declare class TableHeader extends Component {
     private _scrollbarCover;
     constructor(model: AbstractModel, store: AbstractStore);
     getModel(): AbstractModel;
+    setStore(store: AbstractStore): this;
     setModel(model: AbstractModel): this;
     setHiddenColumns(hidden: Set<string>): this;
     setColumns(columns: Column[]): this;

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

@@ -10,6 +10,7 @@ import { ColumnSpec } from "../../component/table/ColumnConfig.js";
 import { Component, ComponentOptions } from "../../core/Component.js";
 import { ExportOptions } from "../../component/table/TableExporter.js";
 export type TableEvent = "selection" | "cellclick";
+export type TableDisplayMode = "normal" | "rotated";
 export interface TableOptions extends ComponentOptions {
 }
 declare class Table extends Component<TableOptions> {
@@ -32,6 +33,14 @@ declare class Table extends Component<TableOptions> {
     private _columnConfigs;
     private _exportMenuEnabled;
     private _listeners;
+    private _displayMode;
+    private _rotatedRecord;
+    private _rotatedStore;
+    private _rotatedColumns;
+    private _rotatedConfigs;
+    private _rotatedFieldByName;
+    private _sourceRefresh;
+    private _suppressSelectionForward;
     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;
@@ -39,6 +48,9 @@ declare class Table extends Component<TableOptions> {
     protected emit(event: "selection", records: ModelRecord[]): void;
     protected emit(event: "cellclick", detail: CellClickEvent): void;
     getColumns(): Column[];
+    private getSourceColumns;
+    getDisplayMode(): TableDisplayMode;
+    setDisplayMode(mode: TableDisplayMode): this;
     getStore(): AbstractStore;
     getModel(): import("../../data").AbstractModel;
     setStore(store: AbstractStore): this;
@@ -64,6 +76,14 @@ declare class Table extends Component<TableOptions> {
     private buildColumnConfigs;
     private initHiddenFromSpec;
     private getEffectiveHiddenSet;
+    private bindSourceStore;
+    private unbindSourceStore;
+    private onSourceStoreChange;
+    private ensureRotatedStore;
+    private rebuildRotatedStore;
+    private rotatedCellType;
+    private rotatedCellValues;
+    private bindView;
     private showColumnMenu;
     setExportMenuEnabled(enabled: boolean): this;
     exportCSV(options?: ExportOptions): void;

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

@@ -26,6 +26,7 @@ declare class HeaderCell extends DefaultCell {
     } | null;
     clearSortState(): this;
     setRequired(value: boolean): this;
+    setHeaderText(text: String): this;
     private _renderTitle;
     on(event: "commit", listener: (value: String | null) => void): this;
     on(event: "editend", listener: () => void): this;

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

@@ -1,5 +1,5 @@
 export { Table } from '../../component/table/Table.js';
-export type { TableOptions, TableEvent } from '../../component/table/Table.js';
+export type { TableOptions, TableEvent, TableDisplayMode } from '../../component/table/Table.js';
 export { TablePanel } from '../../component/table/TablePanel.js';
 export { TreeTable } from '../../component/table/TreeTable.js';
 export type { RowReparentDetail } from '../../component/table/TreeTable.js';

package/dist/lib/types/component/tree/Tree.d.ts

@@ -54,6 +54,7 @@ declare class Tree extends VirtualRowView<TreeRow, TreeOptions> {
     private _reflattenAndRender;
     private _onToggle;
     private _loadAndExpand;
+    private _notifySelectionChange;
     private _rangeSelect;
     private _selectAtIndex;
     private _extendSelectionTo;

package/dist/lib/types/core/AnimatedDropdown.d.ts

@@ -1,4 +1,5 @@
 import { Component, ComponentOptions } from "../core/Component.js";
+import { Animation } from "../core/Animation.js";
 import { DismissableLayer, LayerDismissMode } from "../core/LayerManager.js";
 import { type Rect, type Handle } from "../core/DOM.js";
 export interface AnimatedDropdownOptions extends ComponentOptions {
@@ -17,6 +18,8 @@ declare class AnimatedDropdown<TOptions extends AnimatedDropdownOptions = Animat
     private _open;
     private _closeHandler;
     private _anchorElement;
+    private _showAnimation;
+    private _hideAnimation;
     constructor(options?: AnimatedDropdownOptions, subclassDefaults?: Partial<AnimatedDropdownOptions>);
     protected applyOptions(options: TOptions): this;
     setAnimated(value: boolean): this;
@@ -33,6 +36,7 @@ declare class AnimatedDropdown<TOptions extends AnimatedDropdownOptions = Animat
     placeAnchored(rect: Rect): this;
     protected onShowComplete(): void;
     protected onHideComplete(): void;
+    protected destructor(): void;
     getLayerElement(): Handle | null;
     getDismissMode(): LayerDismissMode;
     requestClose(): void;
@@ -41,8 +45,8 @@ declare class AnimatedDropdown<TOptions extends AnimatedDropdownOptions = Animat
     setCloseHandler(handler: (() => void) | null): this;
     setAnchorElement(el: Handle | null): this;
 }
-export declare function fadeShow(component: Component, options?: FadeOptions): void;
-export declare function fadeHideAndDetach(component: Component, options?: FadeOptions): void;
+export declare function fadeShow(component: Component, options?: FadeOptions): Animation.CancelHandle;
+export declare function fadeHideAndDetach(component: Component, options?: FadeOptions): Animation.CancelHandle;
 declare const AnimatedDropdownCallable: import("../core/Callable.js").Callable<typeof AnimatedDropdown>;
 type AnimatedDropdownCallable<TOptions extends AnimatedDropdownOptions = AnimatedDropdownOptions> = AnimatedDropdown<TOptions>;
 export { AnimatedDropdown as _AnimatedDropdown, AnimatedDropdownCallable as AnimatedDropdown };

package/dist/lib/types/core/Animation.d.ts

@@ -1,4 +1,5 @@
 import { Component } from "../core/Component.js";
+import type { ComponentFactory } from "../core/Component.js";
 import type { Handle } from "../core/DOM.js";
 export declare namespace Animation {
     interface PlayConfig {
@@ -11,7 +12,7 @@ export declare namespace Animation {
         fallbackBufferMs?: number;
     }
     function isReducedMotion(): boolean;
-    function play(el: Handle, config: PlayConfig): void;
+    function play(el: Handle, config: PlayConfig): CancelHandle;
     interface AfterTransitionConfig {
         component: Component;
         property?: string;
@@ -19,7 +20,7 @@ export declare namespace Animation {
         fallbackBufferMs?: number;
         onComplete: () => void;
     }
-    function afterTransition(config: AfterTransitionConfig): void;
+    function afterTransition(config: AfterTransitionConfig): CancelHandle;
     interface TweenConfig<T extends {
         [K in keyof T]: number;
     }> {
@@ -30,18 +31,20 @@ export declare namespace Animation {
         onStep: (values: T) => void;
         onComplete?: () => void;
     }
-    interface TweenHandle {
+    interface CancelHandle {
         cancel(): void;
     }
     function tween<T extends {
         [K in keyof T]: number;
-    }>(config: TweenConfig<T>): TweenHandle;
+    }>(config: TweenConfig<T>): CancelHandle;
     interface MaterializeConfig {
         host: Component;
-        factory: () => Component;
+        factory: ComponentFactory;
         spinnerComponent: Component;
         fadeMs?: number;
         onReady?: (component: Component) => void;
+        onError?: (error: unknown) => void;
+        isStale?: () => boolean;
     }
-    function materialize(config: MaterializeConfig): void;
+    function materialize(config: MaterializeConfig): CancelHandle;
 }