@svgrid/grid 1.0.0 → 1.1.0

package/dist/SvGrid.controller.svelte.d.ts

@@ -0,0 +1,429 @@
+import { type CellEditorOption, type Column, type ColumnDef, type Row, type RowData, type TableFeatures } from "./index";
+import "./sv-grid-scrollbar";
+import { type ColumnStat } from "./conditional-formatting";
+import type { Props, SelectionRange, CellEditState, FilterOperator, MenuPosition, ContextMenuTarget } from "./SvGrid.types";
+import { operatorOption, operatorsForColumn, defaultOperatorFor, operatorLabelFor } from "./filter-operators";
+import { type FacetBucket, isBucketableColumn, buildBuckets, isInBucket } from "./facet-buckets";
+import { getColumnBaseValue, isGroupRow, toolPanelHeaderLabel, formatSummaryNumeric, getColumnAlign, getPinnedCellValue, getColumnAccessorValue, columnDefMatchesId } from "./cell-values";
+/**
+ * SvGrid controller. The component's entire reactive core - every $state,
+ * $derived, $effect and handler - lives here so SvGrid.svelte can stay a thin
+ * view. Instantiated once during the component's init (so $effect attaches to
+ * the component lifecycle) and consumed through the returned getters.
+ */
+export type SvGridController<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData> = ReturnType<typeof createSvGridController<TFeatures, TData>>;
+export declare function createSvGridController<TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(props: Props<TFeatures, TData>): {
+    readonly props: Props<TFeatures, TData>;
+    readonly editingEnabled: boolean;
+    readonly paginationEnabled: boolean;
+    readonly groupingControlsEnabled: boolean;
+    globalFilter: string;
+    scrollContainer: HTMLDivElement | null;
+    gridRootEl: HTMLElement | null;
+    filterRowValues: Record<string, string>;
+    filterMenuValues: Record<string, {
+        operator: FilterOperator;
+        value: string;
+        valueTo?: string;
+    }>;
+    verticalScrollbarEl: HTMLElement | null;
+    horizontalScrollbarEl: HTMLElement | null;
+    scrollVersion: number;
+    viewportVersion: number;
+    lastResetSignature: string;
+    pendingScrollTop: number;
+    pendingScrollLeft: number;
+    scrollSyncRaf: number | null;
+    selectionRange: SelectionRange;
+    isDraggingSelection: boolean;
+    fillDrag: {
+        sourceMinRow: number;
+        sourceMaxRow: number;
+        sourceMinCol: number;
+        sourceMaxCol: number;
+        targetRow: number;
+        targetCol: number;
+    } | null;
+    activeAtPointerDown: {
+        rowIndex: number;
+        colIndex: number;
+    } | null;
+    editingCell: CellEditState;
+    editedCellValues: Record<string, unknown>;
+    readonly UNDO_LIMIT: number;
+    history: {
+        rowId: string;
+        columnId: string;
+        field: string;
+        before: unknown;
+        after: unknown;
+    }[];
+    historyPtr: number;
+    historyVersion: number;
+    tooltip: {
+        text: string;
+        x: number;
+        y: number;
+        below: boolean;
+    } | null;
+    tooltipTimer: number | null;
+    readonly showTooltipFor: (el: HTMLElement, text: string) => void;
+    readonly hideTooltip: () => void;
+    findOpen: boolean;
+    findQuery: string;
+    findHitIndex: number;
+    readonly findHits: {
+        rowIndex: number;
+        colIndex: number;
+        columnId: string;
+    }[];
+    theadEl: HTMLElement | null;
+    headerHeight: number;
+    editorSelectAll: boolean;
+    columnWidths: Record<string, number>;
+    resizingColumnId: string | null;
+    resizeStartX: number;
+    resizeStartWidth: number;
+    readonly MIN_COLUMN_WIDTH: number;
+    columnPinning: {
+        left: Array<string>;
+        right: Array<string>;
+    };
+    columnVirtualizerVersion: number;
+    gridStateVersion: number;
+    readonly selectionColumnWidth: number;
+    readonly rowNumberColumnWidth: number;
+    readonly showRowNumbersEffective: boolean;
+    readonly filterOperatorOptions: import("./SvGrid.types").FilterOption[];
+    readonly TEXT_OPERATORS: FilterOperator[];
+    readonly NUMBER_OPERATORS: FilterOperator[];
+    readonly DATE_OPERATORS: FilterOperator[];
+    readonly CHECKBOX_OPERATORS: FilterOperator[];
+    columnMenuFor: string | null;
+    columnMenuPos: MenuPosition;
+    columnMenuSearch: string;
+    filterMenuFor: string | null;
+    filterMenuPos: MenuPosition;
+    operatorMenuFor: string | null;
+    operatorMenuPos: MenuPosition;
+    chooseColumnsPos: MenuPosition | null;
+    contextMenuFor: ContextMenuTarget<TData> | null;
+    contextMenuPos: MenuPosition;
+    noteOverrides: Record<string, Record<string, string>>;
+    commentEditFor: {
+        rowId: string;
+        columnId: string;
+        x: number;
+        y: number;
+    } | null;
+    commentDraft: string;
+    valueFilters: Record<string, Set<string>>;
+    readonly viewportWidth: number;
+    readonly viewportHeight: number;
+    readonly scrollMetrics: {
+        scrollTop: number;
+        scrollLeft: number;
+        clientHeight: number;
+        clientWidth: number;
+        scrollHeight: number;
+        scrollWidth: number;
+    };
+    readonly hasVerticalOverflow: boolean;
+    readonly showGlobalFilterEffective: boolean;
+    readonly showFilterRowEffective: boolean;
+    readonly showColumnFiltersEffective: boolean;
+    readonly showInlineColumnFilterEffective: boolean;
+    readonly showRowSelectionEffective: boolean;
+    readonly enableCellSelectionEffective: boolean;
+    readonly flushScheduledScrollSync: () => void;
+    readonly scheduleScrollSync: (scrollTop: number, scrollLeft: number) => void;
+    internalData: readonly TData[];
+    internalColumns: ColumnDef<TFeatures, TData>[];
+    hiddenColumns: Record<string, boolean>;
+    readonly externalSortEnabled: boolean;
+    readonly externalFilterEnabled: boolean;
+    readonly passthroughSortedRowModel: ({ rows }: {
+        rows: Array<Row<TData>>;
+    }) => Row<TData>[];
+    readonly resolveEffectiveFeatures: () => TableFeatures;
+    readonly grid: import("./createGrid.svelte").SvelteGrid<TableFeatures, TData, {}>;
+    userColumnOrder: string[];
+    lastSeededOrder: string;
+    readonly allColumns: Column<TData>[];
+    readonly headerGroups: import("./core").HeaderGroup<TData>[];
+    readonly groupHeaderRows: {
+        id: string;
+        cells: {
+            key: string;
+            label: string;
+            colSpan: number;
+            widthPx: number;
+            /** First leaf-column index this cell spans. */
+            firstLeafIndex: number;
+            /** True for the placeholder cells that fill the column above an
+             *  early-bottoming leaf (e.g. the row-label column to the left of a
+             *  multi-level value tree). They render as empty cells so the
+             *  layout stays aligned without showing duplicate labels. */
+            isPlaceholder: boolean;
+        }[];
+    }[];
+    readonly pinnedOffsets: {
+        left: Record<string, number>;
+        right: Record<string, number>;
+    };
+    readonly cellPinStyle: (columnId: string) => string;
+    readonly isColumnPinned: (columnId: string) => "left" | "right" | null;
+    colDragId: string | null;
+    colDropOnId: string | null;
+    colDropSide: "before" | "after" | null;
+    readonly getCurrentColumnOrder: () => string[];
+    readonly emitColumnOrder: () => void;
+    readonly setColumnOrderInternal: (ids: ReadonlyArray<string>) => void;
+    readonly applyColumnDrop: (dragId: string, targetId: string, side: "before" | "after") => void;
+    readonly onColumnHeaderDragStart: (e: DragEvent, columnId: string) => void;
+    readonly onColumnHeaderDragOver: (e: DragEvent, columnId: string) => void;
+    readonly onColumnHeaderDragLeave: (columnId: string) => void;
+    readonly onColumnHeaderDrop: (e: DragEvent, columnId: string) => void;
+    readonly onColumnHeaderDragEnd: () => void;
+    readonly pinColumnLeft: (columnId: string) => void;
+    readonly pinColumnRight: (columnId: string) => void;
+    readonly unpinColumn: (columnId: string) => void;
+    readonly getColumnBaseValue: typeof getColumnBaseValue;
+    readonly hasConditionalFormats: boolean;
+    readonly conditionalColumnStats: Map<string, ColumnStat>;
+    readonly cellConditionalFormat: (row: Row<TData>, column: Column<TData>, value: unknown) => import("./conditional-formatting").ResolvedCellFormat | null;
+    readonly isGroupRow: typeof isGroupRow;
+    readonly isCellEditable: (column: Column<TData>, row?: Row<TData> | undefined) => boolean;
+    readonly isCellEditableAt: (rowIndex: number, colIndex: number) => boolean;
+    readonly sortDirectionByColumn: Record<string, false | "asc" | "desc">;
+    readonly groupingColumns: any;
+    readonly paginationState: any;
+    readonly getRowColumnValue: (row: Row<TData>, columnId: string) => unknown;
+    readonly allRowsBeforePagination: Row<TData>[];
+    readonly allRows: Row<TData>[];
+    readonly rowSelectionState: any;
+    lastSelectionSerialized: string;
+    lastCellRangeSerialized: string;
+    readonly statusBarEnabled: boolean;
+    readonly statusBarAggregates: readonly ("sum" | "avg" | "min" | "max" | "count" | "numericCount")[];
+    readonly statusBarStats: {
+        count: number;
+        numericCount: number;
+        sum: number;
+        avg: number;
+        min: number;
+        max: number;
+    } | null;
+    toolPanelOpen: boolean;
+    readonly toolPanelEnabled: boolean;
+    readonly toolPanelColumns: Column<TData>[];
+    readonly toolPanelHeaderLabel: typeof toolPanelHeaderLabel;
+    readonly toggleColumnVisibleInPanel: (columnId: string) => void;
+    readonly moveColumnInPanel: (columnId: string, dir: -1 | 1) => void;
+    readonly toggleGroupInPanel: (columnId: string) => void;
+    lastSortingSerialized: string;
+    lastFiltersSerialized: string;
+    readonly virtualizer: {
+        readonly version: number;
+        setOptions: (next: Partial<import("./index").VirtualizerOptions>) => void;
+        setScrollOffset: (scrollOffset: number) => void;
+        setViewportHeight: (viewportHeight: number) => void;
+        scrollToIndex: (index: number) => void;
+        getVirtualItems: () => import("./index").VirtualItem[];
+        getTotalSize: () => number;
+        getOffsetForIndex: (index: number) => number;
+        getSizeForIndex: (index: number) => number;
+        getState: () => import("./index").VirtualizerState;
+    };
+    readonly columnVirtualizer: {
+        setViewportWidth(viewportWidth: number): void;
+        setHorizontalOffset(scrollOffset: number): void;
+        setOptions(next: Partial<import("./index").VirtualizerOptions>): void;
+        setScrollOffset(scrollOffset: number): void;
+        setViewportHeight(viewportHeight: number): void;
+        scrollToIndex(index: number): void;
+        getVirtualItems(): import("./index").VirtualItem[];
+        getTotalSize(): number;
+        getOffsetForIndex(index: number): number;
+        getSizeForIndex(index: number): number;
+        getState(): import("./index").VirtualizerState;
+        subscribe(listener: () => void): () => boolean;
+    };
+    readonly rowVirtualizationEnabled: boolean;
+    readonly columnVirtualizationEnabled: boolean;
+    readonly virtualRows: import("./index").VirtualItem[];
+    readonly virtualRowTotalSize: number;
+    readonly virtualRowStart: number;
+    readonly virtualRowEnd: number;
+    readonly virtualRowBottomSpacer: number;
+    readonly rowDomTotalSize: number;
+    readonly rowScrollScalingActive: boolean;
+    readonly rowTopSpacer: number;
+    readonly rowBottomSpacer: number;
+    readonly domToLogicalRowOffset: (domTop: number) => number;
+    readonly logicalToDomRowOffset: (logical: number) => number;
+    readonly virtualColumns: import("./index").VirtualItem[];
+    readonly virtualColumnTotalSize: number;
+    readonly renderedColumnItems: import("./index").VirtualItem[] | {
+        index: number;
+        key: number;
+        size: any;
+        start: number;
+        end: any;
+    }[];
+    readonly hasRenderedColumn: (entry: {
+        item: any;
+        column: any | undefined;
+    }) => entry is {
+        item: any;
+        column: any;
+    };
+    readonly renderedColumns: {
+        item: any;
+        column: any;
+    }[];
+    readonly totalColumnWidth: number;
+    readonly hasHorizontalOverflow: boolean;
+    readonly columnWindowStart: number;
+    readonly columnWindowEnd: any;
+    readonly columnWindowRightSpacer: number;
+    readonly activeCell: any;
+    readonly activeDescendantId: string | null;
+    readonly formatSummaryNumeric: typeof formatSummaryNumeric;
+    readonly computeSummaries: (rows: readonly Row<TData>[], columns: readonly Column<TData>[]) => Record<string, string>;
+    readonly SUMMARY_DEFER_CELL_LIMIT: number;
+    summaryByColumn: Record<string, string>;
+    hasMeasured: boolean;
+    scrollBottomArmed: boolean;
+    readonly onBodyScroll: (event: Event) => void;
+    readonly computeRowClass: (row: Row<TData>, rowIndex: number) => string;
+    readonly computeCellClass: (row: Row<TData>, column: Column<TData>) => string;
+    readonly computeCellTooltip: (row: Row<TData>, column: Column<TData>) => string | null;
+    readonly computeCellNote: (row: Row<TData>, column: Column<TData>) => string | null;
+    readonly getCellDisplayValue: (rowId: string, columnId: string, baseValue: unknown) => any;
+    readonly getColumnAlign: typeof getColumnAlign;
+    readonly editorOptionsCache: Record<string, CellEditorOption[]>;
+    readonly getColumnEditorOptions: (column: Column<TData>, row?: Row<TData> | null | undefined) => CellEditorOption[];
+    readonly formatListCellValue: (column: Column<TData>, value: unknown, row?: Row<TData> | null | undefined) => string;
+    readonly formatCellValue: (column: Column<TData>, value: unknown, row: Row<TData>) => string;
+    readonly getPinnedCellValue: typeof getPinnedCellValue;
+    readonly formatPinnedValue: (column: Column<TData>, value: unknown) => string;
+    readonly computePinnedCellClass: (rowData: TData, column: Column<TData>) => string;
+    readonly isRowSelected: (rowId: string) => boolean;
+    readonly toggleRowSelectionById: (rowId: string) => void;
+    readonly headerSelectionState: "none" | "all" | "some";
+    readonly toggleSelectAllRows: () => void;
+    userHasActivatedCell: boolean;
+    readonly setActiveCell: (rowIndex: number, colIndex: number) => void;
+    readonly scrollActiveCellIntoView: (rowIndex: number, colIndex: number) => void;
+    readonly getColumnBaseWidth: (columnId: string) => any;
+    readonly fittedColumnWidths: Record<string, number> | null;
+    readonly getColumnWidth: (columnId: string) => any;
+    resizePendingWidth: number;
+    resizeRaf: number | null;
+    readonly startColumnResize: (event: PointerEvent, columnId: string) => void;
+    readonly onColumnResizeMove: (event: PointerEvent) => void;
+    readonly endColumnResize: () => void;
+    readonly setSelection: (rowIndex: number, colIndex: number) => void;
+    readonly extendSelection: (rowIndex: number, colIndex: number) => void;
+    readonly isCellInSelectedRange: (rowIndex: number, colIndex: number) => boolean;
+    readonly getCellRangeEdges: (rowIndex: number, colIndex: number) => {
+        top: boolean;
+        bottom: boolean;
+        left: boolean;
+        right: boolean;
+    } | null;
+    readonly fillHandleCell: {
+        rowIndex: any;
+        colIndex: any;
+    } | null;
+    readonly isInFillPreview: (rowIndex: number, colIndex: number) => boolean;
+    readonly findColumnById: (columnId: string) => any;
+    readonly readCellRaw: (rowIndex: number, columnId: string) => unknown;
+    readonly writeCellRaw: (rowIndex: number, columnId: string, value: unknown) => void;
+    readonly applyFillPattern: () => void;
+    readonly clearSelectedCellValues: () => void;
+    readonly startFillDrag: (event: PointerEvent, rowIndex: number, colIndex: number) => void;
+    readonly onFillPointerMove: (event: PointerEvent) => void;
+    readonly onFillPointerUp: () => void;
+    readonly toggleBooleanCell: (rowIndex: number, colIndex: number) => void;
+    readonly onCellPointerDown: (rowIndex: number, colIndex: number, event: PointerEvent) => void;
+    readonly onCellPointerEnter: (rowIndex: number, colIndex: number) => void;
+    readonly endDragSelection: () => void;
+    readonly onWindowPointerMove: (event: PointerEvent) => void;
+    readonly onCellClick: (rowIndex: number, colIndex: number) => void;
+    readonly emitCellDoubleClick: (rowIndex: number, colIndex: number) => void;
+    readonly copySelectionToClipboard: () => void;
+    readonly clearSelectedCells: () => boolean;
+    readonly onCellDoubleClick: (rowIndex: number, colIndex: number) => void;
+    readonly startEditingWithChar: (rowIndex: number, colIndex: number, char: string) => boolean;
+    readonly saveEditingCell: () => void;
+    readonly applyHistoryStep: (step: {
+        rowId: string;
+        columnId: string;
+        field: string;
+        before: unknown;
+        after: unknown;
+    }, direction: "undo" | "redo") => void;
+    readonly updateEditingCellValue: (value: string) => void;
+    readonly onEditorKeyDown: (event: KeyboardEvent) => void;
+    readonly focusOnMount: (node: HTMLInputElement | HTMLTextAreaElement) => void;
+    readonly onHeaderSortClick: (event: MouseEvent, columnId: string) => void;
+    readonly onGridKeyDown: (event: KeyboardEvent) => void;
+    readonly changePage: (delta: number) => void;
+    readonly goToPage: (pageIndex: number) => void;
+    readonly setPageSize: (pageSize: number) => void;
+    readonly openContextMenu: (event: MouseEvent, rowIndex: number, colIndex: number, columnId: string) => void;
+    readonly closeContextMenu: () => void;
+    readonly contextMenuItems: () => {
+        key: string;
+        label: string;
+        separator?: boolean;
+        disabled?: boolean;
+        run?: (() => void) | undefined;
+    }[];
+    readonly saveComment: () => void;
+    readonly removeComment: () => void;
+    readonly closeCommentEditor: () => void;
+    readonly updateFilterRow: (columnId: string, value: string) => void;
+    readonly updateFilterOperator: (columnId: string, operator: FilterOperator) => void;
+    readonly updateFilterMenuValue: (columnId: string, value: string) => void;
+    readonly updateFilterMenuValueTo: (columnId: string, valueTo: string) => void;
+    readonly toggleCheckboxWithKeyboard: (event: KeyboardEvent, toggle: () => void) => void;
+    readonly getColumnAccessorValue: typeof getColumnAccessorValue;
+    readonly fallbackOperatorOption: import("./SvGrid.types").FilterOption;
+    readonly operatorOption: typeof operatorOption;
+    readonly operatorsForColumn: typeof operatorsForColumn;
+    readonly defaultOperatorFor: typeof defaultOperatorFor;
+    readonly operatorLabelFor: typeof operatorLabelFor;
+    readonly isColumnFiltered: (columnId: string) => boolean;
+    readonly closeMenus: () => void;
+    measureCanvas: HTMLCanvasElement | null;
+    readonly measureText: (text: string, font: string) => number;
+    readonly autosizeColumn: (columnId: string) => void;
+    readonly autosizeAllColumns: () => void;
+    readonly resetColumns: () => void;
+    readonly openChooseColumns: (event: MouseEvent) => void;
+    readonly openColumnMenu: (event: MouseEvent, columnId: string) => void;
+    readonly openFilterMenu: (event: MouseEvent, columnId: string) => void;
+    readonly openOperatorMenu: (event: MouseEvent, columnId: string) => void;
+    readonly sortColumnFromMenu: (columnId: string, desc: boolean) => void;
+    readonly clearColumnSort: (columnId: string) => void;
+    readonly groupByColumnFromMenu: (columnId: string) => void;
+    readonly clearGroupingFromMenu: (columnId: string) => void;
+    readonly isBucketableColumn: typeof isBucketableColumn;
+    readonly buildBuckets: typeof buildBuckets;
+    readonly isInBucket: typeof isInBucket;
+    readonly facetBucketsByColumn: Map<string, FacetBucket[]>;
+    readonly columnMenuFacetValues: string[];
+    readonly columnMenuVisibleFacets: string[];
+    readonly isFacetChecked: (columnId: string, value: string) => any;
+    readonly toggleFacetValue: (columnId: string, value: string) => void;
+    readonly isAllFacetsChecked: (columnId: string) => boolean;
+    readonly toggleAllFacets: (columnId: string) => void;
+    readonly clearColumnFilter: (columnId: string) => void;
+    readonly onWindowKeydown: (event: KeyboardEvent) => void;
+    readonly columnDefMatchesId: typeof columnDefMatchesId;
+    readonly buildApi: () => import("./svgrid-wrapper.types").SvGridApi<TFeatures, TData>;
+    apiNotified: boolean;
+};