@keenmate/web-grid 1.0.0-rc02

package/dist/grid.d.ts

@@ -0,0 +1,319 @@
+import type { Column, CellValidationState, RowToolbarConfig, ContextMenuItem, RowChangeDetail, ToolbarClickDetail, RowActionClickDetail, ContextMenuContext, EditTrigger, EditingCell, FocusedCell, SortState, DataRequestDetail, DataRequestTrigger, BeforeCommitResult, GridMode, ToggleVisibility, PaginationLabelsCallback, SummaryContentCallback } from './types.js';
+/**
+ * WebGrid - Core logic class for the data grid
+ *
+ * This class contains all the state management and business logic.
+ * GridElement extends this to add DOM rendering and web component lifecycle.
+ */
+export declare class WebGrid<T = unknown> {
+    protected _items: T[];
+    protected _columns: Column<T>[];
+    protected _sortable: boolean;
+    protected _filterable: boolean;
+    protected _pageable: boolean;
+    protected _pageSize: number;
+    protected _pageSizes: number[];
+    protected _striped: boolean;
+    protected _hoverable: boolean;
+    protected _editable: boolean;
+    protected _editTrigger: EditTrigger;
+    protected _mode: GridMode;
+    protected _dropdownToggleVisibility: ToggleVisibility;
+    protected _dropdownShowOnFocus: boolean;
+    protected _openDropdownOnEnter: boolean;
+    protected _checkboxAlwaysEditable: boolean;
+    protected _showRowNumbers: boolean;
+    protected _invalidCells: CellValidationState[];
+    protected _showRowToolbar: boolean;
+    protected _rowToolbar: RowToolbarConfig<T>[];
+    protected _toolbarAlign: 'center' | 'top';
+    protected _toolbarTopPosition: 'start' | 'center' | 'end' | 'cursor';
+    protected _toolbarTrigger: 'hover' | 'click' | 'button';
+    protected _contextMenu: ContextMenuItem<T>[] | undefined;
+    protected _onrowchange: ((detail: RowChangeDetail<T>) => void) | undefined;
+    protected _onroweditstart: ((detail: {
+        row: T;
+        rowIndex: number;
+        field: string;
+    }) => void) | undefined;
+    protected _onroweditcancel: ((detail: {
+        row: T;
+        rowIndex: number;
+        field: string;
+    }) => void) | undefined;
+    protected _onvalidationerror: ((detail: {
+        row: T;
+        rowIndex: number;
+        field: string;
+        error: string;
+    }) => void) | undefined;
+    protected _ontoolbarclick: ((detail: ToolbarClickDetail<T>) => void) | undefined;
+    protected _onrowaction: ((detail: RowActionClickDetail<T>) => void) | undefined;
+    protected _oncontextmenuopen: ((context: ContextMenuContext<T>) => void) | undefined;
+    protected _ondatarequest: ((detail: DataRequestDetail) => void) | undefined;
+    protected _onrowdelete: ((detail: {
+        rowIndex: number;
+        row: T;
+    }) => void) | undefined;
+    protected _sort: SortState[];
+    protected _filters: Record<string, string>;
+    protected _currentPage: number;
+    protected _totalItems: number | null;
+    protected _showPagination: boolean | 'auto';
+    protected _paginationPosition: string;
+    protected _paginationLabelsCallback?: PaginationLabelsCallback;
+    protected _paginationLayout: string;
+    protected _summaryPosition?: string;
+    protected _summaryContentCallback?: SummaryContentCallback<T>;
+    protected _summaryMetadata: unknown;
+    protected _summaryInline: boolean;
+    protected _customStylesCallback?: () => string;
+    protected _rowClassCallback?: (row: T, rowIndex: number) => string | null;
+    protected _virtualScroll: boolean;
+    protected _virtualScrollThreshold: number;
+    protected _virtualScrollRowHeight: number;
+    protected _virtualScrollBuffer: number;
+    protected _infiniteScroll: boolean;
+    protected _infiniteScrollThreshold: number;
+    protected _hasMoreItems: boolean;
+    protected _isLoadingMore: boolean;
+    protected _editingCell: EditingCell;
+    protected _currentCellError: string | null;
+    protected _isValidating: boolean;
+    protected _draftRows: Map<number, T>;
+    protected _focusedCell: FocusedCell;
+    protected _isCommittingFromKeyboard: boolean;
+    protected _skipNextDropdownAutoEdit: boolean;
+    get items(): T[];
+    set items(value: T[]);
+    get columns(): Column<T>[];
+    set columns(value: Column<T>[]);
+    get sortable(): boolean;
+    set sortable(value: boolean);
+    get filterable(): boolean;
+    set filterable(value: boolean);
+    get pageable(): boolean;
+    set pageable(value: boolean);
+    get pageSize(): number;
+    set pageSize(value: number);
+    get pageSizes(): number[];
+    set pageSizes(value: number[]);
+    get striped(): boolean;
+    set striped(value: boolean);
+    get hoverable(): boolean;
+    set hoverable(value: boolean);
+    get editable(): boolean;
+    set editable(value: boolean);
+    get editTrigger(): EditTrigger;
+    set editTrigger(value: EditTrigger);
+    get mode(): GridMode;
+    set mode(value: GridMode);
+    get dropdownToggleVisibility(): ToggleVisibility;
+    set dropdownToggleVisibility(value: ToggleVisibility);
+    /**
+     * Get effective toggle visibility for a column (column override or grid default)
+     */
+    getEffectiveToggleVisibility(column: Column<T>): ToggleVisibility;
+    get dropdownShowOnFocus(): boolean;
+    set dropdownShowOnFocus(value: boolean);
+    get openDropdownOnEnter(): boolean;
+    set openDropdownOnEnter(value: boolean);
+    /**
+     * Get effective openDropdownOnEnter for a column (column override or grid default)
+     */
+    getEffectiveOpenDropdownOnEnter(column: Column<T>): boolean;
+    get checkboxAlwaysEditable(): boolean;
+    set checkboxAlwaysEditable(value: boolean);
+    get showRowNumbers(): boolean;
+    set showRowNumbers(value: boolean);
+    get invalidCells(): CellValidationState[];
+    set invalidCells(value: CellValidationState[]);
+    get editingCell(): EditingCell;
+    get isValidating(): boolean;
+    get currentCellError(): string | null;
+    get showRowToolbar(): boolean;
+    set showRowToolbar(value: boolean);
+    get rowToolbar(): RowToolbarConfig<T>[];
+    set rowToolbar(value: RowToolbarConfig<T>[]);
+    get toolbarAlign(): 'center' | 'top';
+    set toolbarAlign(value: 'center' | 'top');
+    get toolbarTopPosition(): 'start' | 'center' | 'end' | 'cursor';
+    set toolbarTopPosition(value: 'start' | 'center' | 'end' | 'cursor');
+    get toolbarTrigger(): 'hover' | 'click' | 'button';
+    set toolbarTrigger(value: 'hover' | 'click' | 'button');
+    get contextMenu(): ContextMenuItem<T>[] | undefined;
+    set contextMenu(value: ContextMenuItem<T>[] | undefined);
+    get sort(): SortState[];
+    set sort(value: SortState[]);
+    get currentPage(): number;
+    set currentPage(value: number);
+    get totalItems(): number | null;
+    set totalItems(value: number | null);
+    get showPagination(): boolean | 'auto';
+    set showPagination(value: boolean | 'auto');
+    get paginationPosition(): string;
+    set paginationPosition(value: string);
+    get paginationLabelsCallback(): PaginationLabelsCallback | undefined;
+    set paginationLabelsCallback(value: PaginationLabelsCallback | undefined);
+    get paginationLayout(): string;
+    set paginationLayout(value: string);
+    get summaryPosition(): string | undefined;
+    set summaryPosition(value: string | undefined);
+    get summaryContentCallback(): SummaryContentCallback<T> | undefined;
+    set summaryContentCallback(value: SummaryContentCallback<T> | undefined);
+    get summaryMetadata(): unknown;
+    set summaryMetadata(value: unknown);
+    get summaryInline(): boolean;
+    set summaryInline(value: boolean);
+    get customStylesCallback(): (() => string) | undefined;
+    set customStylesCallback(value: (() => string) | undefined);
+    get rowClassCallback(): ((row: T, rowIndex: number) => string | null) | undefined;
+    set rowClassCallback(value: ((row: T, rowIndex: number) => string | null) | undefined);
+    get virtualScroll(): boolean;
+    set virtualScroll(value: boolean);
+    get virtualScrollThreshold(): number;
+    set virtualScrollThreshold(value: number);
+    get virtualScrollRowHeight(): number;
+    set virtualScrollRowHeight(value: number);
+    get virtualScrollBuffer(): number;
+    set virtualScrollBuffer(value: number);
+    get infiniteScroll(): boolean;
+    set infiniteScroll(value: boolean);
+    get infiniteScrollThreshold(): number;
+    set infiniteScrollThreshold(value: number);
+    get hasMoreItems(): boolean;
+    set hasMoreItems(value: boolean);
+    get isLoadingMore(): boolean;
+    set isLoadingMore(value: boolean);
+    /**
+     * Check if virtual scroll should be used
+     */
+    shouldUseVirtualScroll(): boolean;
+    get showRowActions(): boolean;
+    set showRowActions(value: boolean);
+    get rowActions(): RowToolbarConfig<T>[];
+    set rowActions(value: RowToolbarConfig<T>[]);
+    set onrowchange(value: ((detail: RowChangeDetail<T>) => void) | undefined);
+    set onroweditstart(value: ((detail: {
+        row: T;
+        rowIndex: number;
+        field: string;
+    }) => void) | undefined);
+    set onroweditcancel(value: ((detail: {
+        row: T;
+        rowIndex: number;
+        field: string;
+    }) => void) | undefined);
+    set onvalidationerror(value: ((detail: {
+        row: T;
+        rowIndex: number;
+        field: string;
+        error: string;
+    }) => void) | undefined);
+    get ontoolbarclick(): ((detail: ToolbarClickDetail<T>) => void) | undefined;
+    set ontoolbarclick(value: ((detail: ToolbarClickDetail<T>) => void) | undefined);
+    set onrowaction(value: ((detail: RowActionClickDetail<T>) => void) | undefined);
+    set oncontextmenuopen(value: ((context: ContextMenuContext<T>) => void) | undefined);
+    get ondatarequest(): ((detail: DataRequestDetail) => void) | undefined;
+    set ondatarequest(value: ((detail: DataRequestDetail) => void) | undefined);
+    get onrowdelete(): ((detail: {
+        rowIndex: number;
+        row: T;
+    }) => void) | undefined;
+    set onrowdelete(value: ((detail: {
+        rowIndex: number;
+        row: T;
+    }) => void) | undefined);
+    get isNavigateMode(): boolean;
+    get filteredItems(): T[];
+    get sortedItems(): T[];
+    get paginatedItems(): T[];
+    get totalPages(): number;
+    get displayItems(): T[];
+    /**
+     * Fire ondatarequest event with current state
+     */
+    fireDataRequest(trigger: DataRequestTrigger): void;
+    /**
+     * Check if column is currently sorted
+     */
+    getColumnSortState(field: string): SortState | undefined;
+    /**
+     * Get sort priority (1-based) for a column, or 0 if not sorted
+     */
+    getColumnSortPriority(field: string): number;
+    /**
+     * Apply sensible defaults based on the current mode.
+     * Called when mode is set.
+     */
+    protected applyModeDefaults(): void;
+    protected requestUpdate(): void;
+    getRowDraft(rowIndex: number): T | undefined;
+    hasRowDraft(rowIndex: number): boolean;
+    discardRowDraft(rowIndex: number): void;
+    getDraftRowIndices(): number[];
+    discardAllDrafts(): void;
+    getCellRawValue(item: T, rowIndex: number, field: string): unknown;
+    getCellValue(item: T, column: Column<T>, rowIndex?: number): string;
+    isCellInvalid(rowIndex: number, field: string): boolean;
+    getCellValidationError(rowIndex: number, field: string): string | null;
+    protected addInvalidCell(rowIndex: number, field: string, error: string): void;
+    protected removeInvalidCell(rowIndex: number, field: string): void;
+    /**
+     * Check if a specific cell is currently being edited
+     */
+    isEditing(rowIndex: number, field: string): boolean;
+    /**
+     * Start editing a cell
+     */
+    startEdit(rowIndex: number, field: string, options?: {
+        initialSearchQuery?: string;
+        cursorPosition?: number;
+    }): void;
+    /**
+     * Cancel editing without saving
+     */
+    cancelEdit(): void;
+    /**
+     * Normalize validation result to consistent format
+     */
+    protected normalizeValidationResult(result: BeforeCommitResult, value: unknown): {
+        valid: boolean;
+        message?: string;
+        finalValue: unknown;
+    };
+    /**
+     * Commit edit with validation
+     */
+    commitEdit(rowIndex: number, field: string, newValue: unknown): Promise<void>;
+    /**
+     * Check if a column's cells can be edited
+     */
+    isCellEditable(column: Column<T>): boolean;
+    /**
+     * Get all editable columns with their indices
+     */
+    getEditableColumns(): {
+        index: number;
+        column: Column<T>;
+    }[];
+    /**
+     * Check if a specific cell is currently focused
+     */
+    isCellFocused(rowIndex: number, colIndex: number): boolean;
+    /**
+     * Get the currently focused cell
+     */
+    get focusedCell(): FocusedCell;
+    /**
+     * Set focus to a specific cell (state only, DOM focus handled by GridElement)
+     * NOTE: Does NOT call requestUpdate() - GridElement handles DOM updates surgically
+     */
+    setFocusedCell(rowIndex: number, colIndex: number): void;
+    /**
+     * Clear the focused cell
+     * NOTE: Does NOT call requestUpdate() - GridElement handles DOM updates surgically
+     */
+    clearFocusedCell(): void;
+}
+export default WebGrid;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { GridElement } from './web-component.js';
+export { WebGrid } from './grid.js';
+export type { EditorType, EditTrigger, OptionsLoadTrigger, DateOutputFormat, EditorOption, EditorOptions, CustomEditorContext, CellValidationState, ValidationResult, BeforeCommitContext, BeforeCommitResult, Column, CellRenderCallback, RowChangeDetail, PredefinedToolbarItemType, RowToolbarItem, RowToolbarConfig, NormalizedToolbarItem, ToolbarClickDetail, RowActionType, RowActionClickDetail, ContextMenuContext, ContextMenuItem, QuickGridProps, SortState, DataRequestDetail, DataRequestTrigger, EditingCell, FocusedCell, SortDirection, ToolbarRowGroup, PopupPosition, ConnectorArrowDir } from './types.js';
+export { GridElement as default } from './web-component.js';

package/dist/modules/contextmenu/index.d.ts

@@ -0,0 +1,10 @@
+import type { ContextMenuItem, ContextMenuContext } from '../../types.js';
+import type { GridContext } from '../types.js';
+/**
+ * Open context menu at position
+ */
+export declare function openContextMenu<T>(ctx: GridContext<T>, x: number, y: number, items: ContextMenuItem<T>[], menuContext: ContextMenuContext<T>, onItemClick: (itemId: string) => void, onClose: () => void): HTMLElement | null;
+/**
+ * Close context menu and cleanup
+ */
+export declare function closeContextMenu(container: HTMLElement, handleOutsideClick?: (e: MouseEvent) => void, handleKeyDown?: (e: KeyboardEvent) => void): void;

package/dist/modules/datepicker/datepicker.d.ts

@@ -0,0 +1,79 @@
+import type { DatePickerOptions } from './types.js';
+/**
+ * Lightweight date picker for web-grid
+ */
+export declare class DatePicker {
+    private options;
+    private state;
+    private localeStrings;
+    private formatInfo;
+    private element;
+    private anchor;
+    private input;
+    private cleanupAutoUpdate;
+    private previousInputValue;
+    private boundHandleClickOutside;
+    private boundHandleKeyDown;
+    constructor(options?: DatePickerOptions);
+    /**
+     * Initialize locale strings (use browser Intl API if available)
+     */
+    private initLocaleStrings;
+    /**
+     * Inject datepicker styles into document head (once)
+     */
+    private static injectStyles;
+    /**
+     * Open the date picker
+     */
+    open(anchor: HTMLElement, value?: Date | string | null): void;
+    /**
+     * Close the date picker
+     * @param silent - If true, don't trigger onClose callback (used when switching cells)
+     */
+    close(silent?: boolean): void;
+    /**
+     * Destroy the picker instance
+     */
+    destroy(): void;
+    /**
+     * Get the selected date
+     */
+    getSelectedDate(): Date | null;
+    /**
+     * Get formatted value
+     */
+    getFormattedValue(): string;
+    /**
+     * Position the picker using Floating UI
+     */
+    private position;
+    /**
+     * Attach event listeners
+     */
+    private attachListeners;
+    /**
+     * Handle click events within the picker
+     */
+    private handleClick;
+    /**
+     * Handle click outside the picker
+     */
+    private handleClickOutside;
+    /**
+     * Handle keyboard events
+     */
+    private handleKeyDown;
+    /**
+     * Select a date and fire callback
+     */
+    private selectDate;
+    /**
+     * Re-render the picker contents
+     */
+    private render;
+    /**
+     * Connect an input field for masked input
+     */
+    connectInput(input: HTMLInputElement): void;
+}

package/dist/modules/datepicker/formatting.d.ts

@@ -0,0 +1,44 @@
+import type { FormatInfo } from './types.js';
+/**
+ * Parse a format string like "YYYY-MM-DD" or "DD.MM.YYYY"
+ * Returns structure with positions, separator, and max length
+ */
+export declare function parseFormat(formatString: string): FormatInfo;
+/**
+ * Format a Date object to a string using the given format info
+ */
+export declare function formatDate(date: Date | null, formatInfo: FormatInfo): string;
+/**
+ * Parse a date string using the given format info
+ * Returns null if parsing fails
+ */
+export declare function parseDate(value: string, formatInfo: FormatInfo): Date | null;
+/**
+ * Check if a date is valid
+ */
+export declare function isValidDate(date: Date | null): boolean;
+/**
+ * Normalize a Date or string to a Date object
+ * Returns null if invalid
+ */
+export declare function normalizeDate(dateInput: Date | string | null | undefined): Date | null;
+/**
+ * Format date as YYYY-MM-DD for internal use (data attributes, etc.)
+ */
+export declare function toISODateString(date: Date): string;
+/**
+ * Check if two dates are the same day
+ */
+export declare function isSameDay(date1: Date | null, date2: Date | null): boolean;
+/**
+ * Check if a date is today
+ */
+export declare function isToday(date: Date): boolean;
+/**
+ * Get number of days in a month
+ */
+export declare function getDaysInMonth(year: number, month: number): number;
+/**
+ * Get the first day of week (0-6) for a month
+ */
+export declare function getFirstDayOfMonth(year: number, month: number): number;

package/dist/modules/datepicker/index.d.ts

@@ -0,0 +1,4 @@
+export { DatePicker } from './datepicker.js';
+export type { DatePickerOptions, DatePickerState, FormatInfo, LocaleStrings } from './types.js';
+export { DEFAULT_LOCALE_STRINGS } from './types.js';
+export { parseFormat, formatDate, parseDate, normalizeDate, toISODateString, isSameDay, isToday, isValidDate } from './formatting.js';

package/dist/modules/datepicker/interaction.d.ts

@@ -0,0 +1,39 @@
+import type { DatePickerState, DatePickerOptions, FormatInfo } from './types.js';
+/**
+ * Handle click on a day cell
+ * Returns the selected date if valid, null otherwise
+ */
+export declare function handleDayClick(target: HTMLElement, state: DatePickerState, options: DatePickerOptions): Date | null;
+/**
+ * Handle click on Today button
+ */
+export declare function handleTodayClick(state: DatePickerState, options: DatePickerOptions): Date | null;
+/**
+ * Handle click on month in rolling selector
+ */
+export declare function handleMonthClick(target: HTMLElement, state: DatePickerState): void;
+/**
+ * Handle click on year in rolling selector
+ */
+export declare function handleYearClick(target: HTMLElement, state: DatePickerState): void;
+/**
+ * Apply input mask to enforce date format
+ */
+export declare function applyInputMask(value: string, formatInfo: FormatInfo): string;
+/**
+ * Handle input change with masking
+ */
+export declare function handleInputChange(input: HTMLInputElement, formatInfo: FormatInfo, previousValue: string): string;
+/**
+ * Handle keydown in input field
+ * Returns true if event was handled and should be prevented
+ */
+export declare function handleInputKeyDown(event: KeyboardEvent, formatInfo: FormatInfo): boolean;
+/**
+ * Handle paste in input field
+ */
+export declare function handleInputPaste(event: ClipboardEvent, input: HTMLInputElement, formatInfo: FormatInfo): void;
+/**
+ * Parse input value and update state if valid
+ */
+export declare function updateStateFromInput(value: string, formatInfo: FormatInfo, state: DatePickerState, options: DatePickerOptions): boolean;

package/dist/modules/datepicker/navigation.d.ts

@@ -0,0 +1,37 @@
+import type { DatePickerState, DatePickerOptions } from './types.js';
+/**
+ * Go to the previous month
+ */
+export declare function goToPrevMonth(state: DatePickerState): void;
+/**
+ * Go to the next month
+ */
+export declare function goToNextMonth(state: DatePickerState): void;
+/**
+ * Go to a specific month (0-11)
+ */
+export declare function goToMonth(state: DatePickerState, month: number): void;
+/**
+ * Go to a specific year
+ */
+export declare function goToYear(state: DatePickerState, year: number): void;
+/**
+ * Go to a specific date (updates view to show that month)
+ */
+export declare function goToDate(state: DatePickerState, date: Date): void;
+/**
+ * Handle keyboard navigation within the calendar
+ * Returns true if the event was handled
+ */
+export declare function handleKeyDown(event: KeyboardEvent, state: DatePickerState, options: DatePickerOptions, callbacks: {
+    onSelect?: (date: Date, direction?: 'down' | 'next') => void;
+    onClose?: () => void;
+}): boolean;
+/**
+ * Initialize focus state when picker opens
+ */
+export declare function initializeFocus(state: DatePickerState): void;
+/**
+ * Check if date is in current view month
+ */
+export declare function isInCurrentView(date: Date, state: DatePickerState): boolean;

package/dist/modules/datepicker/rendering.d.ts

@@ -0,0 +1,56 @@
+import type { DatePickerOptions, DatePickerState, LocaleStrings } from './types.js';
+/**
+ * Parse year range string to min/max values
+ */
+export declare function parseYearRange(range: string | undefined, currentYear: number): {
+    min: number;
+    max: number;
+};
+/**
+ * Render the complete date picker structure
+ */
+export declare function renderDatePicker(state: DatePickerState, options: DatePickerOptions, localeStrings?: LocaleStrings): string;
+/**
+ * Render the header with month/year display and navigation
+ */
+export declare function renderHeader(state: DatePickerState, localeStrings: LocaleStrings): string;
+/**
+ * Render the rolling month/year selector
+ */
+export declare function renderRollingSelector(state: DatePickerState, options: DatePickerOptions, localeStrings: LocaleStrings): string;
+/**
+ * Render the calendar grid (weekdays + days)
+ */
+export declare function renderCalendarGrid(state: DatePickerState, options: DatePickerOptions, localeStrings: LocaleStrings): string;
+/**
+ * Render weekday headers
+ */
+export declare function renderWeekdays(localeStrings: LocaleStrings): string;
+/**
+ * Render the day cells for the current month view
+ */
+export declare function renderDays(state: DatePickerState, options: DatePickerOptions): string;
+/**
+ * Render the footer with Today button
+ */
+export declare function renderFooter(localeStrings: LocaleStrings): string;
+/**
+ * Re-render just the days portion (for month navigation)
+ */
+export declare function updateDaysHtml(container: HTMLElement, state: DatePickerState, options: DatePickerOptions): void;
+/**
+ * Update header month/year display
+ */
+export declare function updateHeaderHtml(container: HTMLElement, state: DatePickerState, localeStrings: LocaleStrings): void;
+/**
+ * Toggle rolling selector visibility
+ */
+export declare function toggleRollingSelector(container: HTMLElement, visible: boolean): void;
+/**
+ * Update rolling selector selection state
+ */
+export declare function updateRollingSelectorSelection(container: HTMLElement, state: DatePickerState): void;
+/**
+ * Scroll rolling selector to show selected items
+ */
+export declare function scrollRollingSelectorToSelection(container: HTMLElement): void;

package/dist/modules/datepicker/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Date picker configuration options
+ */
+export interface DatePickerOptions {
+    minDate?: Date | string;
+    maxDate?: Date | string;
+    dateFormat?: string;
+    showTodayButton?: boolean;
+    locale?: string;
+    rollingYearRange?: string;
+    onSelect?: (date: Date | null, direction?: 'down' | 'next') => void;
+    onClose?: () => void;
+}
+/**
+ * Internal state for the date picker
+ */
+export interface DatePickerState {
+    viewMonth: number;
+    viewYear: number;
+    selectedDate: Date | null;
+    isOpen: boolean;
+    rollingSelectorOpen: boolean;
+    rollingSelectorMode: 'month' | 'year';
+    focusedDate: Date | null;
+}
+/**
+ * Parsed format information
+ */
+export interface FormatInfo {
+    format: string;
+    separator: string;
+    parts: {
+        year?: {
+            index: number;
+            length: number;
+        };
+        month?: {
+            index: number;
+            length: number;
+        };
+        day?: {
+            index: number;
+            length: number;
+        };
+    };
+    maxLength: number;
+}
+/**
+ * Locale strings for UI
+ */
+export interface LocaleStrings {
+    today: string;
+    clear: string;
+    monthNames: string[];
+    monthNamesShort: string[];
+    weekdayNames: string[];
+    weekdayNamesShort: string[];
+}
+/**
+ * Default locale strings (English)
+ */
+export declare const DEFAULT_LOCALE_STRINGS: LocaleStrings;

package/dist/modules/dropdown/index.d.ts

@@ -0,0 +1,4 @@
+export { getOptionDisplayValue, getOptionLabel, getOptionValue, getOptionSearchText, getOptionIcon, getOptionSubtitle, isOptionDisabled, getOptionGroup } from './options.js';
+export { renderDropdown, removeDropdown } from './rendering.js';
+export { selectDropdownOption, updateDropdownHighlight, scrollHighlightedIntoView, updateLoadingIndicator, openDropdownForCurrentEditor, toggleDropdown, attachDropdownListeners, updateSelectFilter } from './interaction.js';
+export { handleComboboxInput, handleAutocompleteInput, performAutocompleteSearch } from './input-handlers.js';

package/dist/modules/dropdown/input-handlers.d.ts

@@ -0,0 +1,14 @@
+import type { Column } from '../../types.js';
+import type { GridContext } from '../types.js';
+/**
+ * Handle combobox input (filtering)
+ */
+export declare function handleComboboxInput<T>(ctx: GridContext<T>, e: Event): void;
+/**
+ * Handle autocomplete input (async search)
+ */
+export declare function handleAutocompleteInput<T>(ctx: GridContext<T>, e: Event): void;
+/**
+ * Perform async autocomplete search
+ */
+export declare function performAutocompleteSearch<T>(ctx: GridContext<T>, query: string, column: Column<T>): Promise<void>;