@revolist/revogrid 4.0.2-next → 4.0.2

package/dist/types/components/revoGrid/viewport.helpers.d.ts

@@ -1,9 +1,10 @@
 /** Collect data for pinned columns in required @ViewportProps format */
-import { RevoGrid, Selection } from '../../interfaces';
-import { ViewportColumn } from './viewport.interfaces';
+import { MultiDimensionType } from '../..';
+import { Cell } from '../..';
+import { ViewportColumn } from '../../types/viewport.interfaces';
 export declare const HEADER_SLOT = "header";
 export declare const FOOTER_SLOT = "footer";
 export declare const CONTENT_SLOT = "content";
 export declare const DATA_SLOT = "data";
 /** Receive last visible in viewport by required type */
-export declare function getLastCell(data: ViewportColumn, rowType: RevoGrid.MultiDimensionType): Selection.Cell;
+export declare function getLastCell(data: ViewportColumn, rowType: MultiDimensionType): Cell;

package/dist/types/components/revoGrid/viewport.resize.service.d.ts

@@ -1,12 +1,12 @@
 interface Events {
-  resize(entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver): void;
+    resize(entries: ReadonlyArray<ResizeObserverEntry>, observer: ResizeObserver): void;
 }
 export default class GridResizeService {
-  private events;
-  private resizeObserver;
-  private resize;
-  constructor(el: HTMLElement, events: Events);
-  init(el: HTMLElement): Promise<void>;
-  destroy(): void;
+    private events;
+    private resizeObserver;
+    private resize;
+    constructor(el: HTMLElement, events: Events);
+    init(el: HTMLElement): Promise<void>;
+    destroy(): void;
 }
 export {};

package/dist/types/components/revoGrid/viewport.scrolling.service.d.ts

@@ -1,23 +1,22 @@
-import { RevoGrid } from '../../interfaces';
-export interface ElementScroll {
-  changeScroll?(e: RevoGrid.ViewPortScrollEvent): Promise<RevoGrid.ViewPortScrollEvent>;
-  setScroll(e: RevoGrid.ViewPortScrollEvent): Promise<void>;
-}
-export declare type ElementsScroll = {
-  [key: string]: ElementScroll[];
-};
+import { DimensionColPin } from '../..';
+import { ViewPortScrollEvent } from '../..';
+import { ElementsScroll, ElementScroll } from '../../types/viewport.interfaces';
 export default class GridScrollingService {
-  private setViewport;
-  private elements;
-  constructor(setViewport: (e: RevoGrid.ViewPortScrollEvent) => void);
-  onScroll(e: RevoGrid.ViewPortScrollEvent, key?: RevoGrid.DimensionColPin | string): Promise<void>;
-  private isPinnedColumn;
-  registerElements(els: ElementsScroll): void;
-  /**
-   * Register new element for farther scroll support
-   * @param el - can be null if holder removed
-   * @param key - element key
-   */
-  registerElement(el: ElementScroll | null, key: string): void;
-  unregister(): void;
+    private setViewport;
+    private elements;
+    constructor(setViewport: (e: ViewPortScrollEvent) => void);
+    proxyScroll(e: ViewPortScrollEvent, key?: DimensionColPin | string): Promise<void>;
+    /**
+     * Silent scroll update for mobile devices when we have negative scroll top
+     */
+    scrollSilentService(e: ViewPortScrollEvent, key?: DimensionColPin | string): Promise<void>;
+    private isPinnedColumn;
+    registerElements(els: ElementsScroll): void;
+    /**
+     * Register new element for farther scroll support
+     * @param el - can be null if holder removed
+     * @param key - element key
+     */
+    registerElement(el: ElementScroll | null, key: string): void;
+    unregister(): void;
 }

package/dist/types/components/revoGrid/viewport.service.d.ts

@@ -1,68 +1,66 @@
-import { RevoGrid, Selection } from '../../interfaces';
 import DimensionProvider from '../../services/dimension.provider';
 import SelectionStoreConnector from '../../services/selection.store.connector';
 import ViewportProvider from '../../services/viewport.provider';
-import { OrdererService } from '../order/orderRenderer';
+import { OrdererService } from '../order/order-renderer';
 import GridScrollingService from './viewport.scrolling.service';
-import { ViewportProps } from './viewport.interfaces';
 import ColumnDataProvider from '../../services/column.data.provider';
 import { DataProvider } from '../../services/data.provider';
-declare type StoresMapping<T> = {
-  [xOrY: number]: Partial<T>;
+import { ColumnRegular } from '../..';
+import { DimensionCols, DimensionRows } from '../..';
+import { ViewportProps } from '../../types/viewport.interfaces';
+import { Cell, RangeArea } from '../..';
+export type ResizeDetails = {
+    [index: number]: ColumnRegular;
 };
-declare type Config = {
-  columnProvider: ColumnDataProvider;
-  dataProvider: DataProvider;
-  dimensionProvider: DimensionProvider;
-  viewportProvider: ViewportProvider;
-  uuid: string | null;
-  scrollingService: GridScrollingService;
-  orderService: OrdererService;
-  selectionStoreConnector: SelectionStoreConnector;
-  resize(r: Record<RevoGrid.ColumnProp, RevoGrid.ColumnRegular>): void;
+type Config = {
+    columnProvider: ColumnDataProvider;
+    dataProvider: DataProvider;
+    dimensionProvider: DimensionProvider;
+    viewportProvider: ViewportProvider;
+    scrollingService: GridScrollingService;
+    orderService: OrdererService;
+    selectionStoreConnector: SelectionStoreConnector;
+    disableVirtualX?: boolean;
+    disableVirtualY?: boolean;
+    resize(r: ResizeDetails): void;
 };
-export declare type FocusedData = {
-  model: any;
-  cell: Selection.Cell;
-  colType: RevoGrid.DimensionCols;
-  rowType: RevoGrid.DimensionRows;
-  column?: RevoGrid.ColumnRegular;
+export type FocusedData = {
+    model: any;
+    cell: Cell;
+    colType: DimensionCols;
+    rowType: DimensionRows;
+    column?: ColumnRegular;
 };
 export default class ViewportService {
-  private sv;
-  readonly columns: ViewportProps[];
-  readonly storesByType: Partial<Record<RevoGrid.MultiDimensionType, number>>;
-  readonly storesXToType: StoresMapping<RevoGrid.DimensionCols>;
-  readonly storesYToType: StoresMapping<RevoGrid.DimensionRows>;
-  constructor(sv: Config, contentHeight: number);
-  private onColumnResize;
-  /**
-   * Transform data from stores and apply it to different components
-   */
-  private getViewportColumnData;
-  /** register selection store for Segment */
-  private registerSegment;
-  /** register selection store for Row */
-  private registerRow;
-  /** register selection store for Column */
-  private registerCol;
-  /** Collect Column data */
-  private gatherColumnData;
-  /** Collect Row data */
-  private dataViewPort;
-  private dataPartition;
-  scrollToCell(cell: Partial<Selection.Cell>): void;
-  /**
-   * Clear current grid focus
-   */
-  clearFocused(): void;
-  clearEdit(): void;
-  getFocused(): FocusedData | null;
-  getStoreCoordinateByType(colType: RevoGrid.DimensionCols, rowType: RevoGrid.DimensionRows): {
-    x: number;
-    y: number;
-  };
-  setFocus(colType: RevoGrid.DimensionCols, rowType: RevoGrid.DimensionRows, start: Selection.Cell, end: Selection.Cell): void;
-  setEdit(rowIndex: number, colIndex: number, colType: RevoGrid.DimensionCols, rowType: RevoGrid.DimensionRows): void;
+    private config;
+    readonly columns: ViewportProps[];
+    constructor(config: Config, contentHeight: number);
+    private onColumnResize;
+    /** register selection store for Segment */
+    private registerSegment;
+    /** register selection store for Row */
+    private registerRow;
+    /** register selection store for Column */
+    private registerCol;
+    /** Collect Row data */
+    private dataViewPort;
+    private dataPartition;
+    scrollToCell(cell: Partial<Cell>): void;
+    /**
+     * Clear current grid focus
+     */
+    clearFocused(): void;
+    clearEdit(): void;
+    /**
+     * Collect focused element data
+     */
+    getFocused(): FocusedData | null;
+    getStoreCoordinateByType(colType: DimensionCols, rowType: DimensionRows): {
+        x: number;
+        y: number;
+    };
+    setFocus(colType: string, rowType: string, start: Cell, end: Cell): void;
+    getSelectedRange(): RangeArea | null;
+    setEdit(rowIndex: number, colIndex: number, colType: DimensionCols, rowType: DimensionRows): void;
 }
 export {};

package/dist/types/components/rowHeaders/revogr-row-headers.d.ts

@@ -1,19 +1,52 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { RevoGrid } from '../../interfaces';
-import { ElementScroll } from '../revoGrid/viewport.scrolling.service';
-import { ViewportData } from '../revoGrid/viewport.interfaces';
+import { RowHeaders, ViewPortScrollEvent } from '../../types/interfaces';
+import { ViewportData, ElementScroll } from '../../types/viewport.interfaces';
 /**
  * Row headers component
  * Visible on the left side of the table
  */
 export declare class RevogrRowHeaders {
-  height: number;
-  dataPorts: ViewportData[];
-  headerProp: Record<string, any>;
-  uiid: string;
-  resize: boolean;
-  rowHeaderColumn: RevoGrid.RowHeaders;
-  scrollViewport: EventEmitter<RevoGrid.ViewPortScrollEvent>;
-  elementToScroll: EventEmitter<ElementScroll>;
-  render(): any;
+    /**
+     * Header height to setup row headers
+     */
+    height: number;
+    /**
+     * Viewport data
+     */
+    dataPorts: ViewportData[];
+    /**
+     * Header props
+     */
+    headerProp: Record<string, any>;
+    /**
+     * Row class
+     */
+    rowClass: string;
+    /**
+     * Enable resize
+     */
+    resize: boolean;
+    /**
+     * Row header column
+     */
+    rowHeaderColumn: RowHeaders;
+    /**
+     * Additional data to pass to renderer
+     */
+    additionalData: any;
+    /**
+     * Prevent rendering until job is done.
+     * Can be used for initial rendering performance improvement.
+     * When several plugins require initial rendering this will prevent double initial rendering.
+     */
+    jobsBeforeRender: Promise<any>[];
+    /**
+     * Scroll viewport
+     */
+    scrollViewport: EventEmitter<ViewPortScrollEvent>;
+    /**
+     * Register element to scroll
+     */
+    elementToScroll: EventEmitter<ElementScroll>;
+    render(): any;
 }

package/dist/types/components/rowHeaders/row-header-render.d.ts

@@ -1,9 +1,9 @@
 import { VNode } from '../../stencil-public-runtime';
-import { RevoGrid } from '../../interfaces';
-declare type HeaderRender = {
-  (start: number): (h: RevoGrid.HyperFunc<VNode>, e: {
-    rowIndex: number;
-  }) => number;
+import { HyperFunc } from '../../types/interfaces';
+type HeaderRender = {
+    (start: number): (h: HyperFunc<VNode>, e: {
+        rowIndex: number;
+    }) => number;
 };
 export declare const RowHeaderRender: HeaderRender;
 export {};

package/dist/types/components/scroll/revogr-viewport-scroll.d.ts

@@ -1,81 +1,120 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { RevoGrid } from '../../interfaces';
+import { DimensionCols, DimensionType } from '../../types/dimension';
+import { ScrollCoordinateEvent, ViewPortResizeEvent, ViewPortScrollEvent } from '../../types/interfaces';
+type Delta = 'deltaX' | 'deltaY';
+type LocalScrollEvent = {
+    preventDefault(): void;
+} & {
+    [x in Delta]: number;
+};
 /**
- * Service for tracking grid scrolling
+ * Viewport scroll component for RevoGrid
+ * @slot - content
+ * @slot header - header
+ * @slot footer - footer
  */
 export declare class RevogrViewportScroll {
-  scrollViewport: EventEmitter<RevoGrid.ViewPortScrollEvent>;
-  resizeViewport: EventEmitter<RevoGrid.ViewPortResizeEvent>;
-  scrollchange: EventEmitter<{
-    type: RevoGrid.DimensionType;
-    hasScroll: boolean;
-  }>;
-  private scrollThrottling;
-  /**
-   * Width of inner content
-   */
-  contentWidth: number;
-  /**
-   * Height of inner content
-   */
-  contentHeight: number;
-  private oldValY;
-  private oldValX;
-  horizontalScroll: HTMLElement;
-  private verticalScroll;
-  private header;
-  private footer;
-  /**
-   * Static functions to bind wheel change
-   */
-  private horizontalMouseWheel;
-  private verticalMouseWheel;
-  private horisontalResize;
-  private scrollService;
-  /**
-   * Last mw event time for trigger scroll function below
-   * If mousewheel function was ignored we still need to trigger render
-   */
-  private mouseWheelScroll;
-  setScroll(e: RevoGrid.ViewPortScrollEvent): Promise<void>;
-  /**
-   * update on delta in case we don't know existing position or external change
-   * @param e
-   */
-  changeScroll(e: RevoGrid.ViewPortScrollEvent): Promise<RevoGrid.ViewPortScrollEvent>;
-  connectedCallback(): void;
-  componentDidLoad(): void;
-  /**
-   * Check if scroll present or not per type
-   * Trigger this method on inner content size change or on outer element size change
-   * If inner content bigger then outer size then scroll is present and mousewheel binding required
-   * @param type - dimension type 'rgRow/y' or 'rgCol/x'
-   * @param size - outer content size
-   * @param innerContentSize - inner content size
-   */
-  setScrollVisibility(type: RevoGrid.DimensionType, size: number, innerContentSize: number): void;
-  disconnectedCallback(): void;
-  componentDidRender(): Promise<void>;
-  render(): any;
-  /**
-   * Extra layer for scroll event monitoring, where MouseWheel event is not passing
-   * We need to trigger scroll event in case there is no mousewheel event
-   */
-  private onScroll;
-  /** remember last mw event time */
-  private latestScrollUpdate;
-  /**
-   * On vertical mousewheel event
-   * @param type
-   * @param delta
-   * @param e
-   */
-  private onVerticalMouseWheel;
-  /**
-   * On horizontal mousewheel event
-   * @param type
-   * @param delta
-   * @param e
-   */
-  private onHorizontalMouseWheel;
+    /**
+     * Enable row header
+    */
+    readonly rowHeader: boolean;
+    /**
+     * Width of inner content
+     */
+    contentWidth: number;
+    /**
+     * Height of inner content
+     */
+    contentHeight: number;
+    colType: DimensionCols | 'rowHeaders';
+    /**
+     * Before scroll event
+     */
+    scrollViewport: EventEmitter<ViewPortScrollEvent>;
+    /**
+     * Viewport resize
+     */
+    resizeViewport: EventEmitter<ViewPortResizeEvent>;
+    /**
+     * Triggered on scroll change, can be used to get information about scroll visibility
+     */
+    scrollchange: EventEmitter<{
+        type: DimensionType;
+        hasScroll: boolean;
+    }>;
+    /**
+     * Silently scroll to coordinate
+     * Made to align negative coordinates for mobile devices
+    */
+    silentScroll: EventEmitter<ViewPortScrollEvent>;
+    horizontalScroll: HTMLElement;
+    private oldValY;
+    private oldValX;
+    private verticalScroll;
+    private header;
+    private footer;
+    /**
+     * Static functions to bind wheel change
+     */
+    private horizontalMouseWheel;
+    private verticalMouseWheel;
+    private resizeService;
+    private localScrollService;
+    private localScrollTimer;
+    setScroll(e: ViewPortScrollEvent): Promise<void>;
+    /**
+     * update on delta in case we don't know existing position or external change
+     * @param e
+     */
+    changeScroll(e: ViewPortScrollEvent, silent?: boolean): Promise<ViewPortScrollEvent>;
+    /**
+     * Dispatch this event to trigger vertical mouse wheel from plugins
+     */
+    mousewheelVertical({ detail: e, }: CustomEvent<LocalScrollEvent>): void;
+    /**
+     * Dispatch this event to trigger horizontal mouse wheel from plugins
+     */
+    mousewheelHorizontal({ detail: e, }: CustomEvent<LocalScrollEvent>): void;
+    /**
+     * Allows to use outside listener
+     */
+    scrollApply({ detail: { type, coordinate }, }: CustomEvent<ScrollCoordinateEvent>): void;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    /**
+     * Check if scroll present or not per type
+     * Trigger this method on inner content size change or on outer element size change
+     * If inner content bigger then outer size then scroll is present and mousewheel binding required
+     * @param type - dimension type 'rgRow/y' or 'rgCol/x'
+     * @param size - outer content size
+     * @param innerContentSize - inner content size
+     */
+    setScrollVisibility(type: DimensionType, size: number, innerContentSize: number): void;
+    disconnectedCallback(): void;
+    componentDidRender(): Promise<void>;
+    render(): any;
+    /**
+     * Extra layer for scroll event monitoring, where MouseWheel event is not passing
+     * We need to trigger scroll event in case there is no mousewheel event
+     */
+    applyScroll(type: DimensionType, e: UIEvent): Promise<void>;
+    /**
+     * Applies change on scroll event only if mousewheel event happened some time ago
+     */
+    private applyOnScroll;
+    /**
+     * On vertical mousewheel event
+     * @param type
+     * @param delta
+     * @param e
+     */
+    private onVerticalMouseWheel;
+    /**
+     * On horizontal mousewheel event
+     * @param type
+     * @param delta
+     * @param e
+     */
+    private onHorizontalMouseWheel;
 }
+export {};

package/dist/types/components/scrollable/autohide-scroll.plugin.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Autohide scroll for MacOS when scroll is visible only for 1 sec
+ */
+export declare class AutohideScrollPlugin {
+    private element;
+    private autohideScrollTimeout;
+    constructor(element: HTMLElement);
+    /**
+     * When scroll size updates set it up for autohide
+     */
+    setScrollSize(s: number): void;
+    /**
+     * On each scroll check if it's time to show
+     */
+    checkScroll({ scrollSize, contentSize, virtualSize, }: {
+        scrollSize: number;
+        contentSize: number;
+        virtualSize: number;
+    }): void;
+    private show;
+    clear(): void;
+}

package/dist/types/components/scrollable/revogr-scroll-virtual.d.ts

@@ -1,25 +1,42 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { Observable, RevoGrid } from '../../interfaces';
+import { DimensionType } from '../../types/dimension';
+import { Observable, ViewportState, DimensionSettingsState, ViewPortScrollEvent } from '../../types/interfaces';
+/**
+ * Virtual scroll component
+ */
 export declare class RevogrScrollVirtual {
-  private scrollSize;
-  private isAutoHide;
-  private autoHideTimeout;
-  private scrollService;
-  element: HTMLElement;
-  dimension: RevoGrid.DimensionType;
-  viewportStore: Observable<RevoGrid.ViewportState>;
-  dimensionStore: Observable<RevoGrid.DimensionSettingsState>;
-  scrollVirtual: EventEmitter<RevoGrid.ViewPortScrollEvent>;
-  setScroll(e: RevoGrid.ViewPortScrollEvent): Promise<void>;
-  changeScroll(e: RevoGrid.ViewPortScrollEvent): Promise<RevoGrid.ViewPortScrollEvent>;
-  set size(s: number);
-  get size(): number;
-  connectedCallback(): void;
-  disconnectedCallback(): void;
-  componentWillLoad(): void;
-  componentDidRender(): void;
-  onScroll(e: MouseEvent): void;
-  autoHide(timeout?: number): number;
-  render(): any;
-  private extContentSize;
+    /**
+     * Scroll dimension (`X` - `rgCol` or `Y` - `rgRow`)
+     */
+    dimension: DimensionType;
+    /**
+     * Viewport
+     */
+    viewportStore: Observable<ViewportState>;
+    /**
+     * Dimensions
+     */
+    dimensionStore: Observable<DimensionSettingsState>;
+    /**
+     * Scroll event
+     */
+    scrollVirtual: EventEmitter<ViewPortScrollEvent>;
+    element: HTMLElement;
+    private autohideScrollPlugin;
+    private scrollSize;
+    private localScrollService;
+    private localScrollTimer;
+    setScroll(e: ViewPortScrollEvent): Promise<void>;
+    /**
+     * Update if `delta` exists in case we don't know current position or if it's external change
+     */
+    changeScroll(e: ViewPortScrollEvent): Promise<ViewPortScrollEvent>;
+    set size(s: number);
+    get size(): number;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidRender(): void;
+    onScroll(e: MouseEvent): void;
+    render(): any;
 }

package/dist/types/components/selectionFocus/revogr-focus.d.ts

@@ -1,11 +1,63 @@
-import { Observable, RevoGrid, Selection } from '../../interfaces';
+import { EventEmitter } from '../../stencil-public-runtime';
+import { DSourceState } from '../../store/dataSource/data.store';
+import { SelectionStoreState } from '../../types/selection';
+import { ColumnRegular, DataType, DimensionSettingsState, FocusRenderEvent, FocusTemplateFunc, Observable } from '../../types/interfaces';
+import { DimensionCols, DimensionRows } from '../../types/dimension';
+/**
+ * Focus component. Shows focus layer around the cell that is currently in focus.
+ * @slot focus-${view.type}-${data.type}. @example focus-rgCol-rgRow
+*/
 export declare class RevogrFocus {
-  el: HTMLElement;
-  /** Dynamic stores */
-  selectionStore: Observable<Selection.SelectionStoreState>;
-  dimensionRow: Observable<RevoGrid.DimensionSettingsState>;
-  dimensionCol: Observable<RevoGrid.DimensionSettingsState>;
-  private changed;
-  componentDidRender(): void;
-  render(): any;
+    /**
+     * Column type
+     */
+    colType: DimensionCols;
+    /**
+     * Row type
+     */
+    rowType: DimensionRows;
+    /** Dynamic stores */
+    /** Selection, range, focus for selection */
+    selectionStore: Observable<SelectionStoreState>;
+    /** Dimension settings Y */
+    dimensionRow: Observable<DimensionSettingsState>;
+    /** Dimension settings X */
+    dimensionCol: Observable<DimensionSettingsState>;
+    /**
+     * Data rows source
+     */
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    /**
+     * Column source
+     */
+    colData: Observable<DSourceState<ColumnRegular, DimensionCols>>;
+    /**
+     * Focus template custom function. Can be used to render custom focus layer.
+     */
+    focusTemplate: FocusTemplateFunc | null;
+    /**
+     * Before focus render event.
+     * Can be prevented by event.preventDefault().
+     * If preventDefault used slot will be rendered.
+     */
+    beforeFocusRender: EventEmitter<FocusRenderEvent>;
+    /**
+     * Before focus changed verify if it's in view and scroll viewport into this view
+     * Can be prevented by event.preventDefault()
+     */
+    beforeScrollIntoView: EventEmitter<{
+        el: HTMLElement;
+    }>;
+    /**
+     * Used to setup properties after focus was rendered
+     */
+    afterFocus: EventEmitter<{
+        model: any;
+        column: ColumnRegular;
+    }>;
+    el: HTMLElement;
+    private activeFocus;
+    private changed;
+    componentDidRender(): void;
+    render(): any;
 }