optikos 0.0.0-stage → 0.2.0

package/dist/types/components/data/grid/grid.d.ts

@@ -0,0 +1,177 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import { Store } from '../../../data/store.js';
+import type { Model } from '../../../data/model.js';
+import { type Column } from '../../../data/column.js';
+export interface GridConfig<T extends Record<string, any> = any> extends ComponentConfig {
+    store?: Store<T>;
+    /** Used when no `store` is given. */
+    data?: Partial<T>[];
+    columns: Column<T>[];
+    selection?: 'none' | 'single' | 'multi';
+    /** Row height in px. Default: measured from the `--op-grid-row-height` / `--op-row-height` tokens. */
+    rowHeight?: number;
+    /** Adds a Pagination bar bound to the store (give the store a `pageSize`, or set it here). */
+    paging?: boolean;
+    pageSize?: number;
+    emptyText?: string;
+    striped?: boolean;
+    /** Adds a leading checkbox column with a select-all in the header. Implies multi selection; a row click toggles. */
+    checkboxSelection?: boolean;
+    /** Keep selected records when the page or the filters change. Default false. */
+    keepSelection?: boolean;
+    /** Buttons shown in a bar above the header while records are selected. */
+    bulkActions?: GridAction<T>[];
+    /** Actions at the end of every row (see `rowActionsMode`). */
+    rowActions?: GridRowAction<T>[];
+    /** Optional features (`cellEditing()`...). See `GridPlugin`. */
+    plugins?: GridPlugin<T>[];
+    /** `'menu'` (default): one "⋯" button opens a menu. `'visible'`: every action is an icon button, always shown (dimmed until the row is hovered, active or selected). */
+    rowActionsMode?: 'menu' | 'visible';
+    /** A "Columns" button in the bar: toggle columns on and off, with search. */
+    columnMenu?: boolean;
+    /** Drag a header to a new place (or Alt+←/→ on a focused header). `column-move` and `columns-change` fire; ViewManager saves the order. */
+    reorderableColumns?: boolean;
+    /** A handle on each header's edge: drag to resize (double-click resets), Alt+Shift+←/→ on a focused header. Widths are part of `getColumnState`. */
+    resizableColumns?: boolean;
+    /** Show the group labels (`Column.group`) as a band over the header. Default true when any column has a group. */
+    groupHeaders?: boolean;
+}
+/** Extends a Grid without growing its base: `init` runs once the grid is rendered and may return a cleanup. */
+export interface GridPlugin<T extends Record<string, any> = any> {
+    init(grid: Grid<T>): void | (() => void);
+    destroy?(): void;
+}
+/** What `cellAt` finds under a DOM node: the row index, its record, the column and the cell element. */
+export interface GridCell<T extends Record<string, any> = any> {
+    index: number;
+    record: Model<T>;
+    column: Column<T>;
+    el: HTMLElement;
+}
+export interface GridAction<T extends Record<string, any> = any> {
+    text: string;
+    icon?: string;
+    variant?: 'default' | 'danger';
+    handler: (records: Model<T>[], grid: Grid<T>) => void;
+}
+export interface GridRowAction<T extends Record<string, any> = any> {
+    text: string;
+    icon?: string;
+    variant?: 'default' | 'danger';
+    /** Disabled for the records where this returns true. */
+    disabled?: (record: Model<T>) => boolean;
+    handler: (record: Model<T>, grid: Grid<T>) => void;
+}
+export interface ColumnState {
+    field: string;
+    hidden: boolean;
+    width?: number;
+}
+/** Data grid with a virtualized body: only the visible rows (plus a small overscan) exist in the DOM. */
+/** `T` is the record shape; `new Grid({ store })` infers it from a typed `Store<T>`. */
+export declare class Grid<T extends Record<string, any> = any> extends Component<GridConfig<T>> {
+    protected baseCls: string;
+    private store;
+    private offStore?;
+    private headEl;
+    private headRow;
+    private viewport;
+    private emptyEl;
+    /** The focusable `role=grid` part (header + rows); the root also holds the bulk bar and the pager, which a grid may not contain. */
+    private table;
+    private pager?;
+    private v;
+    private selected;
+    private active;
+    private anchor;
+    private justDragged;
+    private cv;
+    private selAll?;
+    private barEl?;
+    private bulkEl?;
+    private bulkCount?;
+    private bulkBtns;
+    private selectAllBtn?;
+    private rowMenu?;
+    private colDd?;
+    private colList?;
+    private colSearch?;
+    private colChips?;
+    private colGroup;
+    private cols;
+    private userCols;
+    private visibleActions;
+    private mode;
+    protected build(): HTMLDivElement;
+    protected onRender(): void;
+    /** The row, record, column and cell element under a node (e.g. an event target), if it is a body cell. */
+    cellAt(node: EventTarget | null): GridCell<T> | undefined;
+    /** The body cell of row `index` and column `field`, when that row is in the DOM (rows are virtualized). */
+    getCell(index: number, field: string): HTMLElement | undefined;
+    /** The visible data columns, in order (no checkbox/action columns). */
+    getColumns(): Column<T>[];
+    /** The active row index (keyboard cursor), or -1. */
+    getActive(): number;
+    notifyMount(): void;
+    /** Re-measures row height and scrollbar (needed after the grid becomes visible or resizes). */
+    private layout;
+    private bindStore;
+    /** Brings count, selection and the empty state in line with the store. */
+    private sync;
+    setStore(store: Store<T>): void;
+    getStore(): Store<T>;
+    /** Column widths → the CSS grid template shared by the header and every row. */
+    private layoutColumns;
+    private buildHeader;
+    /** Labels over runs of neighbouring columns that share a group (a dragged column can split a group: it shows twice). */
+    private groupBand;
+    /** The group labels in the order they first appear. */
+    getColumnGroups(): string[];
+    /** Shows or hides every column of a group at once (at least one column always stays visible). */
+    setColumnGroupVisible(group: string, visible: boolean): void;
+    setColumns(columns: Column[]): void;
+    /** Order, visibility and width of every column; save it and give it back to `setColumnState`. */
+    getColumnState(): ColumnState[];
+    /** Restores a saved state: columns follow its order (unknown ones keep their place at the end). */
+    setColumnState(state: ColumnState[]): void;
+    private canResize;
+    /** Sets a column's width in px (clamped to `minWidth`/`maxWidth`); `undefined` gives it back its flexible width. */
+    setColumnWidth(field: string, width: number | undefined): void;
+    private initColumnResize;
+    private dir;
+    /** Moves a (user) column in front of `before` (or to the end when null). Hidden columns keep their places. */
+    moveColumn(field: string, before: string | null): void;
+    private initColumnDrag;
+    private paintSort;
+    /** asc → desc → unsorted. */
+    private sortBy;
+    private rowIndexOffset;
+    private renderRow;
+    private indexOfEvent;
+    private onRowEvent;
+    getSelection(): Model<T>[];
+    /** Selects a record or row index. `add` keeps the current selection (multi mode). */
+    select(target: Model<T> | number, opts?: {
+        add?: boolean;
+    }): void;
+    deselectAll(): void;
+    private changed;
+    /** Selects every record that matches the filters, across pages (a remote store: the loaded page). */
+    selectAllFiltered(): void;
+    /** Click semantics: plain = replace, ctrl/meta = toggle, shift = range from the anchor (multi only). */
+    private pick;
+    private setActive;
+    private updateActiveDescendant;
+    focusRow(i: number): void;
+    protected focusEl(): HTMLElement;
+    scrollToRow(i: number): void;
+    private onKey;
+    refresh(): void;
+    private buildBar;
+    /** Header checkbox state and the bulk bar, from the current selection. */
+    private paintSelection;
+    private openRowMenu;
+    private buildColumnMenu;
+    private paintColumnList;
+    protected onDestroy(): void;
+}

package/dist/types/components/data/pagination/pagination.d.ts

@@ -0,0 +1,31 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import type { Store } from '../../../data/store.js';
+export interface PaginationConfig extends ComponentConfig {
+    /** Reads and drives the store's page. Without it, use `total`/`pageSize`/`page`. */
+    store?: Store<any>;
+    total?: number;
+    pageSize?: number;
+    page?: number;
+    /** Page buttons shown on each side of the current one. Default 1. */
+    siblings?: number;
+    showInfo?: boolean;
+}
+export declare class Pagination extends Component<PaginationConfig> {
+    protected baseCls: string;
+    protected tag: 'nav';
+    private unsub?;
+    protected onRender(): void;
+    private bindStore;
+    getPage(): number;
+    private size;
+    private total;
+    private pages;
+    /** Goes to a page (`before-page-change` can cancel), updating the store when there is one. */
+    setPage(page: number): void;
+    setTotal(total: number): void;
+    setPageSize(size: number): void;
+    setStore(store: Store<any>): void;
+    /** Page numbers with `null` where a gap is collapsed: 1 … 4 5 6 … 20. */
+    private window;
+    private paint;
+}

package/dist/types/components/data/searchgrid/searchgrid.d.ts

@@ -0,0 +1,63 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import { type AnyConfig } from '../../../core/registry.js';
+import type { Store } from '../../../data/store.js';
+import type { Model } from '../../../data/model.js';
+import type { Column } from '../../../data/column.js';
+import type { FilterOp, FilterSpec } from '../../../data/proxy.js';
+import { Grid } from '../grid/grid.js';
+/** A filter field of a lookup: any field config, plus how its value is matched. */
+export type LookupFilter = AnyConfig & {
+    name: string;
+    op?: FilterOp;
+    field?: string;
+};
+/** Everything that describes "search for a record": shared by SearchGrid and LookupField. */
+export interface LookupDef {
+    /** A function gives every instance its own store (recommended when the definition is reused). */
+    store: Store<any> | (() => Store<any>);
+    columns: Column[];
+    filters?: LookupFilter[];
+    /** Name of the filter that receives the quick text (LookupField typing). Default: the first filter. */
+    queryField?: string;
+    valueField?: string;
+    displayField?: string;
+    selection?: 'single' | 'multi';
+    paging?: boolean;
+    /** Search when shown. Default true. */
+    autoSearch?: boolean;
+    title?: string;
+    width?: number;
+    height?: number;
+}
+/** Registers a lookup definition for declarative use by name (`lookup: 'people'`). */
+export declare function registerLookup(name: string, def: LookupDef): void;
+export declare function resolveLookup(lookup: LookupDef | string): LookupDef;
+export declare const lookupStore: (def: LookupDef) => Store<any>;
+export interface SearchGridConfig extends ComponentConfig {
+    lookup: LookupDef | string;
+}
+/** Filters on top, results grid below. The Store does the searching; this component only turns the filter fields into specs. */
+export declare class SearchGrid extends Component<SearchGridConfig> {
+    protected baseCls: string;
+    private def;
+    private store;
+    private fields;
+    private grid;
+    private form;
+    protected build(): HTMLDivElement;
+    protected onRender(): void;
+    notifyMount(): void;
+    private confirm;
+    /** The non-empty filter fields as filter specs. */
+    getFilters(): FilterSpec[];
+    /** Filters the store with the current fields (or loads it, when there are none). Resolves when the results are in. */
+    search(query?: string): Promise<void>;
+    /** Empties the filter fields and searches again. */
+    clear(): void;
+    /** Fills the quick-search field (`queryField`, default the first filter) without searching. */
+    setQuery(text: string): void;
+    getSelection(): Model[];
+    getGrid(): Grid;
+    getStore(): Store<any>;
+    focus(): void;
+}

package/dist/types/components/data/table/table.d.ts

@@ -0,0 +1,26 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import { Store } from '../../../data/store.js';
+import { type Column } from '../../../data/column.js';
+export interface TableConfig extends ComponentConfig {
+    data?: Record<string, any>[];
+    store?: Store<any>;
+    columns?: Column[];
+    caption?: string;
+    striped?: boolean;
+    emptyText?: string;
+}
+/** Plain semantic `<table>` for small datasets. No selection, sorting or virtualization: use Grid for those. */
+export declare class Table extends Component<TableConfig> {
+    protected baseCls: string;
+    protected tag: 'table';
+    private store;
+    private unsub?;
+    protected onRender(): void;
+    private bind;
+    private cols;
+    private paint;
+    setData(data: Record<string, any>[]): void;
+    setStore(store: Store<any>): void;
+    setColumns(columns: Column[]): void;
+    setCaption(caption: string): void;
+}

package/dist/types/components/data/tree/tree.d.ts

@@ -0,0 +1,71 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export interface TreeNode {
+    id: string;
+    text: string;
+    icon?: string;
+    children?: TreeNode[];
+    /** No children and nothing to load: no expand arrow. Default: true when there are no `children` and no `load`. */
+    leaf?: boolean;
+    expanded?: boolean;
+    disabled?: boolean;
+    /** With `checkboxes`: the node's own state (a parent's state comes from its children). */
+    checked?: boolean;
+    data?: unknown;
+}
+export type CheckState = boolean | 'mixed';
+export interface TreeConfig extends ComponentConfig {
+    items?: TreeNode[];
+    /** `single` (default), `multi` (Ctrl/⌘ + click or Space toggle) or `none`. */
+    selection?: 'single' | 'multi' | 'none';
+    /** A tri-state checkbox per node: checking a parent checks its whole branch; a parent shows "mixed" when partly checked. */
+    checkboxes?: boolean;
+    /** Children on demand: called the first time a node without `children` (and not `leaf`) is expanded. */
+    load?: (node: TreeNode) => Promise<TreeNode[]> | TreeNode[];
+    emptyText?: string;
+}
+/** A hierarchy: expand/collapse, single or multiple selection, tri-state checkboxes, children loaded on demand, filter, APG tree keyboard. */
+export declare class Tree extends Component<TreeConfig> {
+    protected baseCls: string;
+    private items;
+    private open;
+    private selected;
+    private loading;
+    private query;
+    private focusId?;
+    private root;
+    protected onRender(): void;
+    getNode(id: string, list?: TreeNode[]): TreeNode | undefined;
+    /** The ancestors of a node, from the root down. */
+    getPath(id: string, list?: TreeNode[], trail?: TreeNode[]): TreeNode[] | undefined;
+    private isLeaf;
+    private matches;
+    private walk;
+    private paint;
+    private node;
+    expand(id: string): Promise<void>;
+    collapse(id: string): void;
+    toggle(id: string): void;
+    /** Opens every node that already has its children (it does not load). */
+    expandAll(): void;
+    collapseAll(): void;
+    private pick;
+    /** Selects a node (opening its parents); `add` keeps the current selection in multi mode. */
+    select(id: string, opts?: {
+        add?: boolean;
+    }): void;
+    getSelection(): TreeNode[];
+    deselectAll(): void;
+    /** A node's state: its own `checked`, or for a parent with children, all / none / "mixed" of them. */
+    checkState(n: TreeNode): CheckState;
+    private setBranch;
+    setChecked(id: string, on: boolean): void;
+    toggleChecked(id: string): void;
+    /** Every checked node (a fully checked parent and its children all count). */
+    getChecked(): TreeNode[];
+    setItems(items: TreeNode[]): void;
+    /** Shows only what matches (and its ancestors, opened); empty text clears the filter. */
+    filter(text: string): void;
+    private rows;
+    private focusRow;
+    private onKey;
+}

package/dist/types/components/data/viewmanager/viewmanager.d.ts

@@ -0,0 +1,86 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+import type { FilterGroup, Sorter } from '../../../data/proxy.js';
+import type { Grid, ColumnState } from '../grid/grid.js';
+import type { FilterBuilder } from '../filterbuilder/filterbuilder.js';
+/** Everything a view remembers: plain JSON, so it can travel to any backend. */
+export interface ViewState {
+    columns?: ColumnState[];
+    filter?: FilterGroup | null;
+    sorters?: Sorter[];
+    /** Whatever the app registered in `extra` (panel collapsed, density...). */
+    extra?: Record<string, unknown>;
+}
+export interface SavedView {
+    id?: string;
+    name: string;
+    default?: boolean;
+    state: ViewState;
+}
+/** Where views live. Implement it for your endpoint; `localViewStorage` and `restViewStorage` are ready-made. */
+export interface ViewStorage {
+    list(): Promise<SavedView[]> | SavedView[];
+    /** Create (no `id`) or update. May return the stored view (with the id the server gave it). */
+    save(view: SavedView): Promise<SavedView | void> | SavedView | void;
+    remove(view: SavedView): Promise<void> | void;
+}
+/** Views in the browser (`localStorage` by default) under one key. */
+export declare function localViewStorage(key: string, storage?: Storage): ViewStorage;
+export interface RestViewStorageConfig {
+    /** `GET url` lists, `POST url` creates, `PUT url/:id` updates, `DELETE url/:id` removes. JSON in and out. */
+    url: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+/** Views on your server. Responses must be JSON (the list as an array, create/update returning the stored view). */
+export declare function restViewStorage(cfg: RestViewStorageConfig): ViewStorage;
+export interface ViewManagerConfig extends ComponentConfig {
+    grid: Grid;
+    /** Its filter tree is part of the view. */
+    filters?: FilterBuilder;
+    storage: ViewStorage;
+    /** Extra things to remember: `{ density: { get: () => ..., set: (v) => ... } }`. Stored in `state.extra`. */
+    extra?: Record<string, {
+        get(): unknown;
+        set(value: unknown): void;
+    }>;
+    /** Apply the default view when it opens. Default true. */
+    autoLoad?: boolean;
+}
+/**
+ * "Views" button for a Grid (and its FilterBuilder): saves and restores the visible columns and their order, the filters
+ * (including nested AND/OR groups) and the sort, under a name, in the storage you give it.
+ */
+export declare class ViewManager extends Component<ViewManagerConfig> {
+    protected baseCls: string;
+    private btn;
+    private menu?;
+    private views;
+    private current?;
+    private initial;
+    protected build(): HTMLSpanElement;
+    protected onRender(): void;
+    notifyMount(): void;
+    /** The grid's and filter's current setup. */
+    getState(): ViewState;
+    /** Puts a setup on the grid and the filter. */
+    setState(s: ViewState): void;
+    getViews(): SavedView[];
+    getCurrent(): SavedView | undefined;
+    /** Reads the views from the storage and applies the default one (unless a view is already active). */
+    reload(): Promise<void>;
+    /** Applies a saved view (object or id). */
+    apply(view: SavedView | string): void;
+    /** Saves the current setup into the active view; with none active, asks for a name first. */
+    save(): Promise<void>;
+    /** Saves the current setup as a view with that name (asked for when omitted); an existing name is overwritten. */
+    saveAs(name?: string): Promise<void>;
+    /** Marks the active view as the one applied on open (and unmarks the others). */
+    setDefault(on?: boolean): Promise<void>;
+    remove(view?: SavedView | undefined): Promise<void>;
+    /** Back to the setup the grid had when the manager opened. */
+    reset(): void;
+    private store;
+    private run;
+    private paint;
+    private openMenu;
+}

package/dist/types/components/dataview.d.ts

@@ -0,0 +1 @@
+export * from '../components/data/dataview/dataview.js';

package/dist/types/components/datefield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/datefield/datefield.js';

package/dist/types/components/daterangefield.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/daterangefield/daterangefield.js';

package/dist/types/components/dates/calendar/calendar.d.ts

@@ -0,0 +1,48 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+/** Both ends are `YYYY-MM-DD`; `end` is null while the user has only picked the first day. */
+export interface DateRange {
+    start: string | null;
+    end: string | null;
+}
+export interface CalendarConfig extends ComponentConfig {
+    /** Selected day, `YYYY-MM-DD`; with `range: true`, a `DateRange`. */
+    value?: string | DateRange | null;
+    /** Pick a start and an end day (two clicks). */
+    range?: boolean;
+    min?: string;
+    max?: string;
+    /** 0 = Sunday. Default: the locale's. */
+    firstDay?: number;
+    isDisabled?: (iso: string) => boolean;
+}
+/** Month calendar. Click the title to pick a month; arrow keys, Page keys and Home/End move the focused day. */
+export declare class Calendar extends Component<CalendarConfig> {
+    protected baseCls: string;
+    private cursor;
+    private mode;
+    private titleEl;
+    private bodyEl;
+    private prevEl;
+    private nextEl;
+    protected build(): HTMLDivElement;
+    protected onRender(): void;
+    private blocked;
+    /** The value as a range (a single day is a one-day range). */
+    private span;
+    private first;
+    private choose;
+    private step;
+    private move;
+    private onKey;
+    private weekStart;
+    private paint;
+    private paintDays;
+    private paintMonths;
+    setValue(value: string | DateRange | null): void;
+    /** Switches between single-day and range picking. */
+    setRange(range: boolean): void;
+    setMin(min: string | undefined): void;
+    setMax(max: string | undefined): void;
+    showMonth(year: number, month: number): void;
+    focusDay(): void;
+}

package/dist/types/components/dial.d.ts

@@ -0,0 +1 @@
+export * from '../components/fields/dial/dial.js';

package/dist/types/components/dropdown.d.ts

@@ -0,0 +1 @@
+export * from '../components/overlays/dropdown/dropdown.js';

package/dist/types/components/feedback/spinner/spinner.d.ts

@@ -0,0 +1,11 @@
+import { Component, type ComponentConfig } from '../../../core/component.js';
+export interface SpinnerConfig extends ComponentConfig {
+    label?: string;
+}
+/** Indeterminate progress indicator. The loading mask (`loading` config on any component) uses the same element. */
+export declare class Spinner extends Component<SpinnerConfig> {
+    protected baseCls: string;
+    protected tag: 'span';
+    protected onRender(): void;
+    setLabel(label: string): void;
+}

package/dist/types/components/fieldgroup.d.ts

@@ -0,0 +1 @@
+export * from '../components/form/fieldgroup/fieldgroup.js';

package/dist/types/components/fieldlist.d.ts

@@ -0,0 +1 @@
+export * from '../components/form/fieldlist/fieldlist.js';

package/dist/types/components/fields/checkbox/checkbox.d.ts

@@ -0,0 +1,20 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+export interface CheckboxConfig extends FieldConfig<boolean> {
+    boxLabel?: string;
+    indeterminate?: boolean;
+}
+export declare class Checkbox extends Field<boolean, CheckboxConfig> {
+    protected baseCls: string;
+    private textEl;
+    protected emptyValue(): boolean;
+    /** `required` means "must be checked". */
+    protected isEmpty(v: boolean): boolean;
+    protected createControl(): HTMLLabelElement;
+    protected onRender(): void;
+    protected applyValue(v: boolean): void;
+    private paint;
+    protected onDisabled(disabled: boolean): void;
+    setBoxLabel(text: string): void;
+    setIndeterminate(on: boolean): void;
+    toggle(): void;
+}

package/dist/types/components/fields/checkboxgroup/checkboxgroup.d.ts

@@ -0,0 +1,27 @@
+import { Field, type FieldConfig } from '../../../core/field.js';
+import type { RadioOption } from '../radiogroup/radiogroup.js';
+type Value = string | number;
+export interface CheckboxGroupConfig extends FieldConfig<Value[]> {
+    options?: RadioOption[];
+    direction?: 'vertical' | 'horizontal';
+}
+/** Several choices from a few visible options; the value is the list of checked option values, in option order. */
+export declare class CheckboxGroup extends Field<Value[], CheckboxGroupConfig> {
+    protected baseCls: string;
+    private group;
+    private inputs;
+    protected emptyValue(): Value[];
+    /** `required` means "at least one". */
+    protected isEmpty(v: Value[]): boolean;
+    protected isEqual(a: Value[], b: Value[]): boolean;
+    protected createControl(): HTMLElement;
+    private opts;
+    private buildOptions;
+    protected onRender(): void;
+    protected applyValue(v: Value[]): void;
+    private paint;
+    getDisplayText(): string;
+    protected onDisabled(disabled: boolean): void;
+    setOptions(options: RadioOption[]): void;
+}
+export {};

package/dist/types/components/fields/combobox/combobox.d.ts

@@ -0,0 +1,15 @@
+import { PickerField, type PickerConfig, type ListItem } from '../pickerfield/pickerfield.js';
+export interface ComboBoxConfig<V = unknown> extends PickerConfig<V> {
+    filter?: 'contains' | 'startsWith' | ((item: ListItem, text: string) => boolean);
+}
+/** Editable list: typing filters the options locally. */
+export declare class ComboBox<V = unknown> extends PickerField<V, ComboBoxConfig<V>> {
+    protected baseCls: string;
+    private term;
+    protected emptyValue(): V;
+    protected isEmpty(v: V): boolean;
+    protected visibleItems(): ListItem[];
+    protected onType(text: string): void;
+    protected pick(item: ListItem): void;
+    protected settle(): void;
+}

package/dist/types/components/fields/datefield/datefield.d.ts

@@ -0,0 +1,30 @@
+import { TextField, type TextFieldConfig } from '../textfield/textfield.js';
+export interface DateFieldConfig extends TextFieldConfig<string | null> {
+    min?: string;
+    max?: string;
+    firstDay?: number;
+}
+/** Value is an ISO date string (`YYYY-MM-DD`) or null; the text shown and accepted follows the locale. */
+export declare class DateField extends TextField<string | null, DateFieldConfig> {
+    protected baseCls: string;
+    private cal;
+    private dd;
+    private garbage;
+    protected emptyValue(): null;
+    protected isEmpty(v: string | null): boolean;
+    protected parse(text: string): string | null;
+    protected display(v: string | null): string;
+    protected createControl(): HTMLDivElement;
+    protected onKey(e: KeyboardEvent): void;
+    protected onInput(): void;
+    protected applyValue(v: string | null): void;
+    protected onDisabled(disabled: boolean): void;
+    protected check(): string;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    expand(): void;
+    collapse(): void;
+    setMin(min: string | undefined): void;
+    setMax(max: string | undefined): void;
+}