lsp-grid 1.0.0

package/dist/types/components/overlay/revogr-overlay-selection.d.ts

@@ -0,0 +1,278 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import ColumnService from '../data/column.service';
+import { type DSourceState } from "../../store/index";
+import { EventData } from './selection.utils';
+import { type Observable } from '../../utils';
+import type { SelectionStoreState, DimensionSettingsState, DataType, DimensionRows, ColumnRegular, DimensionCols, DragStartEvent, Cell, MultiDimensionType, Nullable, RangeClipboardCopyEventProps, RangeClipboardPasteEvent, FocusRenderEvent, ApplyFocusEvent, AllDimensionType, Editors, BeforeSaveDataDetails, BeforeEdit, RangeArea, TempRange, ChangedRange, BeforeRangeSaveDataDetails, SaveDataDetails, EditCellStore } from "../../types/index";
+/**
+ * Component for overlaying the grid with the selection.
+ */
+export declare class OverlaySelection {
+    /**
+     * Readonly mode.
+     */
+    readonly: boolean;
+    /**
+     * Range selection allowed.
+     */
+    range: boolean;
+    /**
+     * Enable revogr-order-editor component (read more in revogr-order-editor component).
+     * Allows D&D.
+     */
+    canDrag: boolean;
+    /**
+     * Enable revogr-clipboard component (read more in revogr-clipboard component).
+     * Allows copy/paste.
+     */
+    useClipboard: boolean;
+    /** Stores */
+    /** Selection, range, focus. */
+    selectionStore: Observable<SelectionStoreState>;
+    /** Dimension settings Y. */
+    dimensionRow: Observable<DimensionSettingsState>;
+    /** Dimension settings X. */
+    dimensionCol: Observable<DimensionSettingsState>;
+    /**
+     * Row data store.
+     */
+    dataStore: Observable<DSourceState<DataType, DimensionRows>>;
+    /**
+     * Column data store.
+     */
+    colData: Observable<DSourceState<ColumnRegular, DimensionCols>>;
+    /**
+     * Last real coordinates positions + 1.
+     */
+    lastCell: Cell;
+    /**
+     * Custom editors register.
+     */
+    editors: Editors;
+    /**
+     * If true applys changes when cell closes if not Escape.
+     */
+    applyChangesOnClose: boolean;
+    /**
+     * Additional data to pass to renderer.
+     */
+    additionalData: any;
+    /**
+     * Is mobile view mode.
+     */
+    isMobileDevice: boolean;
+    /**
+     * Before clipboard copy happened. Validate data before copy.
+     * To prevent the default behavior of editing data and use your own implementation, call `e.preventDefault()`.
+     */
+    beforeCopyRegion: EventEmitter;
+    /**
+     * Before region paste happened.
+     */
+    beforeRegionPaste: EventEmitter;
+    /**
+     * Cell edit apply to the data source.
+     * Triggers datasource edit on the root level.
+     */
+    cellEditApply: EventEmitter<BeforeSaveDataDetails>;
+    /**
+     * Before cell focus.
+     */
+    beforeFocusCell: EventEmitter<BeforeSaveDataDetails>;
+    /**
+     * Fired when change of viewport happens.
+     * Usually when we switch between pinned regions.
+     */
+    beforeNextViewportFocus: EventEmitter<Cell>;
+    /**
+     * Set edit cell.
+     */
+    setEdit: EventEmitter<BeforeEdit>;
+    /**
+     * Before range applied.
+     * First step in triggerRangeEvent.
+     */
+    beforeApplyRange: EventEmitter<FocusRenderEvent>;
+    /**
+     * Before range selection applied.
+     * Second step in triggerRangeEvent.
+     */
+    beforeSetRange: EventEmitter;
+    /**
+     * Set range.
+     * Third step in triggerRangeEvent.
+     */
+    setRange: EventEmitter<RangeArea & {
+        type: MultiDimensionType;
+    }>;
+    /**
+     * Before editor render.
+     */
+    beforeEditRender: EventEmitter<FocusRenderEvent>;
+    /** Select all cells from keyboard. */
+    selectAll: EventEmitter;
+    /**
+     * Cancel edit. Used for editors support when editor close requested.
+     */
+    cancelEdit: EventEmitter;
+    /** Back action from keyboard */
+    rollback: EventEmitter;
+    /**
+     * Set temp range area during autofill.
+     */
+    setTempRange: EventEmitter<Nullable<TempRange> | null>;
+    /**
+     * Before set temp range area during autofill.
+     */
+    beforeSetTempRange: EventEmitter<{
+        tempRange: Nullable<TempRange> | null;
+    } & EventData & AllDimensionType>;
+    /**
+     * Before cell get focused.
+     * To prevent the default behavior of applying the edit data, you can call `e.preventDefault()`.
+     */
+    applyFocus: EventEmitter<FocusRenderEvent>;
+    /**
+     * Cell get focused.
+     * To prevent the default behavior of applying the edit data, you can call `e.preventDefault()`.
+     */
+    focusCell: EventEmitter<ApplyFocusEvent & FocusRenderEvent>;
+    /** Range data apply. */
+    beforeRangeDataApply: EventEmitter<FocusRenderEvent>;
+    /** Autofill data in range. First step in applyRangeWithData */
+    selectionChange: EventEmitter<ChangedRange>;
+    /** Before range copy. */
+    beforeRangeCopyApply: EventEmitter<ChangedRange>;
+    /** Range data apply.
+     * Triggers datasource edit on the root level.
+     */
+    rangeEditApply: EventEmitter<BeforeRangeSaveDataDetails>;
+    /** Range copy. */
+    /**
+     * Range copy event.
+     * This event is triggered when data is ready to be copied to the clipboard.
+     * If you want to prevent the default behavior of copying data, you can call `e.preventDefault()`.
+     * If you want to modify the data that will be copied to the clipboard, modify the `data` property of the event object.
+     */
+    rangeClipboardCopy: EventEmitter<RangeClipboardCopyEventProps>;
+    /**
+     * Range paste event.
+     */
+    rangeClipboardPaste: EventEmitter<RangeClipboardPasteEvent>;
+    /**
+     * Before key up event proxy, used to prevent key up trigger.
+     * If you have some custom behaviour event, use this event to check if it wasn't processed by internal logic.
+     * Call preventDefault().
+     */
+    beforeKeyDown: EventEmitter<{
+        original: KeyboardEvent;
+    } & EventData>;
+    /**
+     * Before key down event proxy, used to prevent key down trigger.
+     * If you have some custom behaviour event, use this event to check if it wasn't processed by internal logic.
+     * Call preventDefault().
+     */
+    beforeKeyUp: EventEmitter<{
+        original: KeyboardEvent;
+    } & EventData>;
+    /**
+     * Runs before cell save.
+     * Can be used to override or cancel original save.
+     */
+    beforeCellSave: EventEmitter;
+    /**
+     * Runs when edit finished save started, first in chain event
+     */
+    cellEditDone: EventEmitter<SaveDataDetails>;
+    element: HTMLElement;
+    private clipboard?;
+    protected columnService: ColumnService;
+    private keyboardService;
+    private autoFillService;
+    private orderEditor?;
+    private revogrEdit?;
+    private unsubscribeSelectionStore;
+    onMouseMove(e: MouseEvent | TouchEvent): void;
+    /**
+     * Action finished inside the document.
+     * Pointer left document, clear any active operation.
+     */
+    onMouseUp(): void;
+    /**
+     * Row drag started.
+     * This event is fired when drag action started on cell.
+     */
+    onCellDrag(e: CustomEvent<DragStartEvent>): void;
+    /**
+     * Get keyboard down from element.
+     * This event is fired when keyboard key is released.
+     */
+    onKeyUp(e: KeyboardEvent): void;
+    /**
+     * Get keyboard down from element.
+     * This event is fired when keyboard key is pressed.
+     */
+    onKeyDown(e: KeyboardEvent): void;
+    /**
+     * Selection & Keyboard
+     */
+    selectionServiceSet(selectionStore: Observable<SelectionStoreState>): void;
+    /** Autofill */
+    createAutoFillService(): void;
+    /** Columns */
+    columnServiceSet(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    componentWillRender(): Promise<void>;
+    private renderRange;
+    private renderEditor;
+    private onEditCell;
+    render(): any;
+    /**
+     * Executes the focus operation on the specified range of cells.
+     */
+    private doFocus;
+    private triggerRangeEvent;
+    /**
+     * Open Editor on DblClick
+     */
+    private onElementDblClick;
+    /**
+     * Handle mouse down event on Host element
+     */
+    private onElementMouseDown;
+    /**
+     * Start cell editing
+     */
+    protected doEdit(val?: string): void;
+    /**
+     * Close editor event triggered
+     * @param details - if it requires focus next
+     */
+    private closeEdit;
+    /**
+     * Edit finished.
+     * Close Editor and save.
+     */
+    protected cellEdit(e: SaveDataDetails): void;
+    private getRegion;
+    private onCopy;
+    private onPaste;
+    private focusNext;
+    protected clearCell(): void;
+    private rowDragStart;
+    /**
+     * Verify if edit allowed.
+     */
+    protected canEdit(): boolean | null;
+    get edited(): EditCellStore | null;
+    /**
+     * Sets the focus on a cell and optionally edits a range.
+     */
+    focus(cell?: Cell, isRangeEdit?: boolean, isPrevent?: boolean): boolean;
+    get types(): AllDimensionType;
+    /**
+     * Collect data
+     */
+    protected getData(): EventData;
+}

package/dist/types/components/overlay/selection.utils.d.ts

@@ -0,0 +1,47 @@
+import { DimensionIndexInput, DSourceState } from "../../store/index";
+import type { DimensionSettingsState, Cell, RangeArea, RangeAreaCss, DataLookup, DimensionRows, DataType, EditCellStore } from "../../types/index";
+import { Observable } from '../../utils';
+export type EventData = {
+    el: HTMLElement;
+    rows: DimensionSettingsState;
+    cols: DimensionSettingsState;
+    lastCell: Cell;
+    focus: Cell | null;
+    range: RangeArea | null;
+    edit: EditCellStore | null;
+};
+export declare function collectModelsOfRange(data: DataLookup, store: Observable<DSourceState<DataType, DimensionRows>>): Partial<DataLookup>;
+export declare function getFocusCellBasedOnEvent(e: MouseEvent | TouchEvent, data: EventData): Cell | null;
+/**
+ * Calculate cell based on x, y position
+ */
+export declare function getCurrentCell({ x, y }: Cell, { el, rows, cols }: Pick<EventData, 'el' | 'rows' | 'cols'>): Cell;
+export declare function getCoordinate(range: RangeArea, focus: Cell, changes: Partial<Cell>, isMulti?: boolean): {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+} | null;
+/**
+ * Check if the x coordinate of the cell position is after or equal to the x coordinate of the last cell position
+ * or if the y coordinate of the cell position is after or equal to the y coordinate of the last cell position
+ */
+export declare function isAfterLast({ x, y }: Cell, lastCell: Cell): boolean;
+/** check if out of range */
+export declare function isBeforeFirst({ x, y }: Cell): boolean;
+/** Compare cells, only 1 coordinate difference is possible */
+export declare function styleByCellProps(styles: {
+    [key: string]: number;
+}): RangeAreaCss;
+export declare function getCell({ x, y, x1, y1 }: RangeArea, dimensionRow: Pick<DimensionIndexInput, 'indexToItem' | 'indexes' | 'originItemSize'>, dimensionCol: Pick<DimensionIndexInput, 'indexToItem' | 'indexes' | 'originItemSize'>): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,17 @@
+import { RowDefinition } from "../../types/index";
+export declare const rowDefinitionByType: (newVal?: RowDefinition[]) => Partial<{
+    rowPinStart: {
+        sizes?: Record<number, number>;
+    };
+    rowPinEnd: {
+        sizes?: Record<number, number>;
+    };
+    rgRow: {
+        sizes?: Record<number, number>;
+    };
+}>;
+export declare const rowDefinitionRemoveByType: (oldVal?: RowDefinition[]) => Partial<{
+    rowPinStart: number[];
+    rowPinEnd: number[];
+    rgRow: number[];
+}>;

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

@@ -0,0 +1,37 @@
+import { PluginBaseComponent, PluginProviders, PluginServiceBase } from "../../types/index";
+import { GridPlugin } from "../../plugins/index";
+/**
+ * Plugin service
+ * Manages plugins
+ */
+export declare class PluginService implements PluginServiceBase {
+    /**
+     * Plugins
+     * Define plugins collection
+     */
+    internalPlugins: PluginBaseComponent[];
+    /**
+     * Get all plugins
+     */
+    get(): PluginBaseComponent[];
+    /**
+     * Add plugin to collection
+     */
+    add(plugin: PluginBaseComponent): void;
+    /**
+     * Add user plugins and create
+     */
+    addUserPluginsAndCreate(element: HTMLRevoGridElement, plugins?: GridPlugin[], prevPlugins?: GridPlugin[], pluginData?: PluginProviders): void;
+    /**
+     * Get plugin by class
+     */
+    getByClass<T extends PluginBaseComponent>(pluginClass: new (...args: any[]) => T): T | undefined;
+    /**
+     * Remove plugin
+     */
+    remove(plugin: PluginBaseComponent): void;
+    /**
+     * Remove all plugins
+     */
+    destroy(): void;
+}