lsp-grid 1.0.0

package/dist/types/plugins/groupingRow/grouping.row.types.d.ts

@@ -0,0 +1,103 @@
+import type { VNode } from '../../stencil-public-runtime';
+import type { HyperFunc, ColumnProp, DimensionRows, DataType, Providers, VirtualPositionItem, PositionItem, DimensionCols } from "../../types/index";
+import type { RowProps } from '../../components/data/row-renderer';
+import { GROUP_EXPAND_EVENT } from './grouping.const';
+/**
+ * Properties for the grouping row template
+ */
+interface GroupTemplateProp {
+    /**
+     * Name of the grouping row
+     */
+    name: string;
+    /**
+     * Index of the grouping row
+     */
+    itemIndex: number;
+    /**
+     * Expanded state of the grouping row
+     */
+    expanded: boolean;
+    /**
+     * Depth of the grouping row
+     */
+    depth: number;
+    /**
+     * Providers for the grid
+     */
+    providers: Providers;
+    /**
+     * Dimension type (e.g. rgCol, colPinStart, colPinEnd, rowHeaders)
+     */
+    colType: DimensionCols | 'rowHeaders';
+    /**
+     * Model of the grouping row
+     */
+    model?: DataType;
+}
+export type RowGroupingProps = GroupRowPros & PositionItem & {
+    /**
+     * Visible columns in the grid, can be used to get the width of the column and position of the column
+     * to calculate the position of the cells in the grouping row
+     */
+    columnItems: VirtualPositionItem[];
+};
+export interface GroupRowPros extends RowProps {
+    model: DataType;
+    hasExpand: boolean;
+    providers: Providers;
+    groupingCustomRenderer?: GroupLabelTemplateFunc | null;
+}
+export type GroupLabelTemplateFunc = (createElement: HyperFunc<VNode>, props: GroupTemplateProp & RowGroupingProps, ...args: any[]) => any;
+export type GroupingOptions = {
+    /**
+     * Column props to which grouping will be applied
+     */
+    props?: ColumnProp[];
+    /**
+     * Should grouping be preserved on source update.
+     * default: true
+     */
+    preserveGroupingOnUpdate?: boolean;
+    /**
+     * Custom group label template
+     */
+    groupLabelTemplate?: GroupLabelTemplateFunc;
+} & ExpandedOptions;
+export type BeforeSourceSetEvent = {
+    type: DimensionRows;
+    source: DataType[];
+};
+export type OnExpandEvent = {
+    model: DataType;
+    virtualIndex: number;
+};
+export type ExpandedOptions = {
+    /**
+     * Currently expanded items. to set expanded: '{ 'a': true, 'a,b': true, 'a,b,c': true }'
+     */
+    prevExpanded?: Record<string, boolean>;
+    /**
+     * Is expanded by default
+     */
+    expandedAll?: boolean;
+    /**
+     * Custom group label value parser
+     */
+    getGroupValue?(item: DataType, prop: string | number): any;
+    /**
+     * Custom group label template
+     */
+    groupLabelTemplate?: GroupLabelTemplateFunc;
+};
+declare global {
+    /**
+     * grid.addEventListener(GROUP_EXPAND_EVENT, (e: OnExpandEvent) => {
+     *  console.log(e)
+     * })
+     */
+    interface HTMLRevoGridElementEventMap {
+        [GROUP_EXPAND_EVENT]: OnExpandEvent;
+    }
+}
+export {};

package/dist/types/plugins/groupingRow/grouping.service.d.ts

@@ -0,0 +1,36 @@
+import type { DataType, ColumnProp, ColumnRegular } from "../../types/index";
+import { GROUP_DEPTH, GROUP_EXPANDED, PSEUDO_GROUP_ITEM, PSEUDO_GROUP_ITEM_VALUE, GROUP_COLUMN_PROP } from './grouping.const';
+import type { ExpandedOptions } from './grouping.row.types';
+type SourceGather = {
+    source: DataType[];
+    prevExpanded: Record<string, boolean>;
+    oldNewIndexes?: Record<number, number>;
+};
+export declare function getSource(source: DataType[], items: number[], withoutGrouping?: boolean): Required<SourceGather>;
+export declare function getExpanded(model?: DataType): any;
+/**
+ * Gather data for grouping
+ * @param array - flat data array
+ * @param columnProps - ids of groups
+ * @param expanded - potentially expanded items if present
+ */
+export declare function gatherGrouping(array: DataType[], columnProps: ColumnProp[], { prevExpanded, expandedAll, getGroupValue, }: ExpandedOptions): {
+    sourceWithGroups: DataType[];
+    depth: number;
+    trimmed: Record<number, boolean>;
+    oldNewIndexMap: Record<number, number>;
+};
+export declare function getGroupingName(rgRow?: DataType): any;
+type GroupingItem = {
+    [PSEUDO_GROUP_ITEM]: string;
+    [GROUP_EXPANDED]: boolean;
+    [PSEUDO_GROUP_ITEM_VALUE]: string;
+    [GROUP_DEPTH]: number;
+    [GROUP_COLUMN_PROP]: ColumnProp;
+};
+export declare function isGrouping(rgRow?: DataType): rgRow is GroupingItem;
+export declare function isGroupingColumn(column?: ColumnRegular): boolean;
+export declare function measureEqualDepth<T>(groupA: T[], groupB: T[]): number;
+export declare function getParsedGroup(id: string): any[] | null;
+export declare function isSameGroup(currentGroup: any[], currentModel: DataType, nextModel: DataType): boolean;
+export {};

package/dist/types/plugins/groupingRow/grouping.trimmed.service.d.ts

@@ -0,0 +1,10 @@
+import { Trimmed, TrimmedEntity } from "../../store/index";
+export declare const TRIMMED_GROUPING = "grouping";
+/**
+ * Prepare trimming updated indexes for grouping
+ * @param initiallyTrimed
+ * @param firstLevelMap
+ * @param secondLevelMap
+ */
+export declare function processDoubleConversionTrimmed(initiallyTrimed: Trimmed, firstLevelMap: Record<number, number>, secondLevelMap?: Record<number, number>): Trimmed;
+export declare function filterOutEmptyGroups(allTrimmedGroups: Trimmed, childrenByGroup?: Record<number, number[]>): TrimmedEntity;

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,11 @@
+export * from './base.plugin';
+export * from './column.auto-size.plugin';
+export * from './column.stretch.plugin';
+export * from './dispatcher';
+export * from './export/export.plugin';
+export * from './filter/filter.plugin';
+export * from './groupingRow/grouping.row.plugin';
+export * from './moveColumn/column.drag.plugin';
+export * from './sorting/sorting.plugin';
+export * from './sorting/sorting.sign';
+export * from './add-rows-on-paste.plugin';

package/dist/types/plugins/moveColumn/column.drag.plugin.d.ts

@@ -0,0 +1,42 @@
+import { BasePlugin } from '../base.plugin';
+import type { ColumnPropProp, DimensionCols, PluginProviders } from "../../types/index";
+export type DragStartEventDetails = {
+    event: MouseEvent;
+    data: ColumnPropProp;
+};
+type LocalSubscriptions = Record<string, LocalSubscription>;
+type LocalSubscription = {
+    target: Element | Document;
+    callback(...params: any[]): void;
+};
+export type ColumnDragEventData = {
+    elRect: DOMRect;
+    gridRect: DOMRect;
+    scrollOffset: number;
+    type: DimensionCols;
+};
+export declare class ColumnMovePlugin extends BasePlugin {
+    revogrid: HTMLRevoGridElement;
+    providers: PluginProviders;
+    private moveFunc;
+    private staticDragData;
+    private dragData;
+    private readonly orderUi;
+    protected readonly localSubscriptions: LocalSubscriptions;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    dragStart({ event, data }: DragStartEventDetails): void;
+    doMove(e: MouseEvent): void;
+    move(e: MouseEvent): void;
+    onMouseOut(_: MouseEvent): void;
+    onMouseUp(e: MouseEvent): void;
+    private clearLocalSubscriptions;
+    clearOrder(): void;
+    /**
+     * Clearing subscription
+     */
+    clearSubscriptions(): void;
+    private getData;
+    private getDimension;
+}
+export declare function getLeftRelative(absoluteX: number, gridPos: number, offset: number): number;
+export {};

package/dist/types/plugins/moveColumn/order-column.handler.d.ts

@@ -0,0 +1,16 @@
+export declare class ColumnOrderHandler {
+    private element?;
+    private autoscrollEl?;
+    private offset;
+    renderAutoscroll(_: MouseEvent, parent: HTMLElement | null): void;
+    autoscroll(pos: number, dataContainerSize: number, direction?: string): void;
+    start(e: MouseEvent, { dataEl, gridRect, scrollEl, gridEl, }: {
+        dataEl: HTMLElement;
+        gridRect: DOMRect;
+        scrollEl: Element;
+        gridEl: Element;
+    }, dir?: 'top' | 'left'): void;
+    stop(gridEl: Element): void;
+    showHandler(pos: number, size: number, columnWidth: number, direction?: string): void;
+    render(): HTMLDivElement;
+}

package/dist/types/plugins/rtl/rtl.plugin.d.ts

@@ -0,0 +1,37 @@
+import { BasePlugin } from '../base.plugin';
+import type { PluginProviders } from "../../types/index";
+/**
+ * RTL (Right-to-Left) Plugin for RevoGrid
+ *
+ * This plugin handles RTL transformation by subscribing to the beforecolumnsset event
+ * and applying column order reversal when RTL mode is enabled.
+ */
+export declare class RTLPlugin extends BasePlugin {
+    private isRTLEnabled;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    private init;
+    /**
+     * Handle the beforecolumnsset event to apply RTL transformation
+     */
+    private handleBeforeColumnsSet;
+    /**
+     * Apply RTL transformation to the entire column collection
+     */
+    private applyRTLTransformationToCollection;
+    /**
+     * Apply RTL transformation to column groups
+     */
+    private applyRTLTransformationToGroups;
+    /**
+     * Update RTL state based on the grid's rtl property
+     */
+    private updateRTLState;
+    /**
+     * Get current RTL state
+     */
+    getRTLState(): boolean;
+    /**
+     * Clean up the plugin
+     */
+    destroy(): void;
+}

package/dist/types/plugins/sorting/sorting.func.d.ts

@@ -0,0 +1,9 @@
+import type { CellCompareFunc, ColumnProp, ColumnRegular, DataType, Order } from "../../types/index";
+import type { SortingOrderFunction } from './sorting.types';
+export declare function sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction): number[];
+export declare function defaultCellCompare(this: {
+    column?: ColumnRegular;
+}, prop: ColumnProp, a: DataType, b: DataType): 0 | 1 | -1;
+export declare function descCellCompare(cmp: CellCompareFunc): (prop: ColumnProp, a: DataType, b: DataType) => number;
+export declare function getNextOrder(currentOrder: Order): Order;
+export declare function getComparer(column: Partial<ColumnRegular> | undefined, order: Order): CellCompareFunc | undefined;

package/dist/types/plugins/sorting/sorting.plugin.d.ts

@@ -0,0 +1,48 @@
+import { BasePlugin } from '../base.plugin';
+import type { ColumnRegular, DimensionRows, PluginProviders } from "../../types/index";
+import type { SortingConfig, SortingOrder, SortingOrderFunction } from './sorting.types';
+export * from './sorting.types';
+export * from './sorting.func';
+export * from './sorting.sign';
+/**
+ * Lifecycle
+ * 1. @event `beforesorting` - Triggered when sorting just starts. Nothing has happened yet. This can be triggered from a column or from the source. If the type is from rows, the column will be undefined.
+ * 2. @event `beforesourcesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted.
+ * 3. @event `beforesortingapply` - Triggered before the sorting data is applied to the data source. You can prevent this event, and the data will not be sorted. This event is only called from a column sorting click.
+ * 4. @event `aftersortingapply` - Triggered after sorting has been applied and completed. This event occurs for both row and column sorting.
+ *
+ * Note: If you prevent an event, it will not proceed to the subsequent steps.
+ */
+export declare class SortingPlugin extends BasePlugin {
+    revogrid: HTMLRevoGridElement;
+    sorting?: SortingOrder;
+    sortingFunc?: SortingOrderFunction;
+    /**
+     * Delayed sorting promise
+     */
+    sortingPromise: (() => void) | null;
+    /**
+     * We need to sort only so often
+     */
+    postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean) => void>;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: SortingConfig);
+    /**
+     * Entry point for sorting, waits for all delayes, registers jobs
+     */
+    startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    /**
+     * Apply sorting to data on header click
+     * If additive - add to existing sorting, multiple columns can be sorted
+     */
+    headerclick(column: ColumnRegular, additive: boolean): void;
+    runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    /**
+     * Sort items by sorting function
+     * @requires proxyItems applied to row store
+     * @requires source applied to row store
+     *
+     * @param sorting - per column sorting
+     * @param data - this.stores['rgRow'].store.get('source')
+     */
+    sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, types?: DimensionRows[], ignoreViewportUpdate?: boolean): void;
+}

package/dist/types/plugins/sorting/sorting.sign.d.ts

@@ -0,0 +1,6 @@
+import { ColumnRegular } from "../../types/index";
+type Props = {
+    column: ColumnRegular;
+};
+export declare const SortingSign: ({ column }: Props) => any;
+export {};

package/dist/types/plugins/sorting/sorting.types.d.ts

@@ -0,0 +1,14 @@
+import type { CellCompareFunc, ColumnProp, Order } from "../../types/index";
+export type SortingOrder = Record<ColumnProp, Order>;
+export type SortingOrderFunction = Record<ColumnProp, CellCompareFunc | undefined>;
+export type ColumnSetEvent = {
+    order: SortingOrder;
+};
+export type SortingConfig = {
+    columns?: {
+        prop: ColumnProp;
+        order: Order;
+        cellCompare?: CellCompareFunc;
+    }[];
+    additive?: boolean;
+};

package/dist/types/plugins/wcag/index.d.ts

@@ -0,0 +1,26 @@
+import { PluginProviders } from "../../types/index";
+import { BasePlugin } from '../base.plugin';
+/**
+ * WCAG Plugin is responsible for enhancing the accessibility features of the RevoGrid component.
+ * It ensures that the grid is fully compliant with Web Content Accessibility Guidelines (WCAG) 2.1.
+ * This plugin should be the last plugin you add, as it modifies the grid's default behavior.
+ *
+ * The WCAG Plugin performs the following tasks:
+ * - Sets the 'dir' attribute to 'ltr' for left-to-right text direction.
+ * - Sets the 'role' attribute to 'treegrid' for treelike hierarchical structure.
+ * - Sets the 'aria-keyshortcuts' attribute to 'Enter' and 'Esc' for keyboard shortcuts.
+ * - Adds event listeners for keyboard navigation and editing.
+ *
+ * By default, the plugin adds ARIA roles and properties to the grid elements, providing semantic information
+ * for assistive technologies. These roles include 'grid', 'row', and 'gridcell'. The plugin also sets
+ * ARIA attributes such as 'aria-rowindex', 'aria-colindex', and 'aria-selected'.
+ *
+ * The WCAG Plugin ensures that the grid is fully functional and usable for users with various disabilities,
+ * including visual impairments, deaf-blindness, and cognitive disabilities.
+ *
+ * Note: The WCAG Plugin should be added as the last plugin in the list of plugins, as it modifies the grid's
+ * default behavior and may conflict with other plugins if added earlier.
+ */
+export declare class WCAGPlugin extends BasePlugin {
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+}

package/dist/types/services/cell.helpers.d.ts

@@ -0,0 +1,2 @@
+import type { Cell } from "../types/index";
+export declare function getCell(cell: HTMLElement): Cell;

package/dist/types/services/column.data.provider.d.ts

@@ -0,0 +1,27 @@
+import { DataStore } from "../store/index";
+import type { ColumnProp, ColumnRegular, DimensionCols } from "../types/index";
+import { ColumnCollection } from '../utils/column.utils';
+export type ColumnDataSources = Record<DimensionCols, DataStore<ColumnRegular, DimensionCols>>;
+export default class ColumnDataProvider {
+    readonly dataSources: ColumnDataSources;
+    collection: ColumnCollection | null;
+    get stores(): ColumnDataSources;
+    constructor();
+    column(c: number, type?: DimensionCols): ColumnRegular | undefined;
+    getColumn(virtualIndex: number, type: DimensionCols): ColumnRegular | undefined;
+    getRawColumns(): Record<DimensionCols, ColumnRegular[]>;
+    getColumns(type?: DimensionCols | 'all'): ColumnRegular[];
+    getColumnIndexByProp(prop: ColumnProp, type: DimensionCols): number;
+    getColumnByProp(prop: ColumnProp): ColumnRegular[] | undefined;
+    refreshByType(type: DimensionCols): void;
+    /**
+     * Main method to set columns
+     */
+    setColumns(data: ColumnCollection): ColumnCollection;
+    /**
+     * Used in plugins
+     * Modify columns in store
+     */
+    updateColumns(updatedColumns: ColumnRegular[]): void;
+    updateColumn(column: ColumnRegular, index: number): void;
+}

package/dist/types/services/data.provider.d.ts

@@ -0,0 +1,36 @@
+import { DataStore, Groups, Trimmed } from "../store/index";
+import DimensionProvider from './dimension.provider';
+import type { GroupLabelTemplateFunc } from '../plugins/groupingRow/grouping.row.types';
+import type { DataLookup, DimensionRows, DataType, BeforeSaveDataDetails } from "../types/index";
+export type RowDataSources = {
+    [T in DimensionRows]: DataStore<DataType, DimensionRows>;
+};
+/**
+ * Data source provider
+ *
+ * @dependsOn DimensionProvider
+ */
+export declare class DataProvider {
+    private dimensionProvider;
+    readonly stores: RowDataSources;
+    constructor(dimensionProvider: DimensionProvider);
+    setData(data: DataType[], type?: DimensionRows, disableVirtualRows?: boolean, grouping?: {
+        depth: number;
+        groups?: Groups;
+        customRenderer?: GroupLabelTemplateFunc;
+    }, silent?: boolean): DataType[];
+    getModel(virtualIndex: number, type?: DimensionRows): DataType;
+    changeOrder({ rowType, from, to }: {
+        rowType: DimensionRows;
+        from: number;
+        to: number;
+    }): void;
+    setCellData({ type, rowIndex, prop, val }: Pick<BeforeSaveDataDetails, 'type' | 'rowIndex' | 'prop' | 'val'>, mutate?: boolean): void;
+    setRangeData(data: DataLookup, type: DimensionRows): void;
+    refresh(type?: DimensionRows | 'all'): void;
+    refreshItems(type?: DimensionRows): void;
+    setGrouping({ depth }: {
+        depth: number;
+    }, type?: DimensionRows): void;
+    setTrimmed(trimmed: Trimmed, type?: DimensionRows): void;
+}

package/dist/types/services/dimension.provider.d.ts

@@ -0,0 +1,66 @@
+import ViewportProvider from './viewport.provider';
+import { DimensionStoreCollection, Trimmed } from "../store/index";
+import type { DimensionCols, DimensionType, MultiDimensionType, ColumnRegular, DimensionSettingsState, ViewPortScrollEvent, ViewSettingSizeProp } from "../types/index";
+export type DimensionConfig = {
+    realSizeChanged(k: MultiDimensionType): void;
+};
+/**
+ * Dimension provider
+ * Stores dimension information and custom sizes
+ *
+ * @dependsOn ViewportProvider
+ */
+export default class DimensionProvider {
+    private viewports;
+    readonly stores: DimensionStoreCollection;
+    constructor(viewports: ViewportProvider, config: DimensionConfig);
+    /**
+     * Clear old sizes from dimension and viewports
+     * @param type - dimension type
+     * @param count - count of items
+     */
+    clearSize(t: MultiDimensionType, count: number): void;
+    /**
+     * Apply new custom sizes to dimension and view port
+     * @param type - dimension type
+     * @param sizes - new custom sizes
+     * @param keepOld - keep old sizes merge new with old
+     */
+    setCustomSizes(type: MultiDimensionType, sizes: ViewSettingSizeProp, keepOld?: boolean): void;
+    setItemCount(realCount: number, type: MultiDimensionType): void;
+    /**
+     * Apply trimmed items
+     * @param trimmed - trimmed items
+     * @param type
+     */
+    setTrimmed(trimmed: Trimmed, type: MultiDimensionType): void;
+    /**
+     * Sets dimension data and viewport coordinate
+     * @param itemCount
+     * @param type - dimension type
+     * @param noVirtual - disable virtual data
+     */
+    setData(itemCount: number, type: MultiDimensionType, noVirtual?: boolean): void;
+    /**
+     * Applies new columns to the dimension provider
+     * @param columns - new columns data
+     * @param disableVirtualX - disable virtual data for X axis
+     */
+    applyNewColumns(columns: Record<DimensionCols, ColumnRegular[]>, disableVirtualX: boolean, keepOld?: boolean): void;
+    /**
+     * Gets the full size of the grid by summing up the sizes of all dimensions
+     * Goes through all dimensions columnTypes (x) and rowTypes (y) and sums up their sizes
+     */
+    getFullSize(): {
+        x: number;
+        y: number;
+    };
+    setViewPortCoordinate({ type, coordinate, force, }: {
+        coordinate?: number;
+        type: MultiDimensionType;
+        force?: boolean;
+    }): void;
+    getViewPortPos(e: ViewPortScrollEvent): number;
+    setSettings(data: Partial<DimensionSettingsState>, dimensionType: DimensionType): void;
+    updateSizesPositionByNewDataIndexes(type: MultiDimensionType, newItemsOrder: number[], prevItemsOrder?: number[]): void;
+}

package/dist/types/services/local.scroll.service.d.ts

@@ -0,0 +1,36 @@
+import type { DimensionType, ViewPortScrollEvent } from "../types/index";
+interface Config {
+    skipAnimationFrame?: boolean;
+    runScroll(e: ViewPortScrollEvent): void;
+    applyScroll(e: ViewPortScrollEvent): void;
+}
+type Params = {
+    contentSize: number;
+    virtualContentSize?: number;
+    clientSize: number;
+    virtualSize: number;
+    maxSize?: number;
+};
+/**
+ * Based on content size, client size and virtual size
+ * return full size
+ */
+export declare function getContentSize(contentSize: number, clientSize: number, virtualSize?: number): number;
+export default class LocalScrollService {
+    private cfg;
+    private preventArtificialScroll;
+    private previousScroll;
+    private params;
+    constructor(cfg: Config);
+    setParams(params: Params, dimension: DimensionType): void;
+    setScroll(e: ViewPortScrollEvent): Promise<void>;
+    /**
+     * On scroll event started
+     */
+    scroll(coordinate: number, dimension: DimensionType, force?: boolean, delta?: number, outside?: boolean): void;
+    private getParams;
+    private wrapCoordinate;
+    private cancelScroll;
+    private convert;
+}
+export {};

package/dist/types/services/local.scroll.timer.d.ts

@@ -0,0 +1,32 @@
+import type { DimensionType } from "../types/index";
+/**
+ * Apply changes only if mousewheel event happened some time ago (scrollThrottling)
+ */
+export declare class LocalScrollTimer {
+    private scrollThrottling;
+    /**
+     * Last mw event time for trigger scroll function below
+     * If mousewheel function was ignored we still need to trigger render
+     */
+    private mouseWheelScrollTimestamp;
+    private lastKnownScrollCoordinate;
+    constructor(scrollThrottling?: number);
+    setCoordinate(e: {
+        dimension: DimensionType;
+        coordinate: number;
+    }): void;
+    /**
+     * Remember last mw event time
+     */
+    latestScrollUpdate(dimension: DimensionType): void;
+    isReady(type: DimensionType, coordinate: number): boolean;
+    private verifyChange;
+    /**
+     * Check if scroll is ready to accept new value
+     * this is an edge case for scroll events
+     * when we need to apply scroll after throttling
+     */
+    private lastScrollUpdateCallbacks;
+    private clearLastScrollUpdate;
+    throttleLastScrollUpdate(type: DimensionType, coordinate: number, lastScrollUpdate: () => void): void;
+}

package/dist/types/services/selection.store.connector.d.ts

@@ -0,0 +1,79 @@
+import { SelectionStore } from "../store/index";
+import type { MultiDimensionType, DimensionCols, DimensionRows, Cell, EditCellStore, RangeArea } from "../types/index";
+type StoreByDimension = Record<number, SelectionStore>;
+type FocusedStore = {
+    entity: SelectionStore;
+    cell: Cell;
+    position: Cell;
+};
+type StoresMapping<T> = {
+    [xOrY: number]: Partial<T>;
+};
+export declare const EMPTY_INDEX = -1;
+export declare class SelectionStoreConnector {
+    private dirty;
+    readonly stores: {
+        [y: number]: {
+            [x: number]: SelectionStore;
+        };
+    };
+    readonly columnStores: StoreByDimension;
+    readonly rowStores: {
+        [y: number]: SelectionStore;
+    };
+    /**
+     * Helpers for data conversion
+     */
+    readonly storesByType: Partial<Record<MultiDimensionType, number>>;
+    readonly storesXToType: StoresMapping<DimensionCols>;
+    readonly storesYToType: StoresMapping<DimensionRows>;
+    get focusedStore(): FocusedStore | null;
+    get edit(): EditCellStore | null | undefined;
+    get focused(): Cell | null | undefined;
+    get selectedRange(): RangeArea | null | undefined;
+    private readonly sections;
+    registerSection(e?: Element): void;
+    beforeUpdate(): void;
+    registerColumn(x: number, type: DimensionCols): SelectionStore;
+    registerRow(y: number, type: DimensionRows): SelectionStore;
+    /**
+     * Cross store proxy, based on multiple dimensions
+     */
+    register({ x, y }: Cell): SelectionStore;
+    private destroy;
+    setEditByCell<T extends Cell>(storePos: T, editCell: T): void;
+    /**
+     * Sets the next focus cell before the current one.
+     *
+     * @param focus - The cell to set as the next focus.
+     */
+    beforeNextFocusCell(focus: Cell): void;
+    focusByCell<T extends Cell>(storePos: T, start: T, end: T): void;
+    focus(store: SelectionStore, { focus, end }: {
+        focus: Cell;
+        end: Cell;
+    }): Cell | null;
+    /**
+     * Retrieves the current store pointer based on the active store.
+     * Clears focus from all stores except the active one.
+     */
+    getCurrentStorePointer(store: SelectionStore): Cell | undefined;
+    /**
+     * Retrieves the next store based on the focus cell and current store pointer.
+     * If the next store exists, returns an object with the next store and the item in the new store.
+     * If the next store does not exist, returns null.
+     */
+    getNextStore(focus: Cell, currentStorePointer: Cell, lastCell: Cell): {
+        store: SelectionStore | undefined;
+        item: Partial<Cell> | null;
+    };
+    clearAll(): void;
+    setEdit(val?: string | boolean): void;
+    /**
+     * Select all cells across all stores
+     */
+    selectAll(): void;
+    private getXStores;
+    private getYStores;
+}
+export {};

package/dist/types/services/viewport.provider.d.ts

@@ -0,0 +1,7 @@
+import { type ViewportStoreCollection } from "../store/index";
+import type { MultiDimensionType, ViewportState } from "../types/index";
+export default class ViewportProvider {
+    readonly stores: ViewportStoreCollection;
+    constructor();
+    setViewport(type: MultiDimensionType, data: Partial<ViewportState>): void;
+}