@jimka/typescript-ui 0.4.1 → 0.6.0

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

@@ -0,0 +1,33 @@
+import { ComponentOptions } from "../../core/Component.js";
+import { MenuRow } from "../../component/container/MenuRow.js";
+export type RadioMenuRowEvent = "action";
+export interface RadioMenuRowOptions extends ComponentOptions {
+    text?: string;
+    checked?: boolean;
+    enabled?: boolean;
+    listeners?: {
+        action?: () => void;
+    };
+}
+declare class RadioMenuRow extends MenuRow<RadioMenuRowOptions> {
+    private _radio;
+    private _iconStart;
+    private _checkZone;
+    private readonly _onMouseOver;
+    private readonly _onMouseOut;
+    private readonly _onClick;
+    constructor(options?: RadioMenuRowOptions, subclassDefaults?: Partial<RadioMenuRowOptions>);
+    isChecked(): boolean;
+    setChecked(value: boolean): this;
+    isNavigable(): boolean;
+    isEnabled(): boolean;
+    activate(): void;
+    getContentWidth(): number;
+    setColumns(checkZone: number, iconStart: number, _titleColumn: number): void;
+    doLayout(): this;
+    on(event: "action", listener: () => void): this;
+    off(event: "action", listener: () => void): this;
+}
+declare const RadioMenuRowCallable: import("../../core/Callable.js").Callable<typeof RadioMenuRow>;
+type RadioMenuRowCallable = RadioMenuRow;
+export { RadioMenuRow as _RadioMenuRow, RadioMenuRowCallable as RadioMenuRow };

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

@@ -17,7 +17,7 @@ declare class ScrollStrip extends Panel<ScrollStripOptions> {
     private _clip;
     private _leadArrow;
     private _trailArrow;
-    constructor(options?: ScrollStripOptions);
+    constructor(options?: ScrollStripOptions, subclassDefaults?: Partial<ScrollStripOptions>);
     protected init(element?: Handle): this;
     protected applyOptions(options: ScrollStripOptions): this;
     private installBox;

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

@@ -1,7 +1,7 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
-import type { Handle } from "../../core/DOM.js";
 import type { AxisOrientation } from "../../primitive/Axis.js";
 export type ScrollbarEvent = "scroll";
+export declare const TRACK_WIDTH = 12;
 export type ScrollbarListener = (position: number) => void;
 export interface ScrollbarOptions extends ComponentOptions {
     arrowsEnabled?: boolean;
@@ -10,6 +10,7 @@ export interface ScrollbarOptions extends ComponentOptions {
         scroll?: ScrollbarListener;
     };
 }
+export declare function isScrollbarTarget(e: Event): boolean;
 declare class Scrollbar extends Component<ScrollbarOptions> {
     private _orientation;
     private _thumb;
@@ -20,12 +21,14 @@ declare class Scrollbar extends Component<ScrollbarOptions> {
     private _thumbPos;
     private _dragStartClient;
     private _dragStartScroll;
+    private _thumbHovered;
+    private _thumbDragging;
     private _listeners;
     private _arrowsEnabled;
     private _arrowStep;
     private _arrowStart;
     private _arrowEnd;
-    constructor(orientation?: AxisOrientation, options?: ScrollbarOptions);
+    constructor(orientation?: AxisOrientation, options?: ScrollbarOptions, subclassDefaults?: Partial<ScrollbarOptions>);
     private buildArrows;
     private _onArrowStartTick;
     private _onArrowEndTick;
@@ -33,7 +36,7 @@ declare class Scrollbar extends Component<ScrollbarOptions> {
     private disposeArrows;
     private _onThumbMouseOver;
     private _onThumbMouseOut;
-    protected init(element?: Handle): this;
+    private updateThumbFill;
     on(event: "scroll", listener: ScrollbarListener): this;
     off(event: ScrollbarEvent, listener: Function): this;
     protected emit(event: "scroll", position: number): void;

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

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

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

@@ -69,7 +69,7 @@ declare class TabBar extends Container<TabBarOptions> {
     private _dragShiftHeld;
     private _dragInsertIndex;
     private _springRaiseTimer;
-    constructor(options?: TabBarOptions);
+    constructor(options?: TabBarOptions, subclassDefaults?: Partial<TabBarOptions>);
     private dispatchBarOptions;
     setBarSurfaceColor(color: string): this;
     protected init(element?: Handle): this;
@@ -110,6 +110,8 @@ declare class TabBar extends Container<TabBarOptions> {
     isEntryCloseable(id: string): boolean;
     getEntryName(id: string): string;
     setEntryContentId(id: string, contentId: string): this;
+    setEntryBusy(id: string, busy: boolean): this;
+    isEntryBusy(id: string): boolean;
     getEntryButtonId(id: string): string;
     private entryById;
     private activeEntry;

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

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

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

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

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

@@ -5,7 +5,7 @@ export interface DiagramGroupNodeOptions extends PanelOptions {
 }
 declare class DiagramGroupNode extends Panel<DiagramGroupNodeOptions> {
     private _header;
-    constructor(options?: DiagramGroupNodeOptions);
+    constructor(options?: DiagramGroupNodeOptions, subclassDefaults?: Partial<DiagramGroupNodeOptions>);
     protected applyOptions(options: DiagramGroupNodeOptions): this;
     setLabel(value: string): this;
     getLabel(): string | null;

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

@@ -1,6 +1,7 @@
 import { Component, ComponentOptions } from "../../core/Component.js";
 import type { Handle } from "../../core/DOM.js";
 import { Size } from "../../primitive/Size.js";
+declare function mapFenceLangToEditorId(lang: string | undefined): string | null;
 export interface MarkdownLinkResolution {
     href: string;
     external: boolean;
@@ -9,25 +10,58 @@ export type MarkdownLinkResolver = (href: string) => MarkdownLinkResolution;
 export interface MarkdownOptions extends ComponentOptions {
     markdown?: string;
     linkResolver?: MarkdownLinkResolver;
+    maxMeasure?: string | number | null;
+    fontScale?: number;
 }
 declare class Markdown extends Component<MarkdownOptions> {
     private _contentHandles;
     private _measuredHeight;
     private readonly _unsubscribeTheme;
+    private _codeEditors;
+    private _pendingCodeUpgrades;
+    private _awaitingVisibilityKickoffs;
+    private _awaitingViewportKickoffs;
+    private _viewportWatchArmed;
+    private _viewportPassScheduled;
+    private _measureScheduled;
+    private readonly handleViewportPass;
+    private readonly handleScheduledMeasure;
+    private _renderGeneration;
+    private _maxMeasure;
     constructor(markdown?: string, options?: MarkdownOptions);
     protected applyOptions(options: MarkdownOptions): this;
     getMarkdown(): string;
     setLinkResolver(resolver: MarkdownLinkResolver): this;
     getLinkResolver(): MarkdownLinkResolver;
+    setMaxMeasure(value: string | number | null): this;
+    getMaxMeasure(): string | number | null;
+    setFontScale(value: number): this;
+    getFontScale(): number;
     setMarkdown(markdown: string): this;
     getMinSize(): Size | null;
     getPreferredSize(): Size | null;
     setWidth(width: number): this;
+    private onThemeChanged;
     protected destructor(): void;
     private measureContentHeight;
     protected render(): Handle;
     private create;
     private clearContent;
+    private applyCodeEditorUpgrade;
+    private handleCodeEditorHeightChange;
+    private flushPendingCodeUpgrades;
+    private resyncCodeEditorWidths;
+    private startCodeEditorImport;
+    private isBlockNearViewport;
+    private armViewportWatch;
+    private disarmViewportWatch;
+    private handleViewportChange;
+    private scheduleViewportPass;
+    private onViewportPass;
+    protected onEffectiveVisibilityChange(effective: boolean): void;
+    private loadCodeEditorUpgrade;
+    private scheduleContentMeasure;
+    private onScheduledMeasure;
     private appendBlockTokens;
     private appendBlockToken;
     private appendHeading;
@@ -44,6 +78,13 @@ declare class Markdown extends Component<MarkdownOptions> {
     private appendLink;
     private appendTextNode;
 }
+export interface MarkdownHeading {
+    id: string;
+    text: string;
+    depth: number;
+}
+export declare function extractMarkdownHeadings(source: string): MarkdownHeading[];
+export declare function findActiveHeading(scrollElement: Handle, headings: MarkdownHeading[]): string | null;
 declare const MarkdownCallable: import("../../core/Callable.js").Callable<typeof Markdown>;
 type MarkdownCallable = Markdown;
-export { Markdown as _Markdown, MarkdownCallable as Markdown, };
+export { Markdown as _Markdown, MarkdownCallable as Markdown, mapFenceLangToEditorId, };

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

@@ -0,0 +1,38 @@
+import { FloatingPanel, FloatingPanelOptions } from "../../component/container/FloatingPanel.js";
+import type { Size } from "../../primitive/Size.js";
+import type { MarkdownHeading } from "../../component/display/Markdown.js";
+export interface HeadingScrollSource {
+    on(event: "activeheadingchange", listener: (headingId: string | null) => void): unknown;
+    off(event: "activeheadingchange", listener: (headingId: string | null) => void): unknown;
+}
+export type MarkdownMinimapEvent = "select";
+export interface MarkdownMinimapOptions extends FloatingPanelOptions {
+    maxHeadingDepth?: number;
+    scrollSource?: HeadingScrollSource;
+    listeners?: {
+        select?: (headingId: string) => void;
+    };
+}
+declare class MarkdownMinimap extends FloatingPanel<MarkdownMinimapOptions> {
+    private readonly _tree;
+    private readonly _listeners;
+    private readonly _scrollSource;
+    private _nodesById;
+    private _nearestShown;
+    private readonly handleSelection;
+    private readonly handleActiveHeadingChange;
+    constructor(options?: MarkdownMinimapOptions, subclassDefaults?: Partial<MarkdownMinimapOptions>);
+    getPreferredSize(): Size | null;
+    protected applyOptions(options: MarkdownMinimapOptions): this;
+    getMaxHeadingDepth(): number;
+    setHeadings(headings: MarkdownHeading[]): this;
+    on(event: "select", listener: (headingId: string) => void): this;
+    off(event: "select", listener: (headingId: string) => void): this;
+    protected emit(event: "select", headingId: string): void;
+    private onTreeSelection;
+    private applyActiveHeading;
+    protected destructor(): void;
+}
+declare const MarkdownMinimapCallable: import("../../core/Callable.js").Callable<typeof MarkdownMinimap>;
+type MarkdownMinimapCallable = MarkdownMinimap;
+export { MarkdownMinimap as _MarkdownMinimap, MarkdownMinimapCallable as MarkdownMinimap, };

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

@@ -0,0 +1,60 @@
+import { Panel, PanelOptions } from "../../core/Panel.js";
+import { Markdown } from "../../component/display/Markdown.js";
+import type { MarkdownLinkResolver } from "../../component/display/Markdown.js";
+import type { HeadingScrollSource } from "../../component/display/MarkdownMinimap.js";
+export interface MarkdownViewerOptions extends PanelOptions {
+    markdown?: string;
+    linkResolver?: MarkdownLinkResolver;
+    maxHeadingDepth?: number;
+    showMinimap?: boolean;
+    showControls?: boolean;
+    listeners?: {
+        activeheadingchange?: (headingId: string | null) => void;
+    };
+}
+declare class MarkdownViewer extends Panel<MarkdownViewerOptions> implements HeadingScrollSource {
+    private readonly _markdown;
+    private readonly _minimap;
+    private _controls;
+    private _narrowerBtn;
+    private _widerBtn;
+    private _zoomOutBtn;
+    private _zoomInBtn;
+    private _resetBtn;
+    private _headings;
+    private _widthIndex;
+    private _zoomIndex;
+    private _lastActiveHeadingId;
+    private _pendingClickScrollTop;
+    private readonly _listeners;
+    private readonly handleNativeScroll;
+    private readonly handleMinimapSelect;
+    private readonly _onNarrower;
+    private readonly _onWider;
+    private readonly _onZoomOut;
+    private readonly _onZoomIn;
+    private readonly _onReset;
+    constructor(options?: MarkdownViewerOptions, subclassDefaults?: Partial<MarkdownViewerOptions>);
+    doLayout(): this;
+    protected applyOptions(options: MarkdownViewerOptions): this;
+    getMarkdown(): Markdown;
+    setMarkdown(markdown: string): this;
+    isMinimapVisible(): boolean;
+    setMinimapVisible(value: boolean): this;
+    isControlsVisible(): boolean;
+    setControlsVisible(value: boolean): this;
+    on(event: "activeheadingchange", listener: (headingId: string | null) => void): this;
+    off(event: "activeheadingchange", listener: (headingId: string | null) => void): this;
+    protected emit(event: "activeheadingchange", headingId: string | null): void;
+    private buildControls;
+    private makeControlButton;
+    private wireControlListeners;
+    private stepWidth;
+    private stepZoom;
+    private resetViewerProperties;
+    private onNativeScroll;
+    private scrollToHeading;
+}
+declare const MarkdownViewerCallable: import("../../core/Callable.js").Callable<typeof MarkdownViewer>;
+type MarkdownViewerCallable = MarkdownViewer;
+export { MarkdownViewer as _MarkdownViewer, MarkdownViewerCallable as MarkdownViewer, };

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

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

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

@@ -13,6 +13,12 @@ export { IconText } from '../../component/display/IconText.js';
 export type { IconTextOptions } from '../../component/display/IconText.js';
 export { Markdown } from '../../component/display/Markdown.js';
 export type { MarkdownOptions, MarkdownLinkResolution, MarkdownLinkResolver } from '../../component/display/Markdown.js';
+export { extractMarkdownHeadings, findActiveHeading } from '../../component/display/Markdown.js';
+export type { MarkdownHeading } from '../../component/display/Markdown.js';
+export { MarkdownMinimap } from '../../component/display/MarkdownMinimap.js';
+export type { MarkdownMinimapOptions, MarkdownMinimapEvent, HeadingScrollSource } from '../../component/display/MarkdownMinimap.js';
+export { MarkdownViewer } from '../../component/display/MarkdownViewer.js';
+export type { MarkdownViewerOptions } from '../../component/display/MarkdownViewer.js';
 export { IconLabel } from '../../component/display/IconLabel.js';
 export type { IconLabelOptions } from '../../component/display/IconLabel.js';
 export { ProgressBar } from '../../component/display/ProgressBar.js';

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

@@ -3,13 +3,18 @@ import type { Handle } from "../../core/DOM.js";
 export interface CodeEditorChange {
     value: string;
 }
+export interface CodeEditorHeightChange {
+    height: number;
+}
 export interface CodeEditorOptions extends ComponentOptions {
     value?: string;
     language?: string;
     readOnly?: boolean;
+    autoHeightMaxRows?: number;
     listeners?: {
         change?: (payload: CodeEditorChange) => void;
         readonlyedit?: () => void;
+        heightchange?: (payload: CodeEditorHeightChange) => void;
     };
 }
 declare class CodeEditor extends Component<CodeEditorOptions> {
@@ -22,6 +27,9 @@ declare class CodeEditor extends Component<CodeEditorOptions> {
     private readonly _listeners;
     private readonly _unsubscribeTheme;
     private _scrollElement;
+    private _contentElement;
+    private _lastSyncedShape;
+    private _lastHbarReserve;
     constructor(value?: string, options?: CodeEditorOptions, subclassDefaults?: Partial<CodeEditorOptions>);
     protected applyOptions(options: CodeEditorOptions): this;
     getValue(): string;
@@ -30,19 +38,24 @@ declare class CodeEditor extends Component<CodeEditorOptions> {
     setLanguage(id: string | null): this;
     getReadOnly(): boolean;
     setReadOnly(readOnly: boolean): this;
+    getAutoHeightMaxRows(): number | null;
     focus(preventScroll?: boolean): this;
     moveCursorToEnd(): this;
     format(): Promise<void>;
     private reindentFallback;
     on(event: "change", listener: (payload: CodeEditorChange) => void): this;
     on(event: "readonlyedit", listener: () => void): this;
+    on(event: "heightchange", listener: (payload: CodeEditorHeightChange) => void): this;
     off(event: "change", listener: (payload: CodeEditorChange) => void): this;
     off(event: "readonlyedit", listener: () => void): this;
+    off(event: "heightchange", listener: (payload: CodeEditorHeightChange) => void): this;
     protected emit(event: "change", payload: CodeEditorChange): void;
     protected emit(event: "readonlyedit"): void;
+    protected emit(event: "heightchange", payload: CodeEditorHeightChange): void;
     protected destructor(): void;
     protected getScrollElement(): Handle | undefined;
     private mount;
+    private syncAutoHeight;
     private mountFlashOverlay;
     private onThemeChange;
     private onEditIntent;

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

@@ -1,6 +1,6 @@
 import '../../component/editor/languages.js';
 export { CodeEditor } from '../../component/editor/CodeEditor.js';
-export type { CodeEditorOptions, CodeEditorChange } from '../../component/editor/CodeEditor.js';
+export type { CodeEditorOptions, CodeEditorChange, CodeEditorHeightChange } from '../../component/editor/CodeEditor.js';
 export { registerLanguage, getLanguage, listLanguages } from '../../component/editor/LanguageRegistry.js';
 export type { LanguageDefinition, Formatter } from '../../component/editor/LanguageRegistry.js';
 export { MarkdownEditor } from '../../component/editor/MarkdownEditor.js';

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

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

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

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

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

@@ -15,7 +15,7 @@ declare class Checkbox<TOptions extends CheckboxOptions = CheckboxOptions> exten
     private _box;
     private _check;
     private _dash;
-    constructor(options?: TOptions);
+    constructor(options?: CheckboxOptions, subclassDefaults?: Partial<CheckboxOptions>);
     protected applyOptions(options: TOptions): this;
     protected activate(): void;
     protected getInteractiveSurface(): Component;

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

@@ -15,7 +15,7 @@ export interface RadioButtonOptions extends AbstractBooleanInputOptions {
 declare class RadioButton<TOptions extends RadioButtonOptions = RadioButtonOptions> extends AbstractBooleanInput<TOptions> {
     private _ring;
     private _dot;
-    constructor(text?: string, options?: TOptions);
+    constructor(text?: string, options?: RadioButtonOptions, subclassDefaults?: Partial<RadioButtonOptions>);
     protected applyOptions(options: TOptions): this;
     protected activate(): void;
     protected getInteractiveSurface(): Component;

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

@@ -22,7 +22,7 @@ declare class Slider<TOptions extends SliderOptions = SliderOptions> extends Abs
     private _activeTrack;
     private _thumb;
     private _draggingPointer;
-    constructor(options?: TOptions);
+    constructor(options?: SliderOptions, subclassDefaults?: Partial<SliderOptions>);
     protected applyOptions(options: TOptions): this;
     getValue(): number;
     setValue(value: number): this;

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

@@ -32,8 +32,6 @@ declare class Text<TOptions extends TextOptions = TextOptions> extends Component
     private _measuredGeneration;
     private _wordBreak;
     private _lineClamp;
-    private _textOverflow;
-    private _truncate;
     constructor(text?: String, options?: NoInfer<TOptions>, subclassDefaults?: Partial<TOptions>);
     protected applyOptions(options: TOptions): this;
     private readThemeLineHeightPx;

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

@@ -6,7 +6,7 @@ export interface ToggleOptions extends AbstractBooleanInputOptions {
 declare class Toggle<TOptions extends ToggleOptions = ToggleOptions> extends AbstractBooleanInput<TOptions> {
     private _track;
     private _thumb;
-    constructor(options?: TOptions);
+    constructor(options?: ToggleOptions, subclassDefaults?: Partial<ToggleOptions>);
     protected applyOptions(options: TOptions): this;
     protected activate(): void;
     protected getInteractiveSurface(): Component;

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

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

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

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

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

@@ -10,7 +10,7 @@ declare class MenuBar extends Component {
     private _quickSwitchActive;
     private _keydownListening;
     private readonly _onKeyDown;
-    constructor(options?: MenuBarOptions);
+    constructor(options?: MenuBarOptions, subclassDefaults?: Partial<MenuBarOptions>);
     setMenus(menus: MenuConfig[]): this;
     protected destructor(): void;
     openMenu(index: number): this;

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

@@ -24,6 +24,7 @@ declare class ToolBar<TOptions extends ToolBarOptions = ToolBarOptions> extends
     constructor(options?: ToolBarOptions, subclassDefaults?: Partial<ToolBarOptions>);
     protected applyOptions(options: TOptions): this;
     setOrientation(value: AxisOrientation): this;
+    private applyOrientation;
     getOrientation(): AxisOrientation;
     setCompact(value: boolean): this;
     isCompact(): boolean;

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

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