@jimka/typescript-ui 0.1.0

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

@@ -0,0 +1,117 @@
+import { AnimatedDropdown, AnimatedDropdownOptions } from "../../core/AnimatedDropdown.js";
+import { Component } from "../../core/Component.js";
+import type { Handle } from "../../core/DOM.js";
+import { Text } from "../../component/input/Text.js";
+import { PickerColumn } from "../../component/input/PickerColumn.js";
+declare const MONTH_HEIGHT: number;
+declare const NAV_BTN_WIDTH: number;
+declare const HEADER_HEIGHT: number;
+declare const CELL_HEIGHT: number;
+declare const DAY_GRID_HEIGHT: number;
+declare const ROOT_GAP: number;
+declare const GLYPH_PX: number;
+declare const DAY_GRID_INDEX: number;
+declare const DEFAULT_YEAR_SPAN_BACK: number;
+declare const DEFAULT_YEAR_SPAN_FORWARD: number;
+declare const YEAR_TYPE_IDLE_MS: number;
+declare class PickerDayHeader extends Text {
+    constructor(text: string);
+}
+declare class PickerBlankCell extends Component {
+    constructor();
+}
+declare class PickerNavButton extends Component {
+    constructor(glyphName: string, onClick: () => void);
+    protected render(): Handle;
+}
+declare class PickerMonthLabel extends Text {
+    constructor(onClick: () => void);
+    protected render(): Handle;
+}
+declare class PickerDay extends Text {
+    private readonly _date;
+    private _selected;
+    private _disabled;
+    private readonly _onClick;
+    constructor(date: Date, onClick: (date: Date) => void);
+    getDate(): Date;
+    private onPointerDown;
+    private onClick;
+    setSelected(selected: boolean): this;
+    isSelected(): boolean;
+    setDisabled(disabled: boolean): this;
+    isDisabled(): boolean;
+    protected render(): Handle;
+}
+declare function dayStart(date: Date): Date;
+declare function dayEnd(date: Date): Date;
+export interface AbstractCalendarDropdownOptions extends AnimatedDropdownOptions {
+    minDate?: Date | null;
+    maxDate?: Date | null;
+}
+declare abstract class AbstractCalendarDropdown<TOptions extends AbstractCalendarDropdownOptions = AbstractCalendarDropdownOptions> extends AnimatedDropdown<TOptions> {
+    private readonly _onSelect;
+    protected _value: Date | null;
+    protected _monthAnchor: Date;
+    protected _yearScrollOpen: boolean;
+    protected _root: Component;
+    protected _headerRow: Component;
+    protected _prevButton: PickerNavButton;
+    protected _nextButton: PickerNavButton;
+    protected _monthLabel: PickerMonthLabel;
+    protected _weekdayRow: Component;
+    protected _dayGrid: Component;
+    protected _yearColumn: PickerColumn | null;
+    private _highlightedDayIdx;
+    private _highlightedYear;
+    private _yearTypeBuffer;
+    private _yearTypeTimer;
+    constructor(onSelect: (value: Date) => void, options?: TOptions, subclassDefaults?: Partial<TOptions>);
+    protected applyOptions(options: TOptions): this;
+    private onPointerDown;
+    showAt(anchorEl: Handle, selected: Date | null): this;
+    hideAnimated(): this;
+    protected computePanelHeight(): number;
+    protected rebuild(): void;
+    protected buildDayGrid(): void;
+    protected isValueOnDay(date: Date): boolean;
+    protected isDateInRange(date: Date): boolean;
+    protected hasAnyInRange(monthAnchor: Date): boolean;
+    protected onDateSelected(date: Date): void;
+    protected notifyValueChanged(): void;
+    private prevMonth;
+    private nextMonth;
+    private updateMonthLabel;
+    private toggleYearScroller;
+    protected openYearScroller(): void;
+    protected closeYearScroller(): void;
+    private buildYearScroller;
+    private refreshYearSelection;
+    private onYearSelected;
+    private resetYearTypeBuffer;
+    handleKey(e: KeyboardEvent): boolean;
+    private handleKeyInDayGrid;
+    private getDayGridChildren;
+    private moveHighlightedDay;
+    private setHighlightedDay;
+    private matchesSelection;
+    private highlightFirstDayOfMonth;
+    private highlightLastDayOfMonth;
+    private commitHighlightedDay;
+    private handleKeyInYearScroller;
+    private getYearCells;
+    private moveHighlightedYear;
+    private findHighlightedYearPos;
+    private applyYearHighlight;
+    private highlightFirstYear;
+    private highlightLastYear;
+    private commitHighlightedYear;
+    private appendYearDigit;
+    protected abstract getPanelWidth(): number;
+    protected getExtraInnerHeight(): number;
+    protected buildExtraRootChildren(): void;
+    protected rebuildExtraRowsAfterValueChange(): void;
+    protected applyDateSelection(date: Date): void;
+    protected applyYearSelection(_year: number): void;
+}
+export { AbstractCalendarDropdown, PickerDay, PickerBlankCell, PickerNavButton, PickerMonthLabel, PickerDayHeader, dayStart, dayEnd, MONTH_HEIGHT, NAV_BTN_WIDTH, HEADER_HEIGHT, CELL_HEIGHT, DAY_GRID_HEIGHT, ROOT_GAP, GLYPH_PX, DAY_GRID_INDEX, DEFAULT_YEAR_SPAN_BACK, DEFAULT_YEAR_SPAN_FORWARD, YEAR_TYPE_IDLE_MS, };

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

@@ -0,0 +1,31 @@
+import { Component, ComponentOptions } from "../../core/Component.js";
+import { Bindable } from "../../core/Bindable.js";
+export type AbstractInputEvent = "change" | "binding";
+export interface AbstractInputOptions extends ComponentOptions {
+    enabled?: boolean;
+    readOnly?: boolean;
+    listeners?: {
+        change?: (value: any) => void;
+        binding?: () => void;
+    };
+}
+declare abstract class AbstractInput<TValue, TOptions extends AbstractInputOptions = AbstractInputOptions> extends Component<TOptions> implements Bindable<TValue> {
+    private _listeners;
+    constructor(options?: TOptions, subclassDefaults?: Partial<TOptions>);
+    abstract getValue(): TValue;
+    abstract setValue(value: TValue): this;
+    isEnabled(): boolean;
+    setEnabled(value: boolean): this;
+    isReadOnly(): boolean;
+    setReadOnly(value: boolean): this;
+    on(event: "change", listener: (value: TValue) => void): this;
+    on(event: "binding", listener: () => void): this;
+    off(event: AbstractInputEvent, listener: Function): this;
+    protected emit(event: "change", value: TValue): void;
+    protected emit(event: "binding"): void;
+    protected notifyChange(value: TValue): void;
+    protected abstract applyEnabled(value: boolean): void;
+    protected abstract applyReadOnly(value: boolean): void;
+    protected applyOptions(options: TOptions): this;
+}
+export { AbstractInput };

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

@@ -0,0 +1,45 @@
+import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
+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";
+export interface AbstractPickerFieldOptions extends AbstractInputOptions {
+    dropdownAnimated?: boolean;
+}
+declare abstract class AbstractPickerField<TValue, TDropdown extends AnimatedDropdown & {
+    showAt(anchorEl: Handle, value: TValue | null): unknown;
+}, TOptions extends AbstractPickerFieldOptions = AbstractPickerFieldOptions> extends AbstractInput<TValue | null, TOptions> {
+    protected _input: PickerInput;
+    protected _button: PickerButton;
+    protected _dropdown: TDropdown | null;
+    protected _value: TValue | null;
+    protected _invalid: boolean;
+    protected _showSeconds: boolean;
+    constructor(options?: TOptions);
+    protected abstract formatValue(value: TValue): string;
+    protected abstract parseRaw(raw: string): TValue | null;
+    protected abstract createDropdown(): TDropdown;
+    protected abstract onDropdownSelected(value: TValue): void;
+    protected abstract getPreferredWidth(): number;
+    protected getDefaultBorder(): string;
+    protected applyOptions(options: TOptions): this;
+    doLayout(): this;
+    protected updateHeight(): void;
+    setValue(value: TValue | null): this;
+    getValue(): TValue | null;
+    getBaseline(): number | null;
+    setDropdownAnimated(value: boolean): this;
+    isDropdownAnimated(): boolean;
+    protected applyEnabled(value: boolean): void;
+    protected applyReadOnly(value: boolean): void;
+    protected onButtonClick(): void;
+    protected onButtonPointerDown(e: PointerEvent): void;
+    protected onInput(): void;
+    protected onBlur(): void;
+    protected setInvalid(invalid: boolean): void;
+    protected onKeyDown(e: KeyboardEvent): void;
+    protected ensureDropdown(): TDropdown;
+    protected openDropdown(): void;
+    protected closeDropdown(): void;
+}
+export { AbstractPickerField };

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

@@ -0,0 +1,20 @@
+import { AnimatedDropdown, AnimatedDropdownOptions } from "../../core/AnimatedDropdown.js";
+import type { Handle } from "../../core/DOM.js";
+import { List } from "../../component/list/List.js";
+interface AutoCompleteDropdownOptions extends AnimatedDropdownOptions {
+}
+declare class AutoCompleteDropdown extends AnimatedDropdown<AutoCompleteDropdownOptions> {
+    private readonly _list;
+    private readonly _onSelect;
+    private readonly _onHide;
+    constructor(onSelect: (value: string) => void, onHide: () => void, options?: AutoCompleteDropdownOptions);
+    show(anchorEl: Handle, suggestions: string[]): this;
+    hide(): this;
+    handleKey(e: KeyboardEvent): boolean;
+    getFocusedRowId(): string | null;
+    getList(): List;
+    protected onHideComplete(): void;
+}
+declare const AutoCompleteDropdownCallable: import("../../core/Callable.js").Callable<typeof AutoCompleteDropdown>;
+type AutoCompleteDropdownCallable = AutoCompleteDropdown;
+export { AutoCompleteDropdown as _AutoCompleteDropdown, AutoCompleteDropdownCallable as AutoCompleteDropdown };

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

@@ -0,0 +1,54 @@
+import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
+import { AbstractStore } from "../../data/AbstractStore.js";
+export type AutoCompleteMatchMode = 'contains' | 'startsWith' | 'containsCaseSensitive' | 'startsWithCaseSensitive';
+export interface AutoCompleteFieldOptions extends AbstractInputOptions {
+    suggestions?: string[];
+    store?: AbstractStore;
+    displayField?: string;
+    minChars?: number;
+    debounceMs?: number;
+    maxSuggestions?: number;
+    placeholder?: string;
+    matchMode?: AutoCompleteMatchMode;
+}
+export type AutoCompleteFieldConfig = AutoCompleteFieldOptions;
+export type AutoCompleteFieldEvent = "select";
+declare class AutoCompleteField extends AbstractInput<string, AutoCompleteFieldOptions> {
+    private _textField;
+    private _dropdown;
+    private _debounceTimer;
+    private _selectBag;
+    constructor(options?: AutoCompleteFieldOptions);
+    protected applyOptions(options: AutoCompleteFieldOptions): this;
+    private syncSizeFromTextField;
+    getBaseline(): number | null;
+    doLayout(): this;
+    setValue(value: string): this;
+    getValue(): string;
+    protected applyEnabled(value: boolean): void;
+    protected applyReadOnly(value: boolean): void;
+    setSuggestions(suggestions: string[]): this;
+    setStore(store: AbstractStore, displayField: string): this;
+    setMinChars(n: number): this;
+    setDebounceMs(ms: number): this;
+    setMaxSuggestions(n: number): this;
+    setMatchMode(mode: AutoCompleteMatchMode): this;
+    setPlaceholder(placeholder: string): this;
+    on(event: "select", listener: (value: string) => void): this;
+    on(event: "change", listener: (value: string) => void): this;
+    on(event: "binding", listener: () => void): this;
+    off(event: "select" | "change" | "binding", listener: Function): this;
+    addSelectListener(fn: (value: string) => void): void;
+    private onInput;
+    private onKeyDown;
+    private onBlur;
+    private matches;
+    private querySuggestions;
+    private showSuggestions;
+    private onDropdownHidden;
+    private updateActiveDescendant;
+    private onSuggestionSelected;
+}
+declare const AutoCompleteFieldCallable: import("../../core/Callable.js").Callable<typeof AutoCompleteField>;
+type AutoCompleteFieldCallable = AutoCompleteField;
+export { AutoCompleteField as _AutoCompleteField, AutoCompleteFieldCallable as AutoCompleteField };

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

@@ -0,0 +1,36 @@
+import { AbstractBooleanInput, AbstractBooleanInputOptions } from "../../component/input/AbstractBooleanInput.js";
+import { Component } from "../../core/Component.js";
+export interface CheckboxOptions extends AbstractBooleanInputOptions {
+    selected?: boolean;
+    value?: boolean;
+    indeterminate?: boolean;
+    listeners?: {
+        action?: () => void;
+        change?: (value: boolean) => void;
+        binding?: () => void;
+    };
+}
+declare class Checkbox<TOptions extends CheckboxOptions = CheckboxOptions> extends AbstractBooleanInput<TOptions> {
+    private _box;
+    private _check;
+    private _dash;
+    constructor(options?: TOptions);
+    protected applyOptions(options: TOptions): this;
+    protected activate(): void;
+    protected getInteractiveSurface(): Component;
+    isSelected(): boolean;
+    setSelected(value: boolean): this;
+    getValue(): boolean;
+    setValue(value: boolean): this;
+    isIndeterminate(): boolean;
+    setIndeterminate(value: boolean): this;
+    setAnimated(value: boolean): this;
+    on(event: "action", listener: Function): this;
+    on(event: "change", listener: (value: boolean) => void): this;
+    on(event: "binding", listener: () => void): this;
+    off(event: "action" | "change" | "binding", listener: Function): this;
+    private applySelected;
+}
+declare const CheckboxCallable: import("../../core/Callable.js").Callable<typeof Checkbox>;
+type CheckboxCallable<TOptions extends CheckboxOptions = CheckboxOptions> = Checkbox<TOptions>;
+export { Checkbox as _Checkbox, CheckboxCallable as Checkbox };

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

@@ -0,0 +1,86 @@
+import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
+import type { Handle } from "../../core/DOM.js";
+import { AnimatedDropdown, AnimatedDropdownOptions } from "../../core/AnimatedDropdown.js";
+import { AbstractStore } from "../../data/AbstractStore.js";
+import { ModelRecord } from "../../data/ModelRecord.js";
+import { SelectableListItem, SelectableListItemSpec } from "../../component/list/AbstractSelectableList.js";
+import { ListItemRenderer } from "../../component/list/ListItemRenderer.js";
+import { List } from "../../component/list/List.js";
+export interface ComboBoxOptions extends AbstractInputOptions {
+    items?: SelectableListItemSpec | Array<SelectableListItemSpec>;
+    store?: AbstractStore;
+    displayField?: string;
+    valueField?: string;
+    glyphField?: string;
+    rendererFactory?: () => ListItemRenderer;
+    selectedIndex?: number;
+    value?: string;
+    selectedItem?: string;
+    dropdownAnimated?: boolean;
+    dropdownMinWidth?: number;
+    listeners?: {
+        action?: () => void;
+        change?: (value: string) => void;
+        binding?: () => void;
+    };
+}
+declare class ComboBoxDropdown extends AnimatedDropdown<AnimatedDropdownOptions> {
+    private readonly _list;
+    private _minWidth;
+    constructor(onSelect: (index: number) => void);
+    handleKey(e: KeyboardEvent): boolean;
+    showAt(anchorEl: Handle, items: Array<SelectableListItem>, selectedIndex: number): this;
+    setMinWidth(px: number): this;
+    getMinWidth(): number;
+    getList(): List;
+    private measureWidestLabel;
+}
+declare class ComboBox<TOptions extends ComboBoxOptions = ComboBoxOptions> extends AbstractInput<string, TOptions> {
+    private readonly _dropdown;
+    private _label;
+    private _caret;
+    private _pendingValue;
+    private _boundStore;
+    private readonly _onStoreRefresh;
+    constructor(options?: ComboBoxOptions, subclassDefaults?: Partial<ComboBoxOptions>);
+    protected applyOptions(options: TOptions): this;
+    protected updateHeight(): void;
+    doLayout(): this;
+    getBaseline(): number | null;
+    openDropdown(): this;
+    private toggleDropdown;
+    private setCaretOpen;
+    private closeDropdown;
+    private onKeyDown;
+    private onRowSelected;
+    private computeSelectedItem;
+    private refreshLabel;
+    on(event: "action", listener: Function): this;
+    on(event: "change", listener: (value: string) => void): this;
+    on(event: "binding", listener: () => void): this;
+    off(event: "action" | "change" | "binding", listener: Function): this;
+    setValue(value: string): this;
+    getValue(): string;
+    getSelectedIndex(): number;
+    setSelectedIndex(idx: number, fireEvent?: boolean): this;
+    getItems(): Array<SelectableListItem>;
+    setItems(items: SelectableListItemSpec | Array<SelectableListItemSpec>): this;
+    addItem(item: SelectableListItemSpec): this;
+    setStore(store: AbstractStore, displayField: string, valueField?: string, glyphField?: string): this;
+    getStore(): AbstractStore | null;
+    setRendererFactory(factory: () => ListItemRenderer): this;
+    getRendererFactory(): () => ListItemRenderer;
+    getSelectedRecord(): ModelRecord | undefined;
+    private reapplyPendingValue;
+    private autoSelectFirstIfEmpty;
+    private onStoreRefresh;
+    setDropdownAnimated(value: boolean): this;
+    isDropdownAnimated(): boolean;
+    setDropdownMinWidth(px: number): this;
+    getDropdownMinWidth(): number;
+    protected applyEnabled(value: boolean): void;
+    protected applyReadOnly(value: boolean): void;
+}
+declare const ComboBoxCallable: import("../../core/Callable.js").Callable<typeof ComboBox>;
+type ComboBoxCallable = ComboBox;
+export { ComboBox as _ComboBox, ComboBoxDropdown as _ComboBoxDropdown, ComboBoxCallable as ComboBox };

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

@@ -0,0 +1,19 @@
+import { AbstractPickerField, AbstractPickerFieldOptions } from "../../component/input/AbstractPickerField.js";
+import { DatePickerDropdown } from "../../component/input/DatePickerDropdown.js";
+export interface DateFieldOptions extends AbstractPickerFieldOptions {
+    value?: Date | null;
+    minDate?: Date | null;
+    maxDate?: Date | null;
+}
+declare class DateField extends AbstractPickerField<Date, DatePickerDropdown, DateFieldOptions> {
+    constructor(options?: DateFieldOptions);
+    protected applyOptions(options: DateFieldOptions): this;
+    protected formatValue(date: Date): string;
+    protected parseRaw(raw: string): Date | null;
+    protected createDropdown(): DatePickerDropdown;
+    protected onDropdownSelected(date: Date): void;
+    protected getPreferredWidth(): number;
+}
+declare const DateFieldCallable: import("../../core/Callable.js").Callable<typeof DateField>;
+type DateFieldCallable = DateField;
+export { DateField as _DateField, DateFieldCallable as DateField };

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

@@ -0,0 +1,11 @@
+import { AbstractCalendarDropdown, AbstractCalendarDropdownOptions } from "../../component/input/AbstractCalendarDropdown.js";
+export interface DatePickerDropdownOptions extends AbstractCalendarDropdownOptions {
+}
+declare class DatePickerDropdown extends AbstractCalendarDropdown<DatePickerDropdownOptions> {
+    constructor(onSelect: (value: Date) => void, options?: DatePickerDropdownOptions);
+    protected getPanelWidth(): number;
+    protected onDateSelected(date: Date): void;
+}
+declare const DatePickerDropdownCallable: import("../../core/Callable.js").Callable<typeof DatePickerDropdown>;
+type DatePickerDropdownCallable = DatePickerDropdown;
+export { DatePickerDropdown as _DatePickerDropdown, DatePickerDropdownCallable as DatePickerDropdown };

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

@@ -0,0 +1,20 @@
+import { AbstractPickerField, AbstractPickerFieldOptions } from "../../component/input/AbstractPickerField.js";
+import { DateTimePickerDropdown } from "../../component/input/DateTimePickerDropdown.js";
+export interface DateTimeFieldOptions extends AbstractPickerFieldOptions {
+    value?: Date | null;
+    showSeconds?: boolean;
+    minDate?: Date | null;
+    maxDate?: Date | null;
+}
+declare class DateTimeField extends AbstractPickerField<Date, DateTimePickerDropdown, DateTimeFieldOptions> {
+    constructor(options?: DateTimeFieldOptions);
+    protected applyOptions(options: DateTimeFieldOptions): this;
+    protected formatValue(date: Date): string;
+    protected parseRaw(raw: string): Date | null;
+    protected createDropdown(): DateTimePickerDropdown;
+    protected onDropdownSelected(date: Date): void;
+    protected getPreferredWidth(): number;
+}
+declare const DateTimeFieldCallable: import("../../core/Callable.js").Callable<typeof DateTimeField>;
+type DateTimeFieldCallable = DateTimeField;
+export { DateTimeField as _DateTimeField, DateTimeFieldCallable as DateTimeField };

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

@@ -0,0 +1,22 @@
+import { AbstractCalendarDropdown, AbstractCalendarDropdownOptions } from "../../component/input/AbstractCalendarDropdown.js";
+import { TimeField } from "../../component/input/TimeField.js";
+export interface DateTimePickerDropdownOptions extends AbstractCalendarDropdownOptions {
+    showSeconds?: boolean;
+}
+declare class DateTimePickerDropdown extends AbstractCalendarDropdown<DateTimePickerDropdownOptions> {
+    protected _timeField: TimeField;
+    constructor(onSelect: (value: Date) => void, options?: DateTimePickerDropdownOptions);
+    protected applyOptions(options: DateTimePickerDropdownOptions): this;
+    protected buildExtraRootChildren(): void;
+    protected rebuildExtraRowsAfterValueChange(): void;
+    private onTimeFieldChange;
+    protected applyDateSelection(date: Date): void;
+    protected applyYearSelection(year: number): void;
+    protected getPanelWidth(): number;
+    protected getExtraInnerHeight(): number;
+    private isShowingSeconds;
+    private todayMidnight;
+}
+declare const DateTimePickerDropdownCallable: import("../../core/Callable.js").Callable<typeof DateTimePickerDropdown>;
+type DateTimePickerDropdownCallable = DateTimePickerDropdown;
+export { DateTimePickerDropdown as _DateTimePickerDropdown, DateTimePickerDropdownCallable as DateTimePickerDropdown };

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

@@ -0,0 +1,26 @@
+import { AbstractInput } from "../../component/input/AbstractInput.js";
+import { FileFieldOptions } from "../../component/input/FileField.js";
+export interface FileDropZoneOptions extends FileFieldOptions {
+    promptText?: string;
+}
+declare class FileDropZone<TOptions extends FileDropZoneOptions = FileDropZoneOptions> extends AbstractInput<File[], TOptions> {
+    private _prompt;
+    private _field;
+    private _dragDepth;
+    constructor(options?: FileDropZoneOptions);
+    protected applyOptions(options: TOptions): this;
+    private fieldOptions;
+    private setActive;
+    private onDragEnter;
+    private onDragOver;
+    private onDragLeave;
+    private onDrop;
+    getValue(): File[];
+    setValue(value: File[]): this;
+    clearValue(): this;
+    protected applyEnabled(value: boolean): void;
+    protected applyReadOnly(value: boolean): void;
+}
+declare const FileDropZoneCallable: import("../../core/Callable.js").Callable<typeof FileDropZone>;
+type FileDropZoneCallable<TOptions extends FileDropZoneOptions = FileDropZoneOptions> = FileDropZone<TOptions>;
+export { FileDropZone as _FileDropZone, FileDropZoneCallable as FileDropZone, };

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

@@ -0,0 +1,31 @@
+import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
+export interface FileFieldOptions extends AbstractInputOptions {
+    multiple?: boolean;
+    accept?: string;
+    buttonText?: string;
+}
+declare class FileField<TOptions extends FileFieldOptions = FileFieldOptions> extends AbstractInput<File[], TOptions> {
+    private _button;
+    private _label;
+    private _input;
+    private _droppedFiles;
+    constructor(options?: FileFieldOptions);
+    protected applyOptions(options: TOptions): this;
+    private defaultButtonText;
+    private openPicker;
+    private onNativeChange;
+    acceptDroppedFiles(files: FileList): void;
+    getValue(): File[];
+    setValue(value: File[]): this;
+    clearValue(): this;
+    isMultiple(): boolean;
+    setMultiple(value: boolean): this;
+    getAccept(): string | null;
+    setAccept(value: string): this;
+    private updateLabel;
+    protected applyEnabled(value: boolean): void;
+    protected applyReadOnly(value: boolean): void;
+}
+declare const FileFieldCallable: import("../../core/Callable.js").Callable<typeof FileField>;
+type FileFieldCallable<TOptions extends FileFieldOptions = FileFieldOptions> = FileField<TOptions>;
+export { FileField as _FileField, FileFieldCallable as FileField, };

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

@@ -0,0 +1,14 @@
+import { Text, TextOptions } from "../../component/input/Text.js";
+import type { Handle } from "../../core/DOM.js";
+export interface LabelOptions extends TextOptions {
+}
+declare class Label extends Text<LabelOptions> {
+    private _forId;
+    constructor(text: string, forId: string, options?: LabelOptions);
+    getForId(): string;
+    setForId(id: string): this;
+    protected render(): Handle;
+}
+declare const LabelCallable: import("../../core/Callable.js").Callable<typeof Label>;
+type LabelCallable = Label;
+export { Label as _Label, LabelCallable as Label };

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

@@ -0,0 +1,23 @@
+import { Text, TextOptions } from "../../component/input/Text.js";
+import type { ClickListener } from "../../component/button/Button.js";
+export type LinkEvent = "action";
+export interface LinkOptions extends TextOptions {
+    interactive?: boolean;
+    listeners?: {
+        action?: ClickListener;
+    };
+}
+declare class Link extends Text<LinkOptions> {
+    constructor(text?: String, options?: LinkOptions);
+    protected applyOptions(options: LinkOptions): this;
+    isInteractive(): boolean;
+    setInteractive(value: boolean): this;
+    on(event: "action", listener: ClickListener): this;
+    off(event: "action", listener: ClickListener): this;
+    click(): this;
+    dispose(): void;
+    private handleKeyDown;
+}
+declare const LinkCallable: import("../../core/Callable.js").Callable<typeof Link>;
+type LinkCallable = Link;
+export { Link as _Link, LinkCallable as Link };

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

@@ -0,0 +1,40 @@
+import { AbstractInput, AbstractInputOptions } from "../../component/input/AbstractInput.js";
+export interface NumberSpinnerOptions extends AbstractInputOptions {
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number | null;
+}
+declare class NumberSpinner extends AbstractInput<number, NumberSpinnerOptions> {
+    private _input;
+    private _upBtn;
+    private _downBtn;
+    private _btnBox;
+    constructor(options?: NumberSpinnerOptions);
+    protected applyOptions(options: NumberSpinnerOptions): this;
+    getBaseline(): number | null;
+    private updateHeight;
+    getValue(): number;
+    setValue(n: number): this;
+    getMin(): number;
+    setMin(n: number): this;
+    getMax(): number;
+    setMax(n: number): this;
+    getStep(): number;
+    setStep(n: number): this;
+    getPrecision(): number | null;
+    setPrecision(decimals: number | null): this;
+    protected applyEnabled(enabled: boolean): void;
+    protected applyReadOnly(value: boolean): void;
+    private applyValue;
+    private _setValueSilent;
+    private normalize;
+    private onBlur;
+    private onKeyDown;
+    private formatValue;
+    private derivePrecision;
+}
+declare const NumberSpinnerCallable: import("../../core/Callable.js").Callable<typeof NumberSpinner>;
+type NumberSpinnerCallable = NumberSpinner;
+export { NumberSpinner as _NumberSpinner, NumberSpinnerCallable as NumberSpinner };

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

@@ -0,0 +1,11 @@
+import { TextInput, TextInputOptions } from "../../component/input/TextInput.js";
+export interface PasswordFieldOptions extends TextInputOptions {
+    newPassword?: boolean;
+}
+declare class PasswordField extends TextInput<PasswordFieldOptions> {
+    constructor(options?: PasswordFieldOptions);
+    private updateHeight;
+}
+declare const PasswordFieldCallable: import("../../core/Callable.js").Callable<typeof PasswordField>;
+type PasswordFieldCallable = PasswordField;
+export { PasswordField as _PasswordField, PasswordFieldCallable as PasswordField };

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

@@ -0,0 +1,7 @@
+import { Button } from "../../component/button/Button.js";
+declare class PickerButton extends Button {
+    constructor();
+}
+declare const PickerButtonCallable: import("../../core/Callable.js").Callable<typeof PickerButton>;
+type PickerButtonCallable = PickerButton;
+export { PickerButton as _PickerButton, PickerButtonCallable as PickerButton, };