@revolist/revogrid 4.0.2-next → 4.0.2

package/dist/types/interfaces.d.ts

@@ -1,437 +0,0 @@
-/* eslint-disable */
-/* tslint:disable */
-// @ts-ignore
-import { VNode } from './stencil-public-runtime';
-// @ts-ignore
-import { ObservableMap, Subscription } from '@stencil/store';
-
-export type Observable<T> = ObservableMap<T>;
-export type PluginSubscribe<T> = Subscription<T>;
-
-export declare namespace RevoGrid {
-  // --------------------------------------------------------------------------
-  //
-  //  Dimensions
-  //
-  // --------------------------------------------------------------------------
-
-  type DimensionTypeRow = 'rgRow';
-  type DimensionTypeCol = 'rgCol';
-
-  type DimensionColPin = 'colPinStart' | 'colPinEnd';
-  type DimensionRowPin = 'rowPinStart' | 'rowPinEnd';
-
-  type DimensionType = DimensionTypeCol | DimensionTypeRow;
-
-  type DimensionCols = DimensionColPin | DimensionTypeCol;
-  type DimensionRows = DimensionTypeRow | DimensionRowPin;
-
-  type MultiDimensionType = DimensionCols | DimensionRows;
-
-  // --------------------------------------------------------------------------
-  //
-  //  Columns
-  //
-  // --------------------------------------------------------------------------
-
-  type ColumnDataSchemaModel = {
-    // property
-    prop: ColumnProp;
-    // rgRow model
-    model: DataType;
-    // column data
-    column: ColumnRegular;
-    // index in grid datasource
-    rowIndex: number;
-    // grid datasource
-    data: DataSource;
-  };
-
-  type CellTemplateProp = {
-    providers: Providers;
-  } & ColumnDataSchemaModel;
-
-  type ReadOnlyFormat = boolean | ((params: ColumnDataSchemaModel) => boolean);
-  type RowDrag = boolean | { (params: ColumnDataSchemaModel): boolean };
-
-  interface ColumnGrouping {
-    children: ColumnDataSchema[];
-    name: DataFormat;
-  }
-
-  interface ColumnProperties {
-    /** column inner template */
-    columnTemplate?: ColumnTemplateFunc<VNode>;
-    /** cell properties */
-    columnProperties?: ColPropertiesFunc;
-  }
-
-  type ColumnTypes = { [name: string]: RevoGrid.ColumnType };
-
-  interface ColumnType extends ColumnProperties {
-    /** is column or cell readonly */
-    readonly?: ReadOnlyFormat;
-    /** cell properties */
-    cellProperties?: PropertiesFunc;
-    /** cell inner template */
-    cellTemplate?: CellTemplateFunc<VNode>;
-    /** cell compare function */
-    cellCompare?: CellCompareFunc;
-    /** default column size */
-    size?: number;
-    /**
-     * minimal column size
-     * this property can not be less than cell padding
-     * in order to keep performance on top and minimize dom elements number
-     */
-    minSize?: number;
-    /**  max column size */
-    maxSize?: number;
-
-    /** represents custom editor defined in @editors property */
-    editor?: string | Edition.EditorCtr;
-  }
-
-  type Order = 'asc' | 'desc' | undefined;
-
-  interface ColumnRegular extends ColumnType {
-    /** mapping to data */
-    prop?: ColumnProp;
-    /** column pin 'colPinStart'|'colPinEnd' */
-    pin?: DimensionColPin;
-    /** column header */
-    name?: DataFormat;
-    /** is column can be sorted */
-    sortable?: boolean;
-    /** column size would be changed based on content size */
-    autoSize?: boolean;
-    /** filter */
-    filter?: boolean | string | string[];
-    order?: Order;
-    /** is cell in column or individual can be dragged */
-    rowDrag?: RowDrag;
-
-    /** represents type defined in @columnTypes property */
-    columnType?: string;
-
-    beforeSetup?(rgCol: ColumnRegular): void;
-
-    [key: string]: any;
-  }
-
-  type ColumnDataSchema = ColumnGrouping | ColumnRegular;
-  type ColumnData = ColumnDataSchema[];
-  type ColumnTemplateProp = ColumnRegular & {
-    providers: Providers;
-    index: number;
-  };
-  type ColumnPropProp = ColumnGrouping | ColumnTemplateProp;
-
-  type ColumnProp = string | number;
-  type DataFormat = any;
-
-  type CellProp = string | number | object | boolean | undefined;
-  type CellProps = {
-    style?: { [key: string]: string | undefined };
-    class?: { [key: string]: boolean } | string;
-    [attr: string]: CellProp;
-  };
-
-  type Providers = {
-    viewport: Observable<ViewportState>;
-    dimension: Observable<DimensionSettingsState>;
-    selection: Observable<Selection.SelectionStoreState>;
-  };
-
-  // --------------------------------------------------------------------------
-  //
-  //  Create Element function description
-  //
-  // --------------------------------------------------------------------------
-
-  interface HyperFunc<T> {
-    (tag: any): T;
-  }
-  interface HyperFunc<T> {
-    (tag: any, data: any): T;
-  }
-  interface HyperFunc<T> {
-    (tag: any, text: string): T;
-  }
-  interface HyperFunc<T> {
-    (sel: any, children: Array<T | undefined | null>): T;
-  }
-  interface HyperFunc<T> {
-    (sel: any, data: any, text: string): T;
-  }
-  interface HyperFunc<T> {
-    (sel: any, data: any, children: Array<T | undefined | null>): T;
-  }
-  interface HyperFunc<T> {
-    (sel: any, data: any, children: T): T;
-  }
-
-  type CellTemplateFunc<T> = (createElement: HyperFunc<T>, props: CellTemplateProp) => any;
-  type CellCompareFunc = (prop: ColumnProp, a: DataType, b: DataType) => number;
-  type ColumnTemplateFunc<T> = (createElement: HyperFunc<T>, props: ColumnTemplateProp) => T | T[] | string;
-  type PropertiesFunc = (props: ColumnDataSchemaModel) => CellProps | void | undefined;
-  type ColPropertiesFunc = (props: ColumnPropProp) => CellProps | void | undefined;
-
-  // --------------------------------------------------------------------------
-  //
-  //  Row data source
-  //
-  // --------------------------------------------------------------------------
-
-  type DataType = { [T in ColumnProp]: DataFormat };
-  type DataSource = DataType[];
-  type DataLookup = { [rowIndex: number]: DataType };
-
-  // --------------------------------------------------------------------------
-  //
-  //  Row definitions
-  //
-  // --------------------------------------------------------------------------
-
-  type RowDefinition = {
-    type: DimensionRows;
-    size: number;
-    index: number;
-  };
-
-  interface RowHeaders extends RevoGrid.ColumnRegular {}
-
-  // --------------------------------------------------------------------------
-  //
-  //  Events
-  //
-  // --------------------------------------------------------------------------
-
-  type ViewPortResizeEvent = {
-    dimension: DimensionType;
-    size: number;
-  };
-
-  type ViewPortScrollEvent = {
-    dimension: DimensionType;
-    coordinate: number;
-    delta?: number;
-  };
-
-  type InitialHeaderClick = {
-    index: number;
-    originalEvent: MouseEvent;
-    column: RevoGrid.ColumnRegular;
-  };
-
-  // --------------------------------------------------------------------------
-  //
-  //  Viewport store
-  //
-  // --------------------------------------------------------------------------
-
-  type Range = {
-    start: number;
-    end: number;
-  };
-
-  type ViewportStateItems = {
-    items: VirtualPositionItem[];
-  } & Range;
-
-  interface ViewportState extends ViewportStateItems {
-    realCount: number;
-    virtualSize: number;
-    lastCoordinate: number;
-  }
-
-  type ViewSettingSizeProp = Record<string, number>;
-
-  interface VirtualPositionItem extends PositionItem {
-    size: number;
-  }
-
-  interface PositionItem {
-    itemIndex: number;
-    start: number;
-    end: number;
-  }
-
-  // --------------------------------------------------------------------------
-  //
-  //  Dimension store
-  //
-  // --------------------------------------------------------------------------
-
-  interface DimensionCalc {
-    indexes: number[];
-    positionIndexes: number[];
-    positionIndexToItem: { [position: number]: PositionItem };
-    indexToItem: { [index: number]: PositionItem };
-    sizes: ViewSettingSizeProp;
-  }
-  interface DimensionSettingsState extends DimensionCalc {
-    frameOffset: number;
-    realSize: number;
-    originItemSize: number;
-  }
-}
-
-// --------------------------------------------------------------------------
-//
-//  Plugin space
-//
-// --------------------------------------------------------------------------
-export declare namespace RevoPlugin {
-  class Plugin {
-    constructor(revogrid: HTMLRevoGridElement, ...[]);
-    destroy(): void;
-  }
-
-  class PluginExternal extends Plugin {
-    constructor(revogrid: HTMLRevoGridElement, providers: Record<string, any>, ...[]);
-  }
-
-  type PluginClass = typeof Plugin;
-}
-
-// --------------------------------------------------------------------------
-//
-//  Selection space
-//
-// --------------------------------------------------------------------------
-
-export declare namespace Selection {
-  type RowIndex = number;
-  type ColIndex = number;
-
-  type SelectionStoreState = {
-    // responsible for main range frame, can take focus from here
-    range: RangeArea | null;
-    tempRange: RangeArea | null;
-    tempRangeType: string | null;
-    focus: Cell | null;
-
-    edit: Edition.EditCellStore | null;
-    lastCell: Cell | null;
-  };
-
-  type RangeArea = {
-    x: ColIndex;
-    y: RowIndex;
-    x1: ColIndex;
-    y1: RowIndex;
-  };
-
-  type TempRange = {
-    type: string;
-    area: RangeArea;
-  };
-
-  type ChangedRange = {
-    type: RevoGrid.DimensionRows;
-    newRange: RangeArea;
-    oldRange: RangeArea;
-    newProps: RevoGrid.ColumnProp[];
-    oldProps: RevoGrid.ColumnProp[];
-    newData: { [key: number]: RevoGrid.DataType };
-  };
-
-  interface Cell {
-    x: ColIndex;
-    y: RowIndex;
-  }
-
-  type FocusedCells = {
-    focus: Selection.Cell;
-    end: Selection.Cell;
-  };
-
-  type RangeAreaCss = {
-    left: string;
-    top: string;
-    width: string;
-    height: string;
-  };
-}
-
-// --------------------------------------------------------------------------
-//
-//  Edition space
-//
-// --------------------------------------------------------------------------
-
-export declare namespace Edition {
-  import HyperFunc = RevoGrid.HyperFunc;
-  type SaveData = string;
-  type SaveDataDetails = {
-    rgRow: Selection.RowIndex;
-    rgCol: Selection.ColIndex;
-    val: any;
-    preventFocus?: boolean;
-  };
-
-  type BeforeEdit = {
-    isCancel: boolean;
-  } & Edition.BeforeSaveDataDetails;
-
-  type BeforeSaveDataDetails = {
-    prop: RevoGrid.ColumnProp;
-    model: RevoGrid.DataType;
-    val?: SaveData;
-    rowIndex: number;
-    type: RevoGrid.DimensionRows;
-  };
-
-  type BeforeRangeSaveDataDetails = {
-    data: RevoGrid.DataLookup;
-    models: { [rowIndex: number]: RevoGrid.DataType };
-    type: RevoGrid.DimensionRows;
-  };
-
-  interface EditCellStore extends Selection.Cell {
-    val?: SaveData;
-  }
-
-  type EditCell = EditCellStore & BeforeSaveDataDetails;
-
-  type Editors = { [name: string]: EditorCtr };
-
-  interface EditorCtr {
-    new (
-      // column data
-      column: RevoGrid.ColumnRegular,
-      // to save changes
-      saveCallback: (value: Edition.SaveData, preventFocus?: boolean) => void,
-      // to close editor, if focusNext true, after close editor focus on next cell
-      closeCallback: (focusNext?: boolean) => void,
-    ): EditorBase;
-  }
-
-  interface EditorBase {
-    element?: Element | null;
-    editCell?: EditCell;
-    componentDidRender?(): void;
-    disconnectedCallback?(): void;
-    render(createElement?: HyperFunc<VNode>): VNode | VNode[] | string | void;
-  }
-}
-
-export declare namespace ThemeSpace {
-  interface ThemePackage {
-    defaultRowSize: number;
-  }
-
-  type ThemeConfig = {
-    rowSize: number;
-  };
-
-  type Theme = 'default' | 'material' | 'compact' | 'darkMaterial' | 'darkCompact';
-}
-
-export type DimensionStores = {
-  [T in RevoGrid.MultiDimensionType]: Observable<RevoGrid.DimensionSettingsState>;
-};
-export type ViewportStores = {
-  [T in RevoGrid.MultiDimensionType]: Observable<RevoGrid.ViewportState>;
-};

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

@@ -1,54 +0,0 @@
-import BasePlugin from './basePlugin';
-import ColumnDataProvider from '../services/column.data.provider';
-import { DataProvider } from '../services/data.provider';
-import DimensionProvider from '../services/dimension.provider';
-export declare type AutoSizeColumnConfig = {
-  mode?: ColumnAutoSizeMode;
-  /**
-   * autoSize for all columns
-   * if allColumnes true all columns treated as autoSize, worse for performance
-   * false by default
-   */
-  allColumns?: boolean;
-  /**
-   * assumption per characted size
-   * by default defined as 8, can be changed in this config
-   */
-  letterBlockSize?: number;
-  /** make size calculation exact
-   * by default it based on assumption each character takes some space defined in letterBlockSize */
-  preciseSize?: boolean;
-};
-declare type Providers = {
-  dataProvider: DataProvider;
-  dimensionProvider: DimensionProvider;
-  columnProvider: ColumnDataProvider;
-};
-declare enum ColumnAutoSizeMode {
-  headerClickAutosize = "headerClickAutoSize",
-  autoSizeOnTextOverlap = "autoSizeOnTextOverlap",
-  autoSizeAll = "autoSizeAll"
-}
-export default class AutoSizeColumn extends BasePlugin {
-  private providers;
-  private config?;
-  private autoSizeColumns;
-  private readonly letterBlockSize;
-  /** for config option when @preciseSize enabled */
-  private readonly precsizeCalculationArea;
-  /** for edge case when no columns defined before data */
-  private dataResolve;
-  private dataReject;
-  constructor(revogrid: HTMLRevoGridElement, providers: Providers, config?: AutoSizeColumnConfig);
-  private setSource;
-  private getLength;
-  private afteredit;
-  private afterEditAll;
-  private getColumnSize;
-  private columnSet;
-  private clearPromise;
-  private isRangeEdit;
-  private initiatePresizeElement;
-  destroy(): void;
-}
-export {};

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

@@ -1,37 +0,0 @@
-import { RevoPlugin } from '../interfaces';
-/**
- * Base layer for plugins
- * Provide minimal starting core
- */
-export default abstract class BasePlugin implements RevoPlugin.Plugin {
-  protected revogrid: HTMLRevoGridElement;
-  protected readonly subscriptions: Record<string, (e: CustomEvent) => void>;
-  constructor(revogrid: HTMLRevoGridElement);
-  /**
-   *
-   * @param eventName - event name to subscribe to in revo-grid
-   * @param callback - callback function for event
-   */
-  protected addEventListener(eventName: string, callback: (e: CustomEvent) => void): void;
-  /**
-   * Remove event subscription
-   * @param eventName
-   */
-  protected removeEventListener(eventName: string): void;
-  /**
-   * Trigger event to grid upper level
-   * Event can be cancelled
-   * @param eventName
-   * @param detail
-   * @returns event
-   */
-  protected emit(eventName: string, detail?: any): CustomEvent<any>;
-  /**
-   * Clearing inner subscription
-   */
-  protected clearSubscriptions(): void;
-  /**
-   * Minimal destroy implementations
-   */
-  destroy(): void;
-}

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

@@ -1,29 +0,0 @@
-import { RevoPlugin } from '../interfaces';
-import ColumnDataProvider from '../services/column.data.provider';
-import { DataProvider } from '../services/data.provider';
-import DimensionProvider, { ColumnItems } from '../services/dimension.provider';
-import BasePlugin from './basePlugin';
-declare type Providers = {
-  dataProvider: DataProvider;
-  dimensionProvider: DimensionProvider;
-  columnProvider: ColumnDataProvider;
-};
-export default class StretchColumn extends BasePlugin {
-  private providers;
-  private stretchedColumn;
-  private readonly scrollSize;
-  constructor(revogrid: HTMLRevoGridElement, providers: Providers);
-  private setScroll;
-  private activateChanges;
-  private dropChanges;
-  private apply;
-  /**
-   * Apply stretch changes
-   */
-  applyStretch(columns: ColumnItems): void;
-}
-/**
- * Check plugin type is Stretch
- */
-export declare function isStretchPlugin(plugin: RevoPlugin.Plugin | StretchColumn): plugin is StretchColumn;
-export {};

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

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

package/dist/types/services/localScrollService.d.ts

@@ -1,28 +0,0 @@
-import { RevoGrid } from '../interfaces';
-interface Config {
-  beforeScroll(e: RevoGrid.ViewPortScrollEvent): void;
-  afterScroll(e: RevoGrid.ViewPortScrollEvent): void;
-}
-declare type Params = {
-  contentSize: number;
-  virtualContentSize?: number;
-  clientSize: number;
-  virtualSize: number;
-  maxSize?: number;
-};
-export default class LocalScrollService {
-  private cfg;
-  private preventArtificialScroll;
-  private previousScroll;
-  private params;
-  constructor(cfg: Config);
-  static getVirtualContentSize(contentSize: number, clientSize: number, virtualSize?: number): number;
-  setParams(params: Params, dimension: RevoGrid.DimensionType): void;
-  setScroll(e: RevoGrid.ViewPortScrollEvent): void;
-  scroll(coordinate: number, dimension: RevoGrid.DimensionType, force?: boolean, delta?: number): void;
-  private getParams;
-  private wrapCoordinate;
-  private cancelScroll;
-  private convert;
-}
-export {};

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

@@ -1,30 +0,0 @@
-import { RevoGrid } from '../../interfaces';
-export declare type DimensionDataViewport = Pick<RevoGrid.DimensionSettingsState, 'indexes' | 'positionIndexes' | 'positionIndexToItem' | 'sizes' | 'originItemSize' | 'realSize' | 'frameOffset'>;
-declare type ItemsToUpdate = Pick<RevoGrid.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, items: T, realCount: number, virtualSize: number, dimension: DimensionDataViewport): ItemsToUpdate;
-export declare function updateMissingAndRange(items: RevoGrid.VirtualPositionItem[], missing: RevoGrid.VirtualPositionItem[], range: RevoGrid.Range): void;
-export declare function addMissingItems<T extends ItemsToUpdate>(firstItem: RevoGrid.PositionItem, realCount: number, virtualSize: number, existingCollection: T, dimension: Pick<RevoGrid.DimensionSettingsState, 'sizes' | 'originItemSize'>): RevoGrid.VirtualPositionItem[];
-export declare function getItems(opt: {
-  startIndex: number;
-  start: number;
-  origSize: number;
-  maxSize: number;
-  maxCount: number;
-  sizes?: RevoGrid.ViewSettingSizeProp;
-}, currentSize?: number): RevoGrid.VirtualPositionItem[];
-/**
- * Do batch items recombination
- * If items not overlapped with existing viewport returns null
- */
-export declare function recombineByOffset(offset: number, data: {
-  positiveDirection: boolean;
-} & ItemsToUpdate & Pick<RevoGrid.DimensionSettingsState, 'sizes' | 'realSize' | 'originItemSize'>): ItemsToUpdate | null;
-export declare function isActiveRange(pos: number, item: RevoGrid.PositionItem | undefined): boolean;
-export declare function getFirstItem(s: ItemsToUpdate): RevoGrid.VirtualPositionItem | undefined;
-export declare function getLastItem(s: ItemsToUpdate): RevoGrid.VirtualPositionItem;
-export {};

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

@@ -1,18 +0,0 @@
-/**
- * Store is responsible for visible
- * Viewport information for each dimension
- * Redraw items during scrolling
- */
-import { DimensionDataViewport } from './viewport.helpers';
-import { Observable, RevoGrid } from '../../interfaces';
-export default class ViewportStore {
-  readonly store: Observable<RevoGrid.ViewportState>;
-  constructor();
-  /** Render viewport based on coordinate, this is main method for draw */
-  setViewPortCoordinate(position: number, dimension: DimensionDataViewport): void;
-  /** Update viewport sizes */
-  setViewPortDimension(sizes: RevoGrid.ViewSettingSizeProp): void;
-  getItems(): Pick<RevoGrid.ViewportStateItems, 'items' | 'start' | 'end'>;
-  setViewport(data: Partial<RevoGrid.ViewportState>): void;
-  clear(): void;
-}

package/dist/types/themeManager/themeService.d.ts

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