@revolist/revogrid 4.0.4-next → 4.0.4

package/dist/collection/components/overlay/revogr-overlay-selection.js

@@ -1,723 +1,1228 @@
-import { Component, Event, h, Host, Listen, Prop, Element, Watch } from '@stencil/core';
-import ColumnService from '../data/columnService';
-import SelectionStoreService from '../../store/selection/selection.store.service';
-import { codesLetter } from '../../utils/keyCodes';
-import { SELECTION_BORDER_CLASS } from '../../utils/consts';
-import { isRangeSingleCell } from '../../store/selection/selection.helpers';
-import { getCurrentCell, getElStyle } from './selection.utils';
-import { isEditInput } from './editors/edit.utils';
-import { KeyboardService } from './keyboard.service';
-import { AutoFillService } from './autofill.service';
-import { ClipboardService } from './clipboard.service';
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { h, Host, } from "@stencil/core";
+import ColumnService from "../data/column.service";
+import SelectionStoreService from "../../store/selection/selection.store.service";
+import { codesLetter } from "../../utils/key.codes";
+import { MOBILE_CLASS, SELECTION_BORDER_CLASS } from "../../utils/consts";
+import { getRange, isRangeSingleCell } from "../../store/selection/selection.helpers";
+import { getCurrentCell, getElStyle } from "./selection.utils";
+import { isEditInput } from "../editors/edit.utils";
+import { KeyboardService } from "./keyboard.service";
+import { AutoFillService } from "./autofill.service";
+import { getFromEvent, verifyTouchTarget } from "../../utils/events";
 export class OverlaySelection {
-  constructor() {
-    this.keyboardService = null;
-    this.autoFillService = null;
-    this.clipboardService = null;
-  }
-  // --------------------------------------------------------------------------
-  //
-  //  Listeners
-  //
-  // --------------------------------------------------------------------------
-  onMouseMove(e) {
-    if (this.selectionStoreService.focused) {
-      this.autoFillService.selectionMouseMove(e);
-    }
-  }
-  /** Pointer left document, clear any active operation */
-  onMouseOut() {
-    this.autoFillService.clearAutoFillSelection();
-  }
-  /** Action finished inside of the document */
-  onMouseUp() {
-    this.autoFillService.clearAutoFillSelection();
-  }
-  /** Row drag started */
-  onCellDrag(e) {
-    var _a;
-    (_a = this.orderEditor) === null || _a === void 0 ? void 0 : _a.dragStart(e.detail);
-  }
-  /** Recived keyboard down from element */
-  onKeyUp(e) {
-    var _a;
-    (_a = this.keyboardService) === null || _a === void 0 ? void 0 : _a.keyUp(e);
-  }
-  /** Recived keyboard down from element */
-  onKeyDown(e) {
-    var _a;
-    (_a = this.keyboardService) === null || _a === void 0 ? void 0 : _a.keyDown(e, this.range);
-  }
-  /** Create selection store */
-  selectionServiceSet(s) {
-    this.selectionStoreService = new SelectionStoreService(s, {
-      changeRange: range => { var _a; return !((_a = this.setRange.emit(range)) === null || _a === void 0 ? void 0 : _a.defaultPrevented); },
-      focus: (focus, end) => {
+    constructor() {
+        this.keyboardService = null;
+        this.autoFillService = null;
+        this.revogrEdit = null;
+        this.readonly = undefined;
+        this.range = undefined;
+        this.canDrag = undefined;
+        this.useClipboard = undefined;
+        this.selectionStore = undefined;
+        this.dimensionRow = undefined;
+        this.dimensionCol = undefined;
+        this.dataStore = undefined;
+        this.colData = undefined;
+        this.lastCell = undefined;
+        this.editors = undefined;
+        this.applyChangesOnClose = false;
+        this.additionalData = undefined;
+        this.isMobileDevice = undefined;
+    }
+    // #endregion
+    // #region Listeners
+    onMouseMove(e) {
+        if (this.selectionStoreService.focused) {
+            this.autoFillService.selectionMouseMove(e);
+        }
+    }
+    /** Action finished inside of the document. */
+    /** Pointer left document, clear any active operation. */
+    onMouseUp() {
+        this.autoFillService.clearAutoFillSelection();
+    }
+    /** Row drag started. */
+    onCellDrag(e) {
+        var _a;
+        (_a = this.orderEditor) === null || _a === void 0 ? void 0 : _a.dragStart(e.detail);
+    }
+    /** Get keyboard down from element. */
+    onKeyUp(e) {
+        this.beforeKeyUp.emit(e);
+    }
+    /** Get keyboard down from element. */
+    onKeyDown(e) {
+        var _a;
+        const proxy = this.beforeKeyDown.emit(e);
+        if (e.defaultPrevented || proxy.defaultPrevented) {
+            return;
+        }
+        (_a = this.keyboardService) === null || _a === void 0 ? void 0 : _a.keyDown(e, this.range);
+    }
+    // #endregion
+    /** Selection & Keyboard */
+    selectionServiceSet(s) {
+        this.selectionStoreService = new SelectionStoreService(s, {
+            changeRange: range => this.triggerRangeEvent(range),
+            focus: (focus, end) => this.doFocus(focus, end),
+        });
+        this.keyboardService = new KeyboardService({
+            selectionStoreService: this.selectionStoreService,
+            selectionStore: s,
+            range: r => this.selectionStoreService.changeRange(r),
+            focusNext: (f, next) => this.doFocus(f, f, next),
+            change: val => {
+                if (this.readonly) {
+                    return;
+                }
+                this.doEdit(val);
+            },
+            cancel: async () => {
+                await this.revogrEdit.cancelChanges();
+                this.closeEdit();
+            },
+            clearCell: () => !this.readonly && this.clearCell(),
+            internalPaste: () => !this.readonly && this.beforeRegionPaste.emit(),
+            getData: () => this.getData(),
+            selectAll: () => this.selectAll.emit(),
+        });
+        this.createAutoFillService();
+    }
+    /** Autofill */
+    createAutoFillService() {
+        this.autoFillService = new AutoFillService({
+            selectionStoreService: this.selectionStoreService,
+            dimensionRow: this.dimensionRow,
+            dimensionCol: this.dimensionCol,
+            columnService: this.columnService,
+            dataStore: this.dataStore,
+            clearRangeDataApply: e => this.beforeRangeDataApply.emit(Object.assign(Object.assign({}, e), this.types)),
+            setTempRange: e => this.setTempRange.emit(e),
+            selectionChanged: e => this.selectionChange.emit(e),
+            rangeCopy: e => this.beforeRangeCopyApply.emit(e),
+            rangeDataApply: e => this.rangeEditApply.emit(e),
+            setRange: e => this.triggerRangeEvent(e),
+            getData: () => this.getData(),
+        });
+    }
+    /** Columns */
+    columnServiceSet() {
+        var _a;
+        (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.columnService = new ColumnService(this.dataStore, this.colData);
+        this.createAutoFillService();
+    }
+    connectedCallback() {
+        this.columnServiceSet();
+        this.selectionServiceSet(this.selectionStore);
+    }
+    disconnectedCallback() {
         var _a;
-        const focused = { focus, end };
-        const { defaultPrevented } = this.internalFocusCell.emit(this.columnService.getSaveData(focus.y, focus.x));
+        (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
+    }
+    async componentWillRender() {
+        var _a, _b;
+        const editCell = this.selectionStore.get('edit');
+        if (!editCell) {
+            await ((_b = (_a = this.revogrEdit) === null || _a === void 0 ? void 0 : _a.beforeDisconnect) === null || _b === void 0 ? void 0 : _b.call(_a));
+        }
+    }
+    renderRange(range) {
+        const style = getElStyle(range, this.dimensionRow.state, this.dimensionCol.state);
+        return [
+            h("div", { class: SELECTION_BORDER_CLASS, style: style }, this.isMobileDevice && (h("div", { class: "range-handlers" }, h("span", { class: MOBILE_CLASS }), h("span", { class: MOBILE_CLASS })))),
+        ];
+    }
+    renderEditor() {
+        // Check if edit access
+        const editCell = this.selectionStore.get('edit');
+        // Readonly or Editor closed
+        if (this.readonly || !editCell) {
+            return null;
+        }
+        const val = editCell.val || this.columnService.getCellData(editCell.y, editCell.x);
+        const editable = Object.assign(Object.assign({}, editCell), this.columnService.getSaveData(editCell.y, editCell.x, val));
+        const renderEvent = this.beforeEditRender.emit(Object.assign({ range: Object.assign(Object.assign({}, editCell), { x1: editCell.x, y1: editCell.y }) }, this.types));
+        // Render prevented
+        if (renderEvent.defaultPrevented) {
+            return null;
+        }
+        const style = getElStyle(renderEvent.detail.range, this.dimensionRow.state, this.dimensionCol.state);
+        return (h("revogr-edit", { style: style, ref: el => (this.revogrEdit = el), additionalData: this.additionalData, editCell: editable, saveOnClose: this.applyChangesOnClose, column: this.columnService.columns[editCell.x], editor: this.columnService.getCellEditor(editCell.y, editCell.x, this.editors), onCloseedit: e => this.closeEdit(e), onCelledit: e => {
+                const saveEv = this.beforeCellSave.emit(e.detail);
+                if (!saveEv.defaultPrevented) {
+                    this.cellEdit(saveEv.detail);
+                }
+                // if not clear navigate to next cell after edit
+                if (!saveEv.detail.preventFocus) {
+                    this.focusNext();
+                }
+            } }));
+    }
+    render() {
+        const nodes = [];
+        const editCell = this.renderEditor();
+        // Editor
+        if (editCell) {
+            nodes.push(editCell);
+        }
+        else {
+            const range = this.selectionStoreService.ranged;
+            const selectionFocus = this.selectionStoreService.focused;
+            // Clipboard
+            if ((range || selectionFocus) && this.useClipboard) {
+                nodes.push(h("revogr-clipboard", { readonly: this.readonly, onCopyregion: e => this.onCopy(e.detail), onClearregion: () => !this.readonly && this.clearCell(), ref: e => (this.clipboard = e), onPasteregion: e => this.onPaste(e.detail) }));
+            }
+            // Range
+            if (range) {
+                nodes.push(...this.renderRange(range));
+            }
+            // Autofill
+            if (selectionFocus && !this.readonly && this.range) {
+                nodes.push(this.autoFillService.renderAutofill(range, selectionFocus));
+            }
+            // Order
+            if (this.canDrag) {
+                nodes.push(h("revogr-order-editor", { ref: e => (this.orderEditor = e), dataStore: this.dataStore, dimensionRow: this.dimensionRow, dimensionCol: this.dimensionCol, parent: this.element, onRowdragstartinit: e => this.rowDragStart(e) }));
+            }
+        }
+        return (h(Host, { key: '1bf980bd953bd6743607eeafeb7666a8d8fdf9df', class: { mobile: this.isMobileDevice },
+            // Open Editor on DblClick
+            onDblClick: (e) => {
+                // DblClick prevented outside - Editor will not open
+                if (!e.defaultPrevented) {
+                    this.doEdit();
+                }
+            }, onMouseDown: (e) => this.onElementMouseDown(e), onTouchStart: (e) => this.onElementMouseDown(e, true) }, nodes, h("slot", { key: '53fb45eee4024c8ab29275c6dff3f708e011f007', name: "data" })));
+    }
+    doFocus(focus, end, next) {
+        const { defaultPrevented } = this.beforeFocusCell.emit(this.columnService.getSaveData(focus.y, focus.x));
         if (defaultPrevented) {
-          return false;
+            return false;
         }
-        return !((_a = this.focusCell.emit(focused)) === null || _a === void 0 ? void 0 : _a.defaultPrevented);
-      },
-    });
-    this.keyboardService = new KeyboardService({
-      selectionStoreService: this.selectionStoreService,
-      selectionStore: s,
-      doEdit: (v, c) => this.doEdit(v, c),
-      clearCell: () => this.clearCell(),
-      getData: () => this.getData(),
-      internalPaste: () => this.internalPaste.emit()
-    });
-    this.createAutoFillService();
-    this.createClipboardService();
-  }
-  createAutoFillService() {
-    this.autoFillService = new AutoFillService({
-      selectionStoreService: this.selectionStoreService,
-      dimensionRow: this.dimensionRow,
-      dimensionCol: this.dimensionCol,
-      columnService: this.columnService,
-      dataStore: this.dataStore,
-      setTempRange: (e) => this.setTempRange.emit(e),
-      internalSelectionChanged: (e) => this.internalSelectionChanged.emit(e),
-      internalRangeDataApply: (e) => this.internalRangeDataApply.emit(e),
-      setRange: (e) => this.setRange.emit(e),
-      getData: () => this.getData(),
-    });
-  }
-  columnServiceSet() {
-    var _a;
-    (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
-    this.columnService = new ColumnService(this.dataStore, this.colData);
-    this.createAutoFillService();
-    this.createClipboardService();
-  }
-  createClipboardService() {
-    this.clipboardService = new ClipboardService({
-      selectionStoreService: this.selectionStoreService,
-      columnService: this.columnService,
-      dataStore: this.dataStore,
-      onRangeApply: (d, r) => this.autoFillService.onRangeApply(d, r),
-      internalCopy: () => this.internalCopy.emit()
-    });
-  }
-  connectedCallback() {
-    this.columnServiceSet();
-    this.selectionServiceSet(this.selectionStore);
-  }
-  disconnectedCallback() {
-    var _a;
-    (_a = this.columnService) === null || _a === void 0 ? void 0 : _a.destroy();
-  }
-  renderRange(range) {
-    const style = getElStyle(range, this.dimensionRow.state, this.dimensionCol.state);
-    return [h("div", { class: SELECTION_BORDER_CLASS, style: style })];
-  }
-  renderEditCell() {
-    // if can edit
-    const editCell = this.selectionStore.get('edit');
-    if (this.readonly || !editCell) {
-      return;
-    }
-    const val = editCell.val || this.columnService.getCellData(editCell.y, editCell.x);
-    const editable = Object.assign(Object.assign({}, editCell), this.columnService.getSaveData(editCell.y, editCell.x, val));
-    const style = getElStyle(Object.assign(Object.assign({}, editCell), { x1: editCell.x, y1: editCell.y }), this.dimensionRow.state, this.dimensionCol.state);
-    return (h("revogr-edit", { onCellEdit: e => this.onCellEdit(e.detail), onCloseEdit: e => this.closeEdit(e), editCell: editable, column: this.columnService.columns[editCell.x], editor: this.columnService.getCellEditor(editCell.y, editCell.x, this.editors), style: style }));
-  }
-  render() {
-    const range = this.selectionStoreService.ranged;
-    const selectionFocus = this.selectionStoreService.focused;
-    const els = [];
-    if ((range || selectionFocus) && this.useClipboard) {
-      els.push(this.clipboardService.renderClipboard());
-    }
-    if (range) {
-      els.push(...this.renderRange(range));
-    }
-    const editCell = this.renderEditCell();
-    if (editCell) {
-      els.push(editCell);
-    }
-    if (selectionFocus && !this.readonly && !editCell && this.range) {
-      els.push(this.autoFillService.renderAutofill(range, selectionFocus));
-    }
-    if (this.canDrag) {
-      els.push(h("revogr-order-editor", { ref: e => (this.orderEditor = e), dataStore: this.dataStore, dimensionRow: this.dimensionRow, dimensionCol: this.dimensionCol, parent: this.element, onInternalRowDragStart: e => this.onRowDragStart(e) }));
-    }
-    return (h(Host, { onDblClick: () => this.doEdit(), onMouseDown: (e) => this.onElementMouseDown(e) },
-      els,
-      h("slot", { name: "data" })));
-  }
-  onElementMouseDown(e) {
-    // Ignore focus if clicked input
-    if (isEditInput(e.target)) {
-      return;
-    }
-    const data = this.getData();
-    if (e.defaultPrevented) {
-      return;
-    }
-    // Regular cell click
-    const focusCell = getCurrentCell({ x: e.x, y: e.y }, data);
-    this.selectionStoreService.focus(focusCell, this.range && e.shiftKey);
-    // Initiate autofill selection
-    if (this.range) {
-      this.autoFillService.selectionStart(e, data);
-    }
-  }
-  doEdit(val = '', isCancel = false) {
-    var _a;
-    if (this.canEdit()) {
-      const editCell = this.selectionStore.get('focus');
-      const data = this.columnService.getSaveData(editCell.y, editCell.x);
-      (_a = this.setEdit) === null || _a === void 0 ? void 0 : _a.emit(Object.assign(Object.assign({}, data), { isCancel,
-        val }));
-    }
-  }
-  closeEdit(e) {
-    this.doEdit(undefined, true);
-    if (e === null || e === void 0 ? void 0 : e.detail) {
-      this.focusNext();
-    }
-  }
-  async focusNext() {
-    const canFocus = await this.keyboardService.keyChangeSelection(new KeyboardEvent('keydown', {
-      code: codesLetter.ARROW_DOWN,
-    }), this.range);
-    if (!canFocus) {
-      this.closeEdit();
-    }
-  }
-  clearCell() {
-    if (this.selectionStoreService.ranged && !isRangeSingleCell(this.selectionStoreService.ranged)) {
-      const data = this.columnService.getRangeStaticData(this.selectionStoreService.ranged, '');
-      this.autoFillService.onRangeApply(data, this.selectionStoreService.ranged);
-    }
-    else if (this.canEdit()) {
-      const focused = this.selectionStoreService.focused;
-      this.onCellEdit({ rgRow: focused.y, rgCol: focused.x, val: '' }, true);
-    }
-  }
-  /** Edit finished, close cell and save */
-  onCellEdit(e, clear = false) {
-    const dataToSave = this.columnService.getSaveData(e.rgRow, e.rgCol, e.val);
-    this.internalCellEdit.emit(dataToSave);
-    // if not clear navigate to next cell after edit
-    if (!clear && !e.preventFocus) {
-      this.focusNext();
-    }
-  }
-  onRowDragStart({ detail }) {
-    detail.text = this.columnService.getCellData(detail.cell.y, detail.cell.x);
-  }
-  /** Check if edit possible */
-  canEdit() {
-    var _a;
-    if (this.readonly) {
-      return false;
-    }
-    const editCell = this.selectionStoreService.focused;
-    return editCell && !((_a = this.columnService) === null || _a === void 0 ? void 0 : _a.isReadOnly(editCell.y, editCell.x));
-  }
-  /** Collect data from element */
-  getData() {
-    return {
-      el: this.element,
-      rows: this.dimensionRow.state,
-      cols: this.dimensionCol.state,
-      lastCell: this.lastCell,
-    };
-  }
-  static get is() { return "revogr-overlay-selection"; }
-  static get originalStyleUrls() { return {
-    "$": ["revogr-overlay-style.scss"]
-  }; }
-  static get styleUrls() { return {
-    "$": ["revogr-overlay-style.css"]
-  }; }
-  static get properties() { return {
-    "readonly": {
-      "type": "boolean",
-      "mutable": false,
-      "complexType": {
-        "original": "boolean",
-        "resolved": "boolean",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "readonly",
-      "reflect": false
-    },
-    "range": {
-      "type": "boolean",
-      "mutable": false,
-      "complexType": {
-        "original": "boolean",
-        "resolved": "boolean",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "range",
-      "reflect": false
-    },
-    "canDrag": {
-      "type": "boolean",
-      "mutable": false,
-      "complexType": {
-        "original": "boolean",
-        "resolved": "boolean",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "can-drag",
-      "reflect": false
-    },
-    "useClipboard": {
-      "type": "boolean",
-      "mutable": false,
-      "complexType": {
-        "original": "boolean",
-        "resolved": "boolean",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "attribute": "use-clipboard",
-      "reflect": false
-    },
-    "selectionStore": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<Selection.SelectionStoreState>",
-        "resolved": "ObservableMap<SelectionStoreState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        const evData = Object.assign({ range: Object.assign(Object.assign({}, focus), { x1: end.x, y1: end.y }), next }, this.types);
+        const applyEvent = this.applyFocus.emit(evData);
+        if (applyEvent.defaultPrevented) {
+            return false;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Dynamic stores"
-      }
-    },
-    "dimensionRow": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<RevoGrid.DimensionSettingsState>",
-        "resolved": "ObservableMap<DimensionSettingsState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        const { range } = applyEvent.detail;
+        return !this.focusCell.emit(Object.assign({ focus: {
+                x: range.x,
+                y: range.y,
+            }, end: {
+                x: range.x1,
+                y: range.y1,
+            } }, applyEvent.detail)).defaultPrevented;
+    }
+    triggerRangeEvent(range) {
+        const type = this.types.rowType;
+        const applyEvent = this.beforeApplyRange.emit(Object.assign({ range: Object.assign({}, range) }, this.types));
+        if (applyEvent.defaultPrevented) {
+            return false;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "dimensionCol": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<RevoGrid.DimensionSettingsState>",
-        "resolved": "ObservableMap<DimensionSettingsState>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        const data = this.columnService.getRangeTransformedToProps(applyEvent.detail.range, this.dataStore);
+        let e = this.beforeSetRange.emit(data);
+        e = this.setRange.emit(Object.assign(Object.assign({}, applyEvent.detail.range), { type }));
+        if (e.defaultPrevented) {
+            return false;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "dataStore": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<DataSourceState<RevoGrid.DataType, RevoGrid.DimensionRows>>",
-        "resolved": "ObservableMap<DataSourceState<DataType, DimensionRows>>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "DataSourceState": {
-            "location": "import",
-            "path": "../../store/dataSource/data.store"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        return !e.defaultPrevented;
+    }
+    onElementMouseDown(e, touch = false) {
+        // Ignore focus if clicked input
+        if (isEditInput(e.target)) {
+            return;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Static stores, not expected to change during component lifetime"
-      }
-    },
-    "colData": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Observable<DataSourceState<RevoGrid.ColumnRegular, RevoGrid.DimensionCols>>",
-        "resolved": "ObservableMap<DataSourceState<ColumnRegular, DimensionCols>>",
-        "references": {
-          "Observable": {
-            "location": "import",
-            "path": "../../interfaces"
-          },
-          "DataSourceState": {
-            "location": "import",
-            "path": "../../store/dataSource/data.store"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        const data = this.getData();
+        if (e.defaultPrevented) {
+            return;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": ""
-      }
-    },
-    "lastCell": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Selection.Cell",
-        "resolved": "Cell",
-        "references": {
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        const x = getFromEvent(e, 'clientX');
+        const y = getFromEvent(e, 'clientY');
+        // skip touch
+        if (x === null || y === null) {
+            return;
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Last cell position"
-      }
-    },
-    "editors": {
-      "type": "unknown",
-      "mutable": false,
-      "complexType": {
-        "original": "Edition.Editors",
-        "resolved": "{ [name: string]: EditorCtr; }",
-        "references": {
-          "Edition": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        // Regular cell click
+        const focusCell = getCurrentCell({ x, y }, data);
+        this.selectionStoreService.focus(focusCell, this.range && e.shiftKey);
+        // Initiate autofill selection
+        if (this.range) {
+            this.autoFillService.selectionStart(e.target, data);
+            if (!touch) {
+                e.preventDefault();
+            }
+            else if (verifyTouchTarget(e.touches[0], MOBILE_CLASS)) {
+                e.preventDefault();
+            }
         }
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Custom editors register"
-      }
-    }
-  }; }
-  static get events() { return [{
-      "method": "internalCopy",
-      "name": "internalCopy",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "any",
-        "resolved": "any",
-        "references": {}
-      }
-    }, {
-      "method": "internalPaste",
-      "name": "internalPaste",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "any",
-        "resolved": "any",
-        "references": {}
-      }
-    }, {
-      "method": "internalCellEdit",
-      "name": "internalCellEdit",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "Edition.BeforeSaveDataDetails",
-        "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; type: DimensionRows; }",
-        "references": {
-          "Edition": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+    }
+    /**
+     * Start cell editing
+     */
+    doEdit(val = '') {
+        var _a;
+        if (this.canEdit()) {
+            const editCell = this.selectionStore.get('focus');
+            const data = this.columnService.getSaveData(editCell.y, editCell.x);
+            (_a = this.setEdit) === null || _a === void 0 ? void 0 : _a.emit(Object.assign(Object.assign({}, data), { val }));
         }
-      }
-    }, {
-      "method": "internalFocusCell",
-      "name": "internalFocusCell",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "Edition.BeforeSaveDataDetails",
-        "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; type: DimensionRows; }",
-        "references": {
-          "Edition": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+    }
+    /**
+     * Close editor event triggered
+     * @param details - if requires focus next
+     */
+    closeEdit(e) {
+        this.cancelEdit.emit();
+        if (e === null || e === void 0 ? void 0 : e.detail) {
+            this.focusNext();
         }
-      }
-    }, {
-      "method": "setEdit",
-      "name": "setEdit",
-      "bubbles": false,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "Edition.BeforeEdit",
-        "resolved": "{ isCancel: boolean; } & BeforeSaveDataDetails",
-        "references": {
-          "Edition": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+    }
+    /**
+     * Edit finished.
+     * Close Editor and save.
+     */
+    cellEdit(e) {
+        const dataToSave = this.columnService.getSaveData(e.rgRow, e.rgCol, e.val);
+        this.cellEditApply.emit(dataToSave);
+    }
+    getRegion() {
+        const focus = this.selectionStoreService.focused;
+        let range = this.selectionStoreService.ranged;
+        if (!range) {
+            range = getRange(focus, focus);
         }
-      }
-    }, {
-      "method": "setRange",
-      "name": "setRange",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "Selection.RangeArea",
-        "resolved": "{ x: number; y: number; x1: number; y1: number; }",
-        "references": {
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        return range;
+    }
+    onCopy(e) {
+        const range = this.getRegion();
+        const canCopyEvent = this.beforeCopyRegion.emit(range);
+        if (canCopyEvent.defaultPrevented) {
+            return false;
         }
-      }
-    }, {
-      "method": "setTempRange",
-      "name": "setTempRange",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "Selection.TempRange | null",
-        "resolved": "{ type: string; area: RangeArea; }",
-        "references": {
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        let rangeData;
+        if (range) {
+            const { data, mapping } = this.columnService.copyRangeArray(range, this.dataStore);
+            const event = this.rangeClipboardCopy.emit(Object.assign({ range,
+                data,
+                mapping }, this.types));
+            if (!event.defaultPrevented) {
+                rangeData = event.detail.data;
+            }
         }
-      }
-    }, {
-      "method": "focusCell",
-      "name": "focusCell",
-      "bubbles": false,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "Selection.FocusedCells",
-        "resolved": "{ focus: Cell; end: Cell; }",
-        "references": {
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        this.clipboard.doCopy(e, rangeData);
+        return true;
+    }
+    onPaste(data) {
+        const focus = this.selectionStoreService.focused;
+        const isEditing = this.selectionStoreService.edited !== null;
+        if (!focus || isEditing) {
+            return;
+        }
+        let { changed, range } = this.columnService.getTransformedDataToApply(focus, data);
+        const { defaultPrevented: canPaste } = this.rangeClipboardPaste.emit(Object.assign({ data: changed, range }, this.types));
+        if (canPaste) {
+            return;
+        }
+        this.autoFillService.onRangeApply(changed, range);
+    }
+    async focusNext() {
+        const canFocus = await this.keyboardService.keyChangeSelection(new KeyboardEvent('keydown', {
+            code: codesLetter.ARROW_DOWN,
+        }), this.range);
+        if (!canFocus) {
+            this.closeEdit();
         }
-      }
-    }, {
-      "method": "internalSelectionChanged",
-      "name": "internalSelectionChanged",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": "Selection range changed"
-      },
-      "complexType": {
-        "original": "Selection.ChangedRange",
-        "resolved": "{ type: DimensionRows; newRange: RangeArea; oldRange: RangeArea; newProps: ColumnProp[]; oldProps: ColumnProp[]; newData: { [key: number]: DataType; }; }",
-        "references": {
-          "Selection": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+    }
+    clearCell() {
+        if (this.selectionStoreService.ranged &&
+            !isRangeSingleCell(this.selectionStoreService.ranged)) {
+            const data = this.columnService.getRangeStaticData(this.selectionStoreService.ranged, '');
+            this.autoFillService.onRangeApply(data, this.selectionStoreService.ranged);
         }
-      }
-    }, {
-      "method": "internalRangeDataApply",
-      "name": "internalRangeDataApply",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": "Range data apply"
-      },
-      "complexType": {
-        "original": "Edition.BeforeRangeSaveDataDetails",
-        "resolved": "{ data: DataLookup; models: { [rowIndex: number]: DataType; }; type: DimensionRows; }",
-        "references": {
-          "Edition": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
+        else if (this.canEdit()) {
+            const focused = this.selectionStoreService.focused;
+            const cell = this.columnService.getSaveData(focused.y, focused.x);
+            this.cellEdit({
+                rgRow: focused.y,
+                rgCol: focused.x,
+                val: '',
+                type: cell.type,
+                prop: cell.prop,
+            });
         }
-      }
-    }]; }
-  static get elementRef() { return "element"; }
-  static get watchers() { return [{
-      "propName": "selectionStore",
-      "methodName": "selectionServiceSet"
-    }, {
-      "propName": "dimensionRow",
-      "methodName": "createAutoFillService"
-    }, {
-      "propName": "dimensionCol",
-      "methodName": "createAutoFillService"
-    }, {
-      "propName": "dataStore",
-      "methodName": "columnServiceSet"
-    }, {
-      "propName": "colData",
-      "methodName": "columnServiceSet"
-    }]; }
-  static get listeners() { return [{
-      "name": "mousemove",
-      "method": "onMouseMove",
-      "target": "document",
-      "capture": false,
-      "passive": true
-    }, {
-      "name": "mouseleave",
-      "method": "onMouseOut",
-      "target": "document",
-      "capture": false,
-      "passive": true
-    }, {
-      "name": "mouseup",
-      "method": "onMouseUp",
-      "target": "document",
-      "capture": false,
-      "passive": true
-    }, {
-      "name": "dragStartCell",
-      "method": "onCellDrag",
-      "target": undefined,
-      "capture": false,
-      "passive": false
-    }, {
-      "name": "keyup",
-      "method": "onKeyUp",
-      "target": "document",
-      "capture": false,
-      "passive": false
-    }, {
-      "name": "keydown",
-      "method": "onKeyDown",
-      "target": "document",
-      "capture": false,
-      "passive": false
-    }]; }
+    }
+    rowDragStart({ detail }) {
+        detail.text = this.columnService.getCellData(detail.cell.y, detail.cell.x);
+    }
+    /**
+     * Verify if edit allowed.
+     */
+    canEdit() {
+        var _a;
+        if (this.readonly) {
+            return false;
+        }
+        const editCell = this.selectionStoreService.focused;
+        return editCell && !((_a = this.columnService) === null || _a === void 0 ? void 0 : _a.isReadOnly(editCell.y, editCell.x));
+    }
+    get types() {
+        return {
+            rowType: this.dataStore.get('type'),
+            colType: this.columnService.type,
+        };
+    }
+    /**
+     * Collect data
+     */
+    getData() {
+        return {
+            el: this.element,
+            rows: this.dimensionRow.state,
+            cols: this.dimensionCol.state,
+            lastCell: this.lastCell,
+        };
+    }
+    static get is() { return "revogr-overlay-selection"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["revogr-overlay-style.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["revogr-overlay-style.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "readonly": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Readonly mode."
+                },
+                "attribute": "readonly",
+                "reflect": false
+            },
+            "range": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Range selection allowed."
+                },
+                "attribute": "range",
+                "reflect": false
+            },
+            "canDrag": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Enable revogr-order-editor component (read more in revogr-order-editor component).\nAllows D&D."
+                },
+                "attribute": "can-drag",
+                "reflect": false
+            },
+            "useClipboard": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Enable revogr-clipboard component (read more in revogr-clipboard component).\nAllows copy/paste."
+                },
+                "attribute": "use-clipboard",
+                "reflect": false
+            },
+            "selectionStore": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<SelectionStoreState>",
+                    "resolved": "ObservableMap<SelectionStoreState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::Observable"
+                        },
+                        "SelectionStoreState": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::SelectionStoreState"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Selection, range, focus."
+                }
+            },
+            "dimensionRow": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DimensionSettingsState>",
+                    "resolved": "ObservableMap<DimensionSettingsState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::Observable"
+                        },
+                        "DimensionSettingsState": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::DimensionSettingsState"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Dimension settings Y."
+                }
+            },
+            "dimensionCol": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DimensionSettingsState>",
+                    "resolved": "ObservableMap<DimensionSettingsState>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::Observable"
+                        },
+                        "DimensionSettingsState": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::DimensionSettingsState"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Dimension settings X."
+                }
+            },
+            "dataStore": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DSourceState<DataType, DimensionRows>>",
+                    "resolved": "ObservableMap<DSourceState<DataType, DimensionRows>>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::Observable"
+                        },
+                        "DSourceState": {
+                            "location": "import",
+                            "path": "../../store/dataSource/data.store",
+                            "id": "src/store/dataSource/data.store.ts::DSourceState"
+                        },
+                        "DataType": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::DataType"
+                        },
+                        "DimensionRows": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::DimensionRows"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Row data store."
+                }
+            },
+            "colData": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Observable<DSourceState<ColumnRegular, DimensionCols>>",
+                    "resolved": "ObservableMap<DSourceState<ColumnRegular, DimensionCols>>",
+                    "references": {
+                        "Observable": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::Observable"
+                        },
+                        "DSourceState": {
+                            "location": "import",
+                            "path": "../../store/dataSource/data.store",
+                            "id": "src/store/dataSource/data.store.ts::DSourceState"
+                        },
+                        "ColumnRegular": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::ColumnRegular"
+                        },
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::DimensionCols"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Column data store."
+                }
+            },
+            "lastCell": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Cell",
+                    "resolved": "Cell",
+                    "references": {
+                        "Cell": {
+                            "location": "import",
+                            "path": "../../components",
+                            "id": "src/components.d.ts::Cell"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Last cell position."
+                }
+            },
+            "editors": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Editors",
+                    "resolved": "{ [name: string]: EditorCtr; }",
+                    "references": {
+                        "Editors": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::Editors"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Custom editors register."
+                }
+            },
+            "applyChangesOnClose": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "If true applys changes when cell closes if not Escape."
+                },
+                "attribute": "apply-changes-on-close",
+                "reflect": false,
+                "defaultValue": "false"
+            },
+            "additionalData": {
+                "type": "any",
+                "mutable": false,
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Additional data to pass to renderer."
+                },
+                "attribute": "additional-data",
+                "reflect": false
+            },
+            "isMobileDevice": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Is mobile view mode."
+                },
+                "attribute": "is-mobile-device",
+                "reflect": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "beforeCopyRegion",
+                "name": "beforecopyregion",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before clipboard copy happened. Validate data before copy.\nTo prevent the default behavior of editing data and use your own implementation, call `e.preventDefault()`."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "beforeRegionPaste",
+                "name": "beforepasteregion",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before region paste happened."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "cellEditApply",
+                "name": "celleditapply",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Cell edit apply to the data source.\nTriggers datasource edit on the root level."
+                },
+                "complexType": {
+                    "original": "BeforeSaveDataDetails",
+                    "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; colIndex: number; colType: DimensionCols; type: DimensionRows; }",
+                    "references": {
+                        "BeforeSaveDataDetails": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::BeforeSaveDataDetails"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeFocusCell",
+                "name": "beforecellfocusinit",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before cell focus."
+                },
+                "complexType": {
+                    "original": "BeforeSaveDataDetails",
+                    "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; colIndex: number; colType: DimensionCols; type: DimensionRows; }",
+                    "references": {
+                        "BeforeSaveDataDetails": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::BeforeSaveDataDetails"
+                        }
+                    }
+                }
+            }, {
+                "method": "setEdit",
+                "name": "setedit",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Set edit cell."
+                },
+                "complexType": {
+                    "original": "BeforeEdit",
+                    "resolved": "{ prop: ColumnProp; model: DataType; val?: string; rowIndex: number; colIndex: number; colType: DimensionCols; type: DimensionRows; }",
+                    "references": {
+                        "BeforeEdit": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::BeforeEdit"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeApplyRange",
+                "name": "beforeapplyrange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before range applied."
+                },
+                "complexType": {
+                    "original": "FocusRenderEvent",
+                    "resolved": "FocusRenderEvent",
+                    "references": {
+                        "FocusRenderEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::FocusRenderEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeSetRange",
+                "name": "beforesetrange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before range selection applied."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "beforeEditRender",
+                "name": "beforeeditrender",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before editor render."
+                },
+                "complexType": {
+                    "original": "FocusRenderEvent",
+                    "resolved": "FocusRenderEvent",
+                    "references": {
+                        "FocusRenderEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::FocusRenderEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "setRange",
+                "name": "setrange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Set range."
+                },
+                "complexType": {
+                    "original": "RangeArea & { type: MultiDimensionType }",
+                    "resolved": "RangeArea & { type: MultiDimensionType; }",
+                    "references": {
+                        "RangeArea": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::RangeArea"
+                        },
+                        "MultiDimensionType": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::MultiDimensionType"
+                        }
+                    }
+                }
+            }, {
+                "method": "selectAll",
+                "name": "selectall",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Select all."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "cancelEdit",
+                "name": "canceledit",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Used for editors support when editor close requested."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "setTempRange",
+                "name": "settemprange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Set temp range area during autofill."
+                },
+                "complexType": {
+                    "original": "TempRange | null",
+                    "resolved": "{ type: string; area: RangeArea; }",
+                    "references": {
+                        "TempRange": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::TempRange"
+                        }
+                    }
+                }
+            }, {
+                "method": "applyFocus",
+                "name": "applyfocus",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before cell get focused.\nTo prevent the default behavior of applying the edit data, you can call `e.preventDefault()`."
+                },
+                "complexType": {
+                    "original": "FocusRenderEvent",
+                    "resolved": "FocusRenderEvent",
+                    "references": {
+                        "FocusRenderEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::FocusRenderEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "focusCell",
+                "name": "focuscell",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Cell get focused.\nTo prevent the default behavior of applying the edit data, you can call `e.preventDefault()`."
+                },
+                "complexType": {
+                    "original": "ApplyFocusEvent",
+                    "resolved": "AllDimensionType & FocusedCells",
+                    "references": {
+                        "ApplyFocusEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ApplyFocusEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeRangeDataApply",
+                "name": "beforerangedataapply",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Range data apply."
+                },
+                "complexType": {
+                    "original": "FocusRenderEvent",
+                    "resolved": "FocusRenderEvent",
+                    "references": {
+                        "FocusRenderEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::FocusRenderEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "selectionChange",
+                "name": "selectionchangeinit",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Selection range changed."
+                },
+                "complexType": {
+                    "original": "ChangedRange",
+                    "resolved": "{ type: DimensionRows; colType: DimensionCols; newRange: RangeArea; oldRange: RangeArea; mapping: OldNewRangeMapping; newData: { [key: number]: DataType; }; }",
+                    "references": {
+                        "ChangedRange": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::ChangedRange"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeRangeCopyApply",
+                "name": "beforerangecopyapply",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before range copy."
+                },
+                "complexType": {
+                    "original": "ChangedRange",
+                    "resolved": "{ type: DimensionRows; colType: DimensionCols; newRange: RangeArea; oldRange: RangeArea; mapping: OldNewRangeMapping; newData: { [key: number]: DataType; }; }",
+                    "references": {
+                        "ChangedRange": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::ChangedRange"
+                        }
+                    }
+                }
+            }, {
+                "method": "rangeEditApply",
+                "name": "rangeeditapply",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Range data apply.\nTriggers datasource edit on the root level."
+                },
+                "complexType": {
+                    "original": "BeforeRangeSaveDataDetails",
+                    "resolved": "{ data: DataLookup; models: { [rowIndex: number]: DataType; }; type: DimensionRows; }",
+                    "references": {
+                        "BeforeRangeSaveDataDetails": {
+                            "location": "import",
+                            "path": "../../types/selection",
+                            "id": "src/types/selection.ts::BeforeRangeSaveDataDetails"
+                        }
+                    }
+                }
+            }, {
+                "method": "rangeClipboardCopy",
+                "name": "clipboardrangecopy",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Range copy."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "rangeClipboardPaste",
+                "name": "clipboardrangepaste",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }, {
+                "method": "beforeKeyDown",
+                "name": "beforekeydown",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before key up event proxy, used to prevent key up trigger.\nIf you have some custom behaviour event, use this event to check if it wasn't processed by internal logic.\nCall preventDefault()."
+                },
+                "complexType": {
+                    "original": "KeyboardEvent",
+                    "resolved": "KeyboardEvent",
+                    "references": {
+                        "KeyboardEvent": {
+                            "location": "global",
+                            "id": "global::KeyboardEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeKeyUp",
+                "name": "beforekeyup",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before key down event proxy, used to prevent key down trigger.\nIf you have some custom behaviour event, use this event to check if it wasn't processed by internal logic.\nCall preventDefault()."
+                },
+                "complexType": {
+                    "original": "KeyboardEvent",
+                    "resolved": "KeyboardEvent",
+                    "references": {
+                        "KeyboardEvent": {
+                            "location": "global",
+                            "id": "global::KeyboardEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "beforeCellSave",
+                "name": "beforecellsave",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Runs before cell save.\nCan be used to override or cancel original save."
+                },
+                "complexType": {
+                    "original": "any",
+                    "resolved": "any",
+                    "references": {}
+                }
+            }];
+    }
+    static get elementRef() { return "element"; }
+    static get watchers() {
+        return [{
+                "propName": "selectionStore",
+                "methodName": "selectionServiceSet"
+            }, {
+                "propName": "dimensionRow",
+                "methodName": "createAutoFillService"
+            }, {
+                "propName": "dimensionCol",
+                "methodName": "createAutoFillService"
+            }, {
+                "propName": "dataStore",
+                "methodName": "columnServiceSet"
+            }, {
+                "propName": "colData",
+                "methodName": "columnServiceSet"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "touchmove",
+                "method": "onMouseMove",
+                "target": "document",
+                "capture": false,
+                "passive": true
+            }, {
+                "name": "mousemove",
+                "method": "onMouseMove",
+                "target": "document",
+                "capture": false,
+                "passive": true
+            }, {
+                "name": "touchend",
+                "method": "onMouseUp",
+                "target": "document",
+                "capture": false,
+                "passive": true
+            }, {
+                "name": "mouseup",
+                "method": "onMouseUp",
+                "target": "document",
+                "capture": false,
+                "passive": true
+            }, {
+                "name": "mouseleave",
+                "method": "onMouseUp",
+                "target": "document",
+                "capture": false,
+                "passive": true
+            }, {
+                "name": "dragstartcell",
+                "method": "onCellDrag",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keyup",
+                "method": "onKeyUp",
+                "target": "document",
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "keydown",
+                "method": "onKeyDown",
+                "target": "document",
+                "capture": false,
+                "passive": false
+            }];
+    }
 }
+//# sourceMappingURL=revogr-overlay-selection.js.map