@revolist/revogrid 4.0.2-next → 4.0.2

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

@@ -1,6 +1,6 @@
-import { Observable, PluginSubscribe } from '../../interfaces';
-import { DataSourceState } from '../../store/dataSource/data.store';
-declare type State = DataSourceState<any, any>;
+import { DSourceState } from '../../store/dataSource/data.store';
+import { Observable, PluginSubscribe } from '../..';
+type State = DSourceState<any, any>;
 /**
  * All items
  * Used as proxy for sorting

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

@@ -1,70 +1,69 @@
-import { Trimmed } from '../../plugins/trimmed/trimmed.plugin';
-import { Observable, RevoGrid } from '../../interfaces';
-import DataType = RevoGrid.DataType;
-import ColumnRegular = RevoGrid.ColumnRegular;
-import DimensionRows = RevoGrid.DimensionRows;
-import DimensionCols = RevoGrid.DimensionCols;
-export interface Group extends RevoGrid.ColumnProperties {
-  name: string;
-  children: RevoGrid.ColumnRegular[];
-  ids: (string | number)[];
+import { Trimmed } from './trimmed.plugin';
+import { GroupLabelTemplateFunc } from '../../plugins/groupingRow/grouping.row.types';
+import { DimensionRows, DimensionCols } from '../..';
+import { ColumnProperties, ColumnGrouping, ColumnRegular, DataType, DataSourceState, Observable, ColumnProp } from '../..';
+export interface Group extends ColumnProperties {
+    name: string;
+    children: (ColumnGrouping | ColumnRegular)[];
+    ids: (string | number)[];
 }
-export declare type Groups = Record<any, any>;
-export declare type GDataType = DataType | ColumnRegular;
-export declare type GDimension = DimensionRows | DimensionCols;
-export declare type DataSourceState<T extends GDataType, ST extends GDimension> = {
-  items: number[];
-  proxyItems: number[];
-  source: T[];
-  groupingDepth: number;
-  groups: Groups;
-  type: ST;
-  trimmed: Trimmed;
+export type Groups = Record<any, any>;
+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 default class DataStore<T extends GDataType, ST extends GDimension> {
-  private readonly dataStore;
-  get store(): Observable<DataSourceState<T, ST>>;
-  constructor(type: 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;
-  }, silent?: boolean): void;
-  addTrimmed(some: Partial<Trimmed>): void;
-  setData(input: Partial<DataSourceState<T, ST>>): void;
-  refresh(): void;
+    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;
+    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<DataSourceState<any, any>>, virtualIndex: number): number;
+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<DataSourceState<any, any>>): any[];
+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 function getSourceItem(store: Observable<DataSourceState<any, any>>, virtualIndex: number): any;
+export declare const getSourceItem: (store: Observable<DSourceState<any, any>>, virtualIndex: number) => any | undefined;
 /**
- * set item to source
- * @param store  - store to process
- * @param modelByIndex - collection of rows with virtual indexes to setup
+ * Apple 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>(store: Observable<DataSourceState<T, any>>, modelByIndex: Record<number, T>): void;
+export declare function setSourceByVirtualIndex<T>(store: Observable<DSourceState<T, any>>, modelByIndex: Record<number, T>, 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>(store: Observable<DataSourceState<T, any>>, modelByIndex: Record<number, T>): void;
-export declare function setItems<T>(store: Observable<DataSourceState<T, any>>, items: number[]): void;
-export declare function getSourceItemVirtualIndexByProp(store: Observable<DataSourceState<any, any>>, prop: RevoGrid.ColumnProp): number;
+export declare function setSourceByPhysicalIndex<T>(store: Observable<DSourceState<T, any>>, modelByIndex: Record<number, T>, mutate?: boolean): void;
+export declare function setItems<T>(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,10 @@
+import { Observable, PluginSubscribe } from '../..';
+import { DSourceState } from './data.store';
+export type TrimmedEntity = Record<number, boolean>;
+export type Trimmed = Record<string, TrimmedEntity>;
+/**
+ * Hide items from main collection
+ * But keep them in store
+ */
+export declare const trimmedPlugin: <T>(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

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

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

@@ -2,16 +2,34 @@
  * Storing pre-calculated
  * Dimension information and sizes
  */
-import { DimensionSize } from './dimension.helpers';
-import { Observable, RevoGrid } from '../../interfaces';
+import { DimensionSettingsState, Observable, ViewSettingSizeProp } from '../..';
+import { MultiDimensionType } from '../..';
+export type DimensionStoreCollection = {
+    [T in MultiDimensionType]: DimensionStore;
+};
 export default class DimensionStore {
-  readonly store: Observable<RevoGrid.DimensionSettingsState>;
-  constructor();
-  getCurrentState(): RevoGrid.DimensionSettingsState;
-  setRealSize(count: number): void;
-  setStore<T extends {
-    [key: string]: any;
-  }>(data: Partial<T>): void;
-  drop(): void;
-  setDimensionSize(sizes: RevoGrid.ViewSettingSizeProp): DimensionSize;
+    readonly store: Observable<DimensionSettingsState>;
+    constructor();
+    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): {
+        indexes: number[];
+        positionIndexes: number[];
+        positionIndexToItem: {
+            [x: number]: import("../..").PositionItem;
+        };
+        indexToItem: {
+            [index: number]: import("../..").PositionItem;
+        };
+        sizes: {
+            [x: string]: number;
+        };
+    };
 }

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

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

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

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

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

@@ -1,6 +1,4 @@
-import { Selection } from '../../interfaces';
-import Cell = Selection.Cell;
-import RangeArea = Selection.RangeArea;
+import { Cell, RangeArea } from '../..';
 export declare function isHiddenStore(pos: number): boolean;
 export declare function nextCell(cell: Cell, lastCell: Cell): Partial<Cell> | null;
 export declare function cropCellToMax(cell: Cell, lastCell: Cell): Cell;

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

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

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

@@ -1,18 +1,17 @@
-import { Edition, Observable, Selection } from '../../interfaces';
-import Cell = Selection.Cell;
-import Range = Selection.RangeArea;
+import { Observable } from '../..';
+import { Cell, SelectionStoreState, EditCellStore, RangeArea } from '../..';
 interface Config {
-  changeRange(range: Range): boolean;
-  focus(focus: Cell, end: Cell): boolean;
+    changeRange(range: RangeArea): boolean;
+    focus(focus: Cell, end: Cell): boolean;
 }
 export default class SelectionStoreService {
-  store: Observable<Selection.SelectionStoreState>;
-  private config;
-  constructor(store: Observable<Selection.SelectionStoreState>, config: Config);
-  get edited(): Edition.EditCellStore | null;
-  get focused(): Cell | null;
-  get ranged(): Range | null;
-  changeRange(range: Range): boolean;
-  focus(cell?: Cell, isMulti?: boolean): boolean;
+    store: Observable<SelectionStoreState>;
+    private config;
+    constructor(store: Observable<SelectionStoreState>, config: Config);
+    get edited(): EditCellStore | null;
+    get focused(): Cell | null;
+    get ranged(): RangeArea | null;
+    changeRange(range: RangeArea): boolean;
+    focus(cell?: Cell, isMulti?: boolean): boolean;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { RevoGrid } from '../interfaces';
-export declare const rowTypes: RevoGrid.DimensionRows[];
-export declare const columnTypes: RevoGrid.DimensionCols[];
-export declare function isRowType(type: RevoGrid.DimensionRows | any): type is RevoGrid.DimensionRows;
+import { DimensionCols, DimensionRows } from '..';
+export declare const rowTypes: DimensionRows[];
+export declare const columnTypes: DimensionCols[];
+export declare function isRowType(type: DimensionRows | any): type is DimensionRows;

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

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

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

@@ -0,0 +1,54 @@
+import { DimensionSettingsState, PositionItem, ViewSettingSizeProp, ViewportStateItems, VirtualPositionItem, Range } from '../..';
+export type DimensionDataViewport = Pick<DimensionSettingsState, 'indexes' | 'positionIndexes' | 'positionIndexToItem' | 'sizes' | 'originItemSize' | 'realSize'>;
+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 | null;
+/**
+ * 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 | undefined;
+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/viewport/viewport.store.d.ts

@@ -0,0 +1,36 @@
+import { DimensionDataViewport } from './viewport.helpers';
+import { ViewportStateItems, ViewportState, Observable, ViewSettingSizeProp } from '../..';
+import { MultiDimensionType } from '../..';
+export type ViewportStoreCollection = {
+    [T in MultiDimensionType]: ViewportStore;
+};
+/**
+ * Viewport store class
+ */
+export default class ViewportStore {
+    readonly type: MultiDimensionType;
+    readonly store: Observable<ViewportState>;
+    private lastKnownScroll;
+    get lastCoordinate(): number;
+    private set lastCoordinate(value);
+    constructor(type: MultiDimensionType);
+    /**
+     * Render viewport based on coordinate
+     * It's the main method for draw
+     */
+    setViewPortCoordinate(position: number, dimension: DimensionDataViewport): void;
+    /**
+     * Update viewport sizes for existing items
+     * This method is generating new item positions based on custom sizes and original sizes
+     * @param sizes - custom sizes for each item
+     * @param dropToOriginalSize - drop to original size if requested
+     */
+    setViewPortDimensionSizes(sizes: ViewSettingSizeProp, dropToOriginalSize?: number): void;
+    /**
+     * Set sizes for existing items
+     */
+    setOriginalSizes(size: number): void;
+    getItems(): Pick<ViewportStateItems, 'items' | 'start' | 'end'>;
+    setViewport(data: Partial<ViewportState>): void;
+    clearItems(): void;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { 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;
+    static getTheme(theme: string): 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;