lsp-grid 1.0.0

package/dist/types/store/dataSource/data.proxy.d.ts

@@ -0,0 +1,14 @@
+import { DSourceState } from "../index";
+import type { Observable, PluginSubscribe } from '../../utils';
+type State = DSourceState<any, any>;
+/**
+ * Todo:
+ * Refactor proxy plugin: when items changed outside proxy get recalculated
+ */
+/**
+ * Proxy plugin for data source.
+ *
+ * This plugin is used keep sortint in the data source, even when trimming is applied sorting has to be preserved.
+ */
+export declare const proxyPlugin: (store: Observable<State>) => PluginSubscribe<State>;
+export {};

package/dist/types/store/dataSource/data.store.d.ts

@@ -0,0 +1,74 @@
+import { Trimmed } from './trimmed.plugin';
+import { Observable } from '../../utils';
+import type { GroupLabelTemplateFunc } from '../../plugins/groupingRow/grouping.row.types';
+import type { DimensionRows, DimensionCols, ColumnProperties, ColumnGrouping, ColumnRegular, DataType, DataSourceState, ColumnProp } from "../../types/index";
+export interface Group extends ColumnProperties {
+    name: string;
+    children: (ColumnGrouping | ColumnRegular)[];
+    indexes: number[];
+}
+export type Groups = Record<number, Group[]>;
+export type GDataType = DataType | ColumnRegular;
+export type GDimension = DimensionRows | DimensionCols;
+export type DSourceState<T1 extends GDataType, T2 extends GDimension> = DataSourceState<T1, T2> & {
+    groupingCustomRenderer?: GroupLabelTemplateFunc | null;
+};
+/**
+ * Data store
+ * Manage the state of a data source and provide methods for updating, adding, and refreshing the data.
+ */
+export declare class DataStore<T extends GDataType, ST extends GDimension> {
+    private readonly dataStore;
+    get store(): Observable<DSourceState<T, ST>>;
+    constructor(type: ST, storeData?: DSourceState<T, ST>);
+    /**
+     * full data source update
+     * @param source - data column/rgRow source
+     * @param grouping - grouping information if present
+     */
+    updateData(source: T[], grouping?: {
+        depth: number;
+        groups?: Groups;
+        customRenderer?: GroupLabelTemplateFunc;
+    }, silent?: boolean): void;
+    addTrimmed(some: Partial<Trimmed>): void;
+    setSourceData(items: Record<number, any>, mutate?: boolean): void;
+    setData(input: Partial<DSourceState<T, ST>>): void;
+    refresh(): void;
+}
+/**
+ * get physical index by virtual
+ * @param store - store to process
+ */
+export declare function getPhysical(store: Observable<DSourceState<any, any>>, virtualIndex: number): number;
+/**
+ * get all visible items
+ * @param store - store to process
+ */
+export declare function getVisibleSourceItem(store: Observable<DSourceState<any, any>>): any[];
+/**
+ * get mapped item from source
+ * @param store - store to process
+ * @param virtualIndex - virtual index to process
+ */
+export declare const getSourceItem: <T1 extends GDataType, T2 extends GDimension>(store: Observable<DSourceState<T1, T2>>, virtualIndex: number) => T1;
+/**
+ * Get physical index from virtual index
+ */
+export declare const getSourcePhysicalIndex: <T1 extends GDataType, T2 extends GDimension>(store: Observable<DSourceState<T1, T2>>, virtualIndex: number) => number;
+/**
+ * Apply silently item/model/row value to data source
+ * @param store  - data source with changes
+ * @param modelByIndex - collection of rows/values with virtual indexes to setup/replace in store/data source
+ * @param mutate - if true, store will be mutated and whole viewport will be re-rendered
+ */
+export declare function setSourceByVirtualIndex<T extends GDataType>(store: Observable<DSourceState<T, any>>, modelByIndex: Record<number, T | undefined>, mutate?: boolean): void;
+/**
+ * set item to source
+ * @param store  - store to process
+ * @param modelByIndex - collection of rows with physical indexes to setup
+ * @param mutate - if true, store will be mutated and whole viewport will be re-rendered
+ */
+export declare function setSourceByPhysicalIndex<T extends GDataType>(store: Observable<DSourceState<T, any>>, modelByIndex: Record<number, T>, mutate?: boolean): void;
+export declare function setItems<T extends GDataType>(store: Observable<DSourceState<T, any>>, items: number[]): void;
+export declare function getSourceItemVirtualIndexByProp(store: Observable<DSourceState<any, any>>, prop: ColumnProp): number;

package/dist/types/store/dataSource/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data.proxy';
+export * from './data.store';
+export * from './trimmed.plugin';

package/dist/types/store/dataSource/trimmed.plugin.d.ts

@@ -0,0 +1,12 @@
+import { Observable, PluginSubscribe } from '../../utils';
+import { DSourceState, GDataType } from './data.store';
+export type TrimmedEntity = {
+    [physicalIndexInSource: number]: boolean;
+};
+export type Trimmed = Record<string, TrimmedEntity>;
+/**
+ * Hide items from main collection
+ * But keep them in store
+ */
+export declare const trimmedPlugin: <T extends GDataType>(store: Observable<DSourceState<T, any>>) => PluginSubscribe<DSourceState<T, any>>;
+export declare function gatherTrimmedItems(trimmedItems: Trimmed): TrimmedEntity;

package/dist/types/store/dimension/dimension.helpers.d.ts

@@ -0,0 +1,24 @@
+import type { DimensionSettingsState, PositionItem, ViewSettingSizeProp } from "../../types/index";
+export type DimensionPosition = Pick<DimensionSettingsState, 'indexes' | 'positionIndexes' | 'originItemSize' | 'positionIndexToItem'>;
+export type DimensionIndexInput = Pick<DimensionSettingsState, 'indexes' | 'originItemSize' | 'indexToItem'>;
+export type DimensionSize = Pick<DimensionSettingsState, 'indexes' | 'positionIndexes' | 'positionIndexToItem' | 'indexToItem' | 'realSize' | 'sizes'>;
+/**
+ * Pre-calculation
+ * Dimension custom sizes for each cell
+ * Keeps only changed sizes, skips origin size
+ */
+export declare function calculateDimensionData(originItemSize: number, newSizes?: ViewSettingSizeProp): {
+    indexes: number[];
+    positionIndexes: number[];
+    positionIndexToItem: {
+        [x: number]: PositionItem;
+    };
+    indexToItem: {
+        [index: number]: PositionItem;
+    };
+};
+/**
+ * Calculate item by position
+ */
+export declare const getItemByPosition: ({ indexes, positionIndexes, originItemSize, positionIndexToItem, }: Pick<DimensionPosition, "indexes" | "positionIndexes" | "originItemSize" | "positionIndexToItem">, pos: number) => PositionItem;
+export declare function getItemByIndex(dimension: Pick<DimensionIndexInput, 'indexToItem' | 'indexes' | 'originItemSize'>, index: number): PositionItem;

package/dist/types/store/dimension/dimension.recalculate.plugin.d.ts

@@ -0,0 +1,9 @@
+import { DimensionSettingsState } from "../../types/index";
+import type { Observable, PluginSubscribe } from '../../utils';
+/**
+ * Plugin which recalculates realSize on changes of sizes, originItemSize and count
+ */
+export declare const recalculateRealSizePlugin: (storeService: {
+    store: Observable<DimensionSettingsState>;
+    setStore: (k: Partial<DimensionSettingsState>) => void;
+}) => PluginSubscribe<DimensionSettingsState>;

package/dist/types/store/dimension/dimension.store.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from '../../utils';
+import { DimensionSettingsState, ViewSettingSizeProp, MultiDimensionType } from "../../types/index";
+export type DimensionStoreCollection = {
+    [T in MultiDimensionType]: DimensionStore;
+};
+export declare class DimensionStore {
+    readonly type: MultiDimensionType;
+    readonly store: Observable<DimensionSettingsState>;
+    constructor(type: MultiDimensionType);
+    getCurrentState(): DimensionSettingsState;
+    dispose(): void;
+    setStore<T extends Record<string, any>>(data: Partial<T>): void;
+    drop(): void;
+    /**
+     * Set custom dimension sizes and overwrite old
+     * Generates new indexes based on sizes
+     * @param sizes - sizes to set
+     */
+    setDimensionSize(sizes?: ViewSettingSizeProp): void;
+    updateSizesPositionByIndexes(newItemsOrder: number[], prevItemsOrder?: number[]): void;
+}

package/dist/types/store/dimension/dimension.trim.plugin.d.ts

@@ -0,0 +1,13 @@
+import { DimensionSettingsState } from "../../types/index";
+import type { Observable, PluginSubscribe } from '../../utils';
+/**
+ * Plugin for trimming
+ *
+ * 1.a. Retrieves the previous sizes value. Saves the resulting trimmed data as a new sizes value.
+ * 1.b. Stores a reference to the trimmed data to prevent further changes.
+ * 2. Removes multiple and shifts the data based on the trimmed value.
+ */
+export declare const trimmedPlugin: (storeService: {
+    store: Observable<DimensionSettingsState>;
+    setSizes: (k: DimensionSettingsState["sizes"]) => void;
+}) => PluginSubscribe<DimensionSettingsState>;

package/dist/types/store/dimension/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dimension.store';
+export * from './dimension.helpers';

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

@@ -0,0 +1,8 @@
+import type { DimensionCols, DimensionRows } from "../types/index";
+export * from './dataSource';
+export * from './dimension';
+export * from './selection';
+export * from './vp';
+export declare const rowTypes: DimensionRows[];
+export declare const columnTypes: DimensionCols[];
+export declare function isRowType(type: DimensionRows | any): type is DimensionRows;

package/dist/types/store/selection/index.d.ts

@@ -0,0 +1,2 @@
+export * from './selection.store';
+export * from './selection.helpers';

package/dist/types/store/selection/selection.helpers.d.ts

@@ -0,0 +1,6 @@
+import { Cell, RangeArea } from "../../types/index";
+export declare function isHiddenStore(pos: number): pos is -1;
+export declare function nextCell(cell: Cell, lastCell: Cell): Partial<Cell> | null;
+export declare function cropCellToMax(cell: Cell, lastCell: Cell): Cell;
+export declare function getRange(start?: Cell | null, end?: Cell | null): RangeArea | null;
+export declare function isRangeSingleCell(a: RangeArea): boolean;

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

@@ -0,0 +1,22 @@
+/**
+ * Selection store
+ */
+import { Observable } from '../../utils';
+import type { SelectionStoreState, Cell, TempRange, RangeArea, Nullable } from "../../types/index";
+export declare class SelectionStore {
+    readonly store: Observable<SelectionStoreState>;
+    private unsubscribe;
+    constructor();
+    onChange<Key extends keyof SelectionStoreState>(propName: Key, cb: (newValue: SelectionStoreState[Key]) => void): void;
+    clearFocus(): void;
+    setFocus(focus: Cell, end?: Cell): void;
+    setNextFocus(focus: Cell): void;
+    setTempArea(range: Nullable<TempRange> | null): void;
+    clearTemp(): void;
+    /** Can be applied from selection change or from simple keyboard change clicks */
+    setRangeArea(range: RangeArea | null): void;
+    setRange(start: Cell, end: Cell): void;
+    setLastCell(lastCell: Cell): void;
+    setEdit(val?: string | boolean): void;
+    dispose(): void;
+}

package/dist/types/store/vp/index.d.ts

@@ -0,0 +1,7 @@
+import { MultiDimensionType } from "../../types/index";
+import { ViewportStore } from './viewport.store';
+export * from './viewport.store';
+export * from './viewport.helpers';
+export type ViewportStoreCollection = {
+    [T in MultiDimensionType]: ViewportStore;
+};

package/dist/types/store/vp/viewport.helpers.d.ts

@@ -0,0 +1,54 @@
+import type { DimensionSettingsState, PositionItem, ViewSettingSizeProp, ViewportStateItems, VirtualPositionItem, Range } from "../../types/index";
+export type DimensionDataViewport = Pick<DimensionSettingsState, 'indexes' | 'positionIndexes' | 'positionIndexToItem' | 'sizes' | 'originItemSize' | 'realSize'>;
+export type ItemsToUpdate = Pick<ViewportStateItems, 'items' | 'start' | 'end'>;
+/**
+ * Update items based on new scroll position
+ * If viewport wasn't changed fully simple recombination of positions
+ * Otherwise rebuild viewport items
+ */
+export declare function getUpdatedItemsByPosition<T extends ItemsToUpdate>(pos: number, // coordinate
+items: T, realCount: number, virtualSize: number, dimension: DimensionDataViewport): ItemsToUpdate;
+export declare function updateMissingAndRange(items: VirtualPositionItem[], missing: VirtualPositionItem[], range: Range): void;
+/**
+ * If partial replacement
+ * this function adds items if viewport has some space left
+ */
+export declare function addMissingItems<T extends ItemsToUpdate>(firstItem: PositionItem, realCount: number, virtualSize: number, existingCollection: T, dimension: Pick<DimensionSettingsState, 'sizes' | 'originItemSize'>): VirtualPositionItem[];
+/**
+ * Get wiewport items parameters
+ * caching position and calculating items count in viewport
+ */
+export declare function getItems(opt: {
+    firstItemIndex: number;
+    firstItemStart: number;
+    origSize: number;
+    maxSize: number;
+    maxCount: number;
+    sizes?: ViewSettingSizeProp;
+}, currentSize?: number): VirtualPositionItem[];
+/**
+ * Do batch items recombination
+ * If items not overlapped with existing viewport returns null
+ */
+type RecombindDimensionData = Pick<DimensionSettingsState, 'sizes' | 'realSize' | 'originItemSize'>;
+type RecombineOffsetData = {
+    positiveDirection: boolean;
+} & ItemsToUpdate & RecombindDimensionData;
+export declare function recombineByOffset(offset: number, data: RecombineOffsetData): ItemsToUpdate | undefined;
+/**
+ * Verify if position is in range of the PositionItem, start and end are included
+ */
+export declare function isActiveRange(pos: number, realSize: number, first?: PositionItem, last?: PositionItem): boolean;
+export declare function isActiveRangeOutsideLastItem(pos: number, virtualSize: number, firstItem?: PositionItem, lastItem?: PositionItem): boolean;
+export declare function getFirstItem(s: ItemsToUpdate): VirtualPositionItem;
+export declare function getLastItem(s: ItemsToUpdate): VirtualPositionItem;
+/**
+ * Set items sizes from start index to end
+ * @param vpItems
+ * @param start
+ * @param size
+ * @param lastCoordinate
+ * @returns
+ */
+export declare function setItemSizes(vpItems: VirtualPositionItem[], initialIndex: number, size: number, lastCoordinate: number): VirtualPositionItem[];
+export {};

package/dist/types/store/vp/viewport.store.d.ts

@@ -0,0 +1,26 @@
+import { DimensionDataViewport, ItemsToUpdate } from './viewport.helpers';
+import { type Observable } from '../../utils';
+import type { ViewportState, MultiDimensionType } from "../../types/index";
+/**
+ * Viewport store class
+ */
+export declare class ViewportStore {
+    readonly type: MultiDimensionType;
+    readonly store: Observable<ViewportState>;
+    private lastKnownScroll;
+    get lastCoordinate(): number;
+    set lastCoordinate(value: number);
+    constructor(type: MultiDimensionType);
+    /**
+     * Render viewport based on coordinate
+     * It's the main method for draw
+     * Use force if you want to re-render viewport
+     */
+    setViewPortCoordinate(position: number, dimension: DimensionDataViewport, force?: boolean): void;
+    /**
+     * Set sizes for existing items
+     */
+    setOriginalSizes(size: number): void;
+    getItems(): ItemsToUpdate;
+    setViewport(data: Partial<ViewportState>): void;
+}

package/dist/types/themeManager/theme.compact.d.ts

@@ -0,0 +1,4 @@
+import { ThemePackage } from '../types/theme';
+export declare class ThemeCompact implements ThemePackage {
+    defaultRowSize: number;
+}

package/dist/types/themeManager/theme.default.d.ts

@@ -0,0 +1,4 @@
+import { ThemePackage } from '../types/theme';
+export declare class ThemeDefault implements ThemePackage {
+    defaultRowSize: number;
+}

package/dist/types/themeManager/theme.material.d.ts

@@ -0,0 +1,4 @@
+import { ThemePackage } from '../types/theme';
+export declare class ThemeMaterial implements ThemePackage {
+    defaultRowSize: number;
+}

package/dist/types/themeManager/theme.service.d.ts

@@ -0,0 +1,13 @@
+import type { Theme, ThemeConfig, ThemePackage } from '../types/theme';
+export declare const DEFAULT_THEME = "default";
+export declare const allowedThemes: Theme[];
+export default class ThemeService {
+    private currentTheme;
+    private customRowSize;
+    get theme(): ThemePackage;
+    get rowSize(): number;
+    set rowSize(size: number);
+    constructor(cfg: ThemeConfig);
+    register(theme: Theme): void;
+}
+export declare function getTheme(theme?: string | null): Theme;

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

@@ -0,0 +1,8 @@
+export type DimensionTypeRow = 'rgRow';
+export type DimensionTypeCol = 'rgCol';
+export type DimensionColPin = 'colPinStart' | 'colPinEnd';
+export type DimensionRowPin = 'rowPinStart' | 'rowPinEnd';
+export type DimensionType = DimensionTypeCol | DimensionTypeRow;
+export type DimensionCols = DimensionColPin | DimensionTypeCol;
+export type DimensionRows = DimensionTypeRow | DimensionRowPin;
+export type MultiDimensionType = DimensionCols | DimensionRows;

package/dist/types/types/events.d.ts

@@ -0,0 +1,2 @@
+export type RevogridEvents = 'contentsizechanged' | 'beforeedit' | 'beforerangeedit' | 'afteredit' | 'beforeautofill' | 'beforerange' | 'afterfocus' | 'roworderchanged' | 'beforesorting' | 'beforesourcesortingapply' | 'beforesortingapply' | 'rowdragstart' | 'headerclick' | 'beforecellfocus' | 'beforefocuslost' | 'beforesourceset' | 'beforeanysource' | 'aftersourceset' | 'afteranysource' | 'beforecolumnsset' | 'beforecolumnapplied' | 'aftercolumnsset' | 'beforefilterapply' | 'beforefiltertrimmed' | 'beforetrimmed' | 'aftertrimmed' | 'viewportscroll' | 'beforeexport' | 'beforeeditstart' | 'afterrollback' | 'aftermouseup' | 'aftercolumnresize' | 'beforerowdefinition' | 'filterconfigchanged' | 'sortingconfigchanged' | 'rowheaderschanged' | 'beforegridrender' | 'aftergridrender' | 'aftergridinit' | 'beforecolumndrag' | 'additionaldatachanged' | 'afterthemechanged' | 'created' | 'beforepaste' | 'beforepasteapply' | 'pasteregion' | 'afterpasteapply' | 'beforecut' | 'clearregion' | 'beforecopy' | 'beforecopyapply' | 'copyregion' | 'beforerowrender' | 'afterrender' | 'beforecellrender' | 'beforedatarender' | 'dragstartcell' | 'celleditinit' | 'closeedit' | 'filterChange' | 'resetChange' | 'beforefocusrender' | 'beforescrollintoview' | 'afterfocus' | 'beforeheaderclick' | 'headerresize' | 'beforeheaderresize' | 'headerdblclick' | 'beforeheaderrender' | 'beforegroupheaderrender' | 'afterheaderrender' | 'rowdragstartinit' | 'rowdragendinit' | 'rowdragmoveinit' | 'rowdragmousemove' | 'rowdropinit' | 'roworderchange' | 'beforecopyregion' | 'beforepasteregion' | 'celleditapply' | 'beforecellfocusinit' | 'beforenextvpfocus' | 'setedit' | 'beforeapplyrange' | 'beforesetrange' | 'setrange' | 'beforeeditrender' | 'selectall' | 'canceledit' | 'rollback' | 'settemprange' | 'beforesettemprange' | 'applyfocus' | 'focuscell' | 'beforerangedataapply' | 'selectionchangeinit' | 'beforerangecopyapply' | 'rangeeditapply' | 'clipboardrangecopy' | 'clipboardrangepaste' | 'beforekeydown' | 'beforekeyup' | 'beforecellsave' | 'celledit' | 'scrollview' | 'ref' | 'scrollvirtual' | 'scrollviewport' | 'resizeviewport' | 'scrollchange' | 'scrollviewportsilent' | 'html';
+export declare const REVOGRID_EVENTS: Map<RevogridEvents, RevogridEvents>;

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

@@ -0,0 +1,8 @@
+export * from './dimension';
+export * from './interfaces';
+export * from './selection';
+export * from './theme';
+export * from './plugin';
+export * from './plugin.types';
+export * from './viewport.interfaces';
+export * from './events';