lsp-grid 1.0.0

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

@@ -0,0 +1,39 @@
+/**
+ * Collects data for pinned columns in the required @ViewportProps format.
+ */
+import type { DimensionRows, MultiDimensionType, SlotType, Cell, ViewportColumn, ColumnRegular, DimensionCols, ViewportState, DimensionSettingsState, DataType } from "../../types/index";
+import type { Observable } from '../../utils';
+import type { DSourceState } from '../../store';
+/**
+ * Represents the slot names for the viewport slots.
+ */
+export declare const HEADER_SLOT = "header";
+export declare const FOOTER_SLOT = "footer";
+export declare const CONTENT_SLOT = "content";
+export declare const DATA_SLOT = "data";
+/**
+ * Returns the last visible cell in the viewport for a given row type.
+ * Coordinates are not zero-based and are relative to the viewport.
+ * If needed to be zero-based they can be adjusted by subtracting 1.
+ */
+export declare function getLastCell(data: ViewportColumn, rowType: MultiDimensionType): Cell;
+/**
+ * Represents the partition of viewport data.
+ */
+export type VPPartition = {
+    colData: Observable<DSourceState<ColumnRegular, DimensionCols>>;
+    viewportCol: Observable<ViewportState>;
+    viewportRow: Observable<ViewportState>;
+    lastCell: Cell;
+    slot: SlotType;
+    type: DimensionRows;
+    canDrag: boolean;
+    position: Cell;
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    dimensionCol: Observable<DimensionSettingsState>;
+    dimensionRow: Observable<DimensionSettingsState>;
+    style?: {
+        height: string;
+    };
+};
+export declare function viewportDataPartition(data: ViewportColumn, type: DimensionRows, slot: SlotType, fixed?: boolean): VPPartition;

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

@@ -0,0 +1,17 @@
+type ResizeEntry = {
+    width: number;
+    height: number;
+};
+export default class GridResizeService {
+    private readonly resize;
+    private resizeObserver;
+    private previousSize;
+    readonly apply: import("lodash").DebouncedFunc<(e: {
+        width: number;
+        height: number;
+    }) => void>;
+    constructor(el: HTMLElement, resize: (entry: ResizeEntry, previousSize: ResizeEntry) => void, elements: (HTMLElement | undefined)[]);
+    init(el: HTMLElement, extras?: HTMLElement[]): void;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { DimensionColPin, ViewPortScrollEvent, ElementsScroll, ElementScroll } from "../../types/index";
+export default class GridScrollingService {
+    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 | undefined, key: string): void;
+    unregister(): void;
+}

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

@@ -0,0 +1,59 @@
+import DimensionProvider from '../../services/dimension.provider';
+import { type SelectionStoreConnector } from '../../services/selection.store.connector';
+import ViewportProvider from '../../services/viewport.provider';
+import { OrdererService } from '../order/order-renderer';
+import GridScrollingService from './viewport.scrolling.service';
+import ColumnDataProvider from '../../services/column.data.provider';
+import { DataProvider } from '../../services/data.provider';
+import type { AllDimensionType, Cell, ColumnRegular, DimensionCols, DimensionRows, RangeArea, ViewportProps } from "../../types/index";
+export type ResizeDetails = {
+    [index: number]: ColumnRegular;
+};
+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 type FocusedData = {
+    model: any;
+    cell: Cell;
+    colType: DimensionCols;
+    rowType: DimensionRows;
+    column?: ColumnRegular;
+};
+export default class ViewportService {
+    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;
+    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): Cell | undefined;
+    setFocus(colType: string, rowType: string, start: Cell, end: Cell): void;
+    getSelectedRange(): RangeArea & AllDimensionType | null | undefined;
+    setEdit(rowIndex: number, colIndex: number, colType: DimensionCols, rowType: DimensionRows): void;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { RowHeaders, ViewPortScrollEvent, ViewportData, ElementScroll } from "../../types/index";
+/**
+ * Row headers component
+ * Visible on the left side of the table
+ */
+export declare class RevogrRowHeaders {
+    /**
+     * 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

@@ -0,0 +1,9 @@
+import type { VNode } from '../../stencil-public-runtime';
+import type { HyperFunc } from "../../types/index";
+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

@@ -0,0 +1,117 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { DimensionCols, DimensionType, ElementScroll, ScrollCoordinateEvent, ViewPortResizeEvent, ViewPortScrollEvent } from "../../types/index";
+type Delta = 'deltaX' | 'deltaY';
+type LocalScrollEvent = {
+    preventDefault(): void;
+} & {
+    [x in Delta]: number;
+};
+/**
+ * Viewport scroll component for RevoGrid
+ * @slot - content
+ * @slot header - header
+ * @slot footer - footer
+ */
+export declare class RevogrViewportScroll implements ElementScroll {
+    /**
+     * 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 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 | undefined>;
+    /**
+     * 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

@@ -0,0 +1,43 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { DimensionType, ViewPortScrollEvent } from "../../types/index";
+/**
+ * Virtual scroll component
+ */
+export declare class RevogrScrollVirtual {
+    /**
+     * Scroll dimension (`X` - `rgCol` or `Y` - `rgRow`)
+     */
+    dimension: DimensionType;
+    /**
+     * Dimensions
+     */
+    realSize: number;
+    /**
+     * Virtual size
+     */
+    virtualSize: number;
+    /**
+     * Client size
+     */
+    clientSize: number;
+    /**
+     * 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>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillLoad(): void;
+    componentDidRender(): void;
+    onScroll(e: MouseEvent): void;
+    render(): any;
+}

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

@@ -0,0 +1,58 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { DSourceState } from "../../store/index";
+import type { SelectionStoreState, ColumnRegular, DataType, DimensionSettingsState, FocusRenderEvent, FocusTemplateFunc, DimensionCols, DimensionRows, FocusAfterRenderEvent } from "../../types/index";
+import type { Observable } from '../../utils';
+/**
+ * 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 {
+    /**
+     * 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<FocusAfterRenderEvent>;
+    el: HTMLElement;
+    private activeFocus;
+    componentDidRender(): void;
+    render(): any;
+}

package/dist/types/components/selectionTempRange/revogr-temp-range.d.ts

@@ -0,0 +1,28 @@
+import { DimensionSettingsState, SelectionStoreState } from "../../types/index";
+import type { Observable } from '../../utils';
+/**
+ * Temporary range selection component. Shows temporary range selection.
+ */
+export declare class RevogrFocus {
+    /**
+     * Dynamic stores
+     */
+    /**
+     * Selection store, shows current selection and focus
+     */
+    selectionStore: Observable<SelectionStoreState>;
+    /**
+     * Dimension row store
+     */
+    dimensionRow: Observable<DimensionSettingsState>;
+    /**
+     * Dimension column store
+     */
+    dimensionCol: Observable<DimensionSettingsState>;
+    el?: HTMLElement;
+    private readonly onChange;
+    private doChange;
+    componentDidRender(): void;
+    render(): any;
+    private getRange;
+}

package/dist/types/components/vnode/vnode-converter.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter, type VNode } from '../../stencil-public-runtime';
+/**
+ * VNode to html converter for stencil components.
+ * Transform VNode to html string.
+ */
+/**
+ * @internal
+ */
+export declare class VNodeToHtml {
+    redraw: (() => VNode[]) | null | undefined;
+    html: EventEmitter<{
+        html: string;
+        vnodes: (VNode[]) | null;
+    }>;
+    el: HTMLElement;
+    private vnodes;
+    componentDidRender(): void;
+    render(): any;
+}

package/dist/types/components/vnode/vnode.utils.d.ts

@@ -0,0 +1,9 @@
+import { type VNode } from '../../stencil-public-runtime';
+import { type JSX } from '../../components';
+/**
+ * Converts a VNode element into an HTML element and appends it to the specified parentHolder.
+ */
+export declare function convertVNodeToHTML(parentHolder: Element, redraw: JSX.VnodeHtml['redraw']): Promise<{
+    html: string;
+    vnodes: (VNode[]) | null;
+}>;