@revolist/revogrid 4.0.4-next → 4.0.4

package/dist/collection/components/scroll/revogr-viewport-scroll.js

@@ -1,399 +1,565 @@
-import { Component, Event, h, Method, Element, Prop, Host } from '@stencil/core';
-import each from 'lodash/each';
-import GridResizeService from '../revoGrid/viewport.resize.service';
-import LocalScrollService from '../../services/localScrollService';
-import { CONTENT_SLOT, FOOTER_SLOT, HEADER_SLOT } from '../revoGrid/viewport.helpers';
+/*!
+ * Built by Revolist OU ❤️
+ */
+import { h, Host, } from "@stencil/core";
+import each from "lodash/each";
+import GridResizeService from "../revoGrid/viewport.resize.service";
+import LocalScrollService from "../../services/local.scroll.service";
+import { LocalScrollTimer } from "../../services/local.scroll.timer";
+import { CONTENT_SLOT, FOOTER_SLOT, HEADER_SLOT, } from "../revoGrid/viewport.helpers";
 /**
- * Service for tracking grid scrolling
+ * Viewport scroll component for RevoGrid
+ * @slot - content
+ * @slot header - header
+ * @slot footer - footer
  */
 export class RevogrViewportScroll {
-  constructor() {
-    this.scrollThrottling = 30;
+    constructor() {
+        this.oldValY = this.contentHeight;
+        this.oldValX = this.contentWidth;
+        this.rowHeader = undefined;
+        this.contentWidth = 0;
+        this.contentHeight = 0;
+        this.colType = undefined;
+    }
+    async setScroll(e) {
+        var _a;
+        this.localScrollTimer.latestScrollUpdate(e.dimension);
+        (_a = this.localScrollService) === null || _a === void 0 ? void 0 : _a.setScroll(e);
+    }
     /**
-     * Width of inner content
+     * update on delta in case we don't know existing position or external change
+     * @param e
      */
-    this.contentWidth = 0;
+    async changeScroll(e, silent = false) {
+        if (silent) {
+            if (e.coordinate) {
+                switch (e.dimension) {
+                    // for mobile devices to skip negative scroll loop. only on vertical scroll
+                    case 'rgRow':
+                        this.verticalScroll.style.transform = `translateY(${-1 * e.coordinate}px)`;
+                        break;
+                }
+            }
+            return null;
+        }
+        if (e.delta) {
+            switch (e.dimension) {
+                case 'rgCol':
+                    e.coordinate = this.horizontalScroll.scrollLeft + e.delta;
+                    break;
+                case 'rgRow':
+                    e.coordinate = this.verticalScroll.scrollTop + e.delta;
+                    break;
+            }
+            this.setScroll(e);
+        }
+        return e;
+    }
     /**
-     * Height of inner content
+     * Dispatch this event to trigger vertical mouse wheel from plugins
      */
-    this.contentHeight = 0;
-    this.oldValY = this.contentHeight;
-    this.oldValX = this.contentWidth;
+    mousewheelVertical({ detail: e, }) {
+        this.verticalMouseWheel(e);
+    }
     /**
-     * Last mw event time for trigger scroll function below
-     * If mousewheel function was ignored we still need to trigger render
+     * Dispatch this event to trigger horizontal mouse wheel from plugins
      */
-    this.mouseWheelScroll = { rgCol: 0, rgRow: 0 };
-  }
-  async setScroll(e) {
-    var _a;
-    this.latestScrollUpdate(e.dimension);
-    (_a = this.scrollService) === null || _a === void 0 ? void 0 : _a.setScroll(e);
-  }
-  /**
-   * update on delta in case we don't know existing position or external change
-   * @param e
-   */
-  async changeScroll(e) {
-    if (e.delta) {
-      switch (e.dimension) {
-        case 'rgCol':
-          e.coordinate = this.horizontalScroll.scrollLeft + e.delta;
-          break;
-        case 'rgRow':
-          e.coordinate = this.verticalScroll.scrollTop + e.delta;
-          break;
-      }
-      this.setScroll(e);
+    mousewheelHorizontal({ detail: e, }) {
+        this.horizontalMouseWheel(e);
     }
-    return e;
-  }
-  connectedCallback() {
     /**
-     * Bind scroll functions for farther usage
+     * Allows to use outside listener
      */
-    if ('ontouchstart' in document.documentElement) {
-      this.scrollThrottling = 0;
+    scrollApply({ detail: { type, coordinate }, }) {
+        this.applyOnScroll(type, coordinate, true);
     }
-    else {
-      this.verticalMouseWheel = this.onVerticalMouseWheel.bind(this, 'rgRow', 'deltaY');
-      this.horizontalMouseWheel = this.onHorizontalMouseWheel.bind(this, 'rgCol', 'deltaX');
+    connectedCallback() {
+        /**
+         * Bind scroll functions for farther usage
+         */
+        // allow mousewheel for all devices including mobile
+        this.verticalMouseWheel = this.onVerticalMouseWheel.bind(this, 'rgRow', 'deltaY');
+        this.horizontalMouseWheel = this.onHorizontalMouseWheel.bind(this, 'rgCol', 'deltaX');
+        this.localScrollTimer = new LocalScrollTimer('ontouchstart' in document.documentElement ? 0 : 10);
+        /**
+         * Create local scroll service
+         */
+        this.localScrollService = new LocalScrollService({
+            // to improve safari smoothnes on scroll
+            // skipAnimationFrame: isSafariDesktop(),
+            runScroll: e => this.scrollViewport.emit(e),
+            applyScroll: e => {
+                this.localScrollTimer.setCoordinate(e);
+                switch (e.dimension) {
+                    case 'rgCol':
+                        // this will trigger on scroll event
+                        this.horizontalScroll.scrollLeft = e.coordinate;
+                        break;
+                    case 'rgRow':
+                        // this will trigger on scroll event
+                        this.verticalScroll.scrollTop = e.coordinate;
+                        // for mobile devices to skip negative scroll loop. only on vertical scroll
+                        if (this.verticalScroll.style.transform) {
+                            this.verticalScroll.style.transform = '';
+                        }
+                        break;
+                }
+            },
+        });
+    }
+    componentDidLoad() {
+        // track horizontal viewport resize
+        this.resizeService = new GridResizeService(this.horizontalScroll, {
+            resize: entries => {
+                var _a, _b;
+                let height = ((_a = entries[0]) === null || _a === void 0 ? void 0 : _a.contentRect.height) || 0;
+                if (height) {
+                    height -= this.header.clientHeight + this.footer.clientHeight;
+                }
+                const els = {
+                    rgRow: {
+                        size: height,
+                        contentSize: this.contentHeight,
+                        scroll: this.verticalScroll.scrollTop,
+                        noScroll: false,
+                    },
+                    rgCol: {
+                        size: ((_b = entries[0]) === null || _b === void 0 ? void 0 : _b.contentRect.width) || 0,
+                        contentSize: this.contentWidth,
+                        scroll: this.horizontalScroll.scrollLeft,
+                        noScroll: this.colType !== 'rgCol' ? true : false,
+                    },
+                };
+                each(els, (item, dimension) => {
+                    var _a;
+                    this.resizeViewport.emit({ dimension, size: item.size, rowHeader: this.rowHeader });
+                    if (item.noScroll) {
+                        return;
+                    }
+                    (_a = this.localScrollService) === null || _a === void 0 ? void 0 : _a.scroll(item.scroll, dimension, true);
+                    // track scroll visibility on outer element change
+                    this.setScrollVisibility(dimension, item.size, item.contentSize);
+                });
+            },
+        });
     }
     /**
-     * Create local scroll service
+     * 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
      */
-    this.scrollService = new LocalScrollService({
-      beforeScroll: e => this.scrollViewport.emit(e),
-      afterScroll: e => {
-        switch (e.dimension) {
-          case 'rgCol':
-            this.horizontalScroll.scrollLeft = e.coordinate;
-            break;
-          case 'rgRow':
-            this.verticalScroll.scrollTop = e.coordinate;
-            break;
+    setScrollVisibility(type, size, innerContentSize) {
+        // test if scroll present
+        const hasScroll = size < innerContentSize;
+        let el;
+        // event reference for binding
+        switch (type) {
+            case 'rgCol':
+                el = this.horizontalScroll;
+                break;
+            case 'rgRow':
+                el = this.verticalScroll;
+                break;
         }
-      },
-    });
-  }
-  componentDidLoad() {
-    /**
-     * Track horizontal viewport resize
-     */
-    this.horisontalResize = new GridResizeService(this.horizontalScroll, {
-      resize: entries => {
-        var _a, _b;
-        let height = ((_a = entries[0]) === null || _a === void 0 ? void 0 : _a.contentRect.height) || 0;
-        if (height) {
-          height -= this.header.clientHeight + this.footer.clientHeight;
+        // based on scroll visibility assign or remove class and event
+        if (hasScroll) {
+            el.classList.add(`scroll-${type}`);
+        }
+        else {
+            el.classList.remove(`scroll-${type}`);
+        }
+        this.scrollchange.emit({ type, hasScroll });
+    }
+    disconnectedCallback() {
+        this.resizeService.destroy();
+    }
+    async componentDidRender() {
+        // scroll update if number of rows changed
+        if (this.contentHeight < this.oldValY && this.verticalScroll) {
+            this.verticalScroll.scrollTop += this.contentHeight - this.oldValY;
         }
-        const els = {
-          rgRow: {
-            size: height,
+        this.oldValY = this.contentHeight;
+        // scroll update if number of cols changed
+        if (this.contentWidth < this.oldValX) {
+            this.horizontalScroll.scrollLeft += this.contentWidth - this.oldValX;
+        }
+        this.oldValX = this.contentWidth;
+        this.localScrollService.setParams({
             contentSize: this.contentHeight,
-            scroll: this.verticalScroll.scrollTop,
-          },
-          rgCol: {
-            size: ((_b = entries[0]) === null || _b === void 0 ? void 0 : _b.contentRect.width) || 0,
+            clientSize: this.verticalScroll.clientHeight,
+            virtualSize: 0,
+        }, 'rgRow');
+        this.localScrollService.setParams({
             contentSize: this.contentWidth,
-            scroll: this.horizontalScroll.scrollLeft,
-          },
-        };
-        each(els, (item, dimension) => {
-          var _a;
-          this.resizeViewport.emit({ dimension, size: item.size });
-          (_a = this.scrollService) === null || _a === void 0 ? void 0 : _a.scroll(item.scroll, dimension, true);
-          // track scroll visibility on outer element change
-          this.setScrollVisibility(dimension, item.size, item.contentSize);
-        });
-      },
-    });
-  }
-  /**
-   * 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, size, innerContentSize) {
-    // test if scroll present
-    const hasScroll = size < innerContentSize;
-    let el;
-    // event reference for binding
-    let event;
-    switch (type) {
-      case 'rgCol':
-        el = this.horizontalScroll;
-        event = this.horizontalMouseWheel;
-        break;
-      case 'rgRow':
-        el = this.verticalScroll;
-        event = this.verticalMouseWheel;
-        break;
+            clientSize: this.horizontalScroll.clientWidth,
+            virtualSize: 0,
+        }, 'rgCol');
+        this.setScrollVisibility('rgRow', this.verticalScroll.clientHeight, this.contentHeight);
+        this.setScrollVisibility('rgCol', this.horizontalScroll.clientWidth, this.contentWidth);
+    }
+    render() {
+        return (h(Host, { key: '6a0fe25ddee66c2f940a487a62cd449ffcdc5dbb', onWheel: this.horizontalMouseWheel, onScroll: (e) => this.applyScroll('rgCol', e) }, h("div", { key: '709628164413e82c226fcc1912166f52f393f3a6', class: "inner-content-table", style: { width: `${this.contentWidth}px` } }, h("div", { key: 'bc57d5cbfeded428a08621c1ac6e88a5c92926ab', class: "header-wrapper", ref: e => (this.header = e) }, h("slot", { key: '40ea612e8977ec422af7b569f1247a79617a4ea9', name: HEADER_SLOT })), h("div", { key: 'd50aff782206dbe259b4c7dc10c07b4b9bd045fe', class: "vertical-inner", ref: el => (this.verticalScroll = el), onWheel: this.verticalMouseWheel, onScroll: (e) => this.applyScroll('rgRow', e) }, h("div", { key: '0db87895530659a70c78fd07b4c74c55d7c3fd86', class: "content-wrapper", style: { height: `${this.contentHeight}px` } }, h("slot", { key: 'b6a5053abaf4fee2b76af2a1e27f70b674a796fa', name: CONTENT_SLOT }))), h("div", { key: 'd75b963be5dd0ec1b96e9a1386adf5cb1d2f6aa9', class: "footer-wrapper", ref: e => (this.footer = e) }, h("slot", { key: 'fb232888a34885305301b811b9abb0e70db6bb6a', name: FOOTER_SLOT })))));
+    }
+    /**
+     * 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
+     */
+    async applyScroll(type, e) {
+        if (!(e.target instanceof HTMLElement)) {
+            return;
+        }
+        let scroll = 0;
+        switch (type) {
+            case 'rgCol':
+                scroll = e.target.scrollLeft;
+                break;
+            case 'rgRow':
+                scroll = e.target.scrollTop;
+                break;
+        }
+        // for mobile devices to skip negative scroll loop
+        if (scroll < 0) {
+            this.silentScroll.emit({ dimension: type, coordinate: scroll });
+            return;
+        }
+        this.applyOnScroll(type, scroll);
     }
-    // based on scroll visibility assign or remove class and event
-    if (hasScroll) {
-      el.classList.add(`scroll-${type}`);
-      el.addEventListener('mousewheel', event);
+    /**
+     * Applies change on scroll event only if mousewheel event happened some time ago
+     */
+    applyOnScroll(type, coordinate, outside = false) {
+        var _a;
+        // apply after throttling
+        if (this.localScrollTimer.isReady(type, coordinate)) {
+            (_a = this.localScrollService) === null || _a === void 0 ? void 0 : _a.scroll(coordinate, type, undefined, undefined, outside);
+        }
+    }
+    /**
+     * On vertical mousewheel event
+     * @param type
+     * @param delta
+     * @param e
+     */
+    onVerticalMouseWheel(type, delta, e) {
+        var _a, _b;
+        (_a = e.preventDefault) === null || _a === void 0 ? void 0 : _a.call(e);
+        const pos = this.verticalScroll.scrollTop + e[delta];
+        (_b = this.localScrollService) === null || _b === void 0 ? void 0 : _b.scroll(pos, type, undefined, e[delta]);
+        this.localScrollTimer.latestScrollUpdate(type);
     }
-    else {
-      el.classList.remove(`scroll-${type}`);
-      el.removeEventListener('mousewheel', event);
+    /**
+     * On horizontal mousewheel event
+     * @param type
+     * @param delta
+     * @param e
+     */
+    onHorizontalMouseWheel(type, delta, e) {
+        var _a, _b;
+        (_a = e.preventDefault) === null || _a === void 0 ? void 0 : _a.call(e);
+        const pos = this.horizontalScroll.scrollLeft + e[delta];
+        (_b = this.localScrollService) === null || _b === void 0 ? void 0 : _b.scroll(pos, type, undefined, e[delta]);
+        this.localScrollTimer.latestScrollUpdate(type);
     }
-    this.scrollchange.emit({ type, hasScroll });
-  }
-  disconnectedCallback() {
-    this.verticalScroll.removeEventListener('mousewheel', this.verticalMouseWheel);
-    this.horizontalScroll.removeEventListener('mousewheel', this.horizontalMouseWheel);
-    this.horisontalResize.destroy();
-  }
-  async componentDidRender() {
-    // scroll update if number of rows changed
-    if (this.contentHeight < this.oldValY && this.verticalScroll) {
-      this.verticalScroll.scrollTop += this.contentHeight - this.oldValY;
+    static get is() { return "revogr-viewport-scroll"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["revogr-viewport-scroll-style.scss"]
+        };
     }
-    this.oldValY = this.contentHeight;
-    // scroll update if number of cols changed
-    if (this.contentWidth < this.oldValX) {
-      this.horizontalScroll.scrollLeft += this.contentWidth - this.oldValX;
+    static get styleUrls() {
+        return {
+            "$": ["revogr-viewport-scroll-style.css"]
+        };
     }
-    this.oldValX = this.contentWidth;
-    this.scrollService.setParams({
-      contentSize: this.contentHeight,
-      clientSize: this.verticalScroll.clientHeight,
-      virtualSize: 0,
-    }, 'rgRow');
-    this.scrollService.setParams({
-      contentSize: this.contentWidth,
-      clientSize: this.horizontalScroll.clientWidth,
-      virtualSize: 0,
-    }, 'rgCol');
-    this.setScrollVisibility('rgRow', this.verticalScroll.clientHeight, this.contentHeight);
-    this.setScrollVisibility('rgCol', this.horizontalScroll.clientWidth, this.contentWidth);
-  }
-  render() {
-    return (h(Host, { onScroll: (e) => this.onScroll('rgCol', e) },
-      h("div", { class: "inner-content-table", style: { width: `${this.contentWidth}px` } },
-        h("div", { class: "header-wrapper", ref: e => (this.header = e) },
-          h("slot", { name: HEADER_SLOT })),
-        h("div", { class: "vertical-inner", ref: el => (this.verticalScroll = el), onScroll: (e) => this.onScroll('rgRow', e) },
-          h("div", { class: "content-wrapper", style: { height: `${this.contentHeight}px` } },
-            h("slot", { name: CONTENT_SLOT }))),
-        h("div", { class: "footer-wrapper", ref: e => (this.footer = e) },
-          h("slot", { name: FOOTER_SLOT })))));
-  }
-  /**
-   * 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
-   */
-  onScroll(dimension, e) {
-    var _a;
-    const target = e.target;
-    let scroll = 0;
-    switch (dimension) {
-      case 'rgCol':
-        scroll = target === null || target === void 0 ? void 0 : target.scrollLeft;
-        break;
-      case 'rgRow':
-        scroll = target === null || target === void 0 ? void 0 : target.scrollTop;
-        break;
+    static get properties() {
+        return {
+            "rowHeader": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Enable row header"
+                },
+                "attribute": "row-header",
+                "reflect": false
+            },
+            "contentWidth": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Width of inner content"
+                },
+                "attribute": "content-width",
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "contentHeight": {
+                "type": "number",
+                "mutable": false,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Height of inner content"
+                },
+                "attribute": "content-height",
+                "reflect": false,
+                "defaultValue": "0"
+            },
+            "colType": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "DimensionCols | 'rowHeaders'",
+                    "resolved": "\"colPinEnd\" | \"colPinStart\" | \"rgCol\" | \"rowHeaders\"",
+                    "references": {
+                        "DimensionCols": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionCols"
+                        }
+                    }
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "attribute": "col-type",
+                "reflect": false
+            }
+        };
     }
-    const change = new Date().getTime() - this.mouseWheelScroll[dimension];
-    if (change > this.scrollThrottling) {
-      (_a = this.scrollService) === null || _a === void 0 ? void 0 : _a.scroll(scroll, dimension);
+    static get events() {
+        return [{
+                "method": "scrollViewport",
+                "name": "scrollviewport",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Before scroll event"
+                },
+                "complexType": {
+                    "original": "ViewPortScrollEvent",
+                    "resolved": "{ dimension: DimensionType; coordinate: number; delta?: number; outside?: boolean; }",
+                    "references": {
+                        "ViewPortScrollEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewPortScrollEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "resizeViewport",
+                "name": "resizeviewport",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Viewport resize"
+                },
+                "complexType": {
+                    "original": "ViewPortResizeEvent",
+                    "resolved": "{ dimension: DimensionType; size: number; rowHeader?: boolean; }",
+                    "references": {
+                        "ViewPortResizeEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewPortResizeEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "scrollchange",
+                "name": "scrollchange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Triggered on scroll change, can be used to get information about scroll visibility"
+                },
+                "complexType": {
+                    "original": "{\n    type: DimensionType;\n    hasScroll: boolean;\n  }",
+                    "resolved": "{ type: DimensionType; hasScroll: boolean; }",
+                    "references": {
+                        "DimensionType": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionType"
+                        }
+                    }
+                }
+            }, {
+                "method": "silentScroll",
+                "name": "scrollviewportsilent",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Silently scroll to coordinate\nMade to align negative coordinates for mobile devices"
+                },
+                "complexType": {
+                    "original": "ViewPortScrollEvent",
+                    "resolved": "{ dimension: DimensionType; coordinate: number; delta?: number; outside?: boolean; }",
+                    "references": {
+                        "ViewPortScrollEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewPortScrollEvent"
+                        }
+                    }
+                }
+            }];
     }
-  }
-  /** remember last mw event time */
-  latestScrollUpdate(dimension) {
-    this.mouseWheelScroll[dimension] = new Date().getTime();
-  }
-  /**
-   * On vertical mousewheel event
-   * @param type
-   * @param delta
-   * @param e
-   */
-  onVerticalMouseWheel(type, delta, e) {
-    var _a;
-    e.preventDefault();
-    const pos = this.verticalScroll.scrollTop + e[delta];
-    (_a = this.scrollService) === null || _a === void 0 ? void 0 : _a.scroll(pos, type, undefined, e[delta]);
-    this.latestScrollUpdate(type);
-  }
-  /**
-   * On horizontal mousewheel event
-   * @param type
-   * @param delta
-   * @param e
-   */
-  onHorizontalMouseWheel(type, delta, e) {
-    var _a;
-    e.preventDefault();
-    const pos = this.horizontalScroll.scrollLeft + e[delta];
-    (_a = this.scrollService) === null || _a === void 0 ? void 0 : _a.scroll(pos, type, undefined, e[delta]);
-    this.latestScrollUpdate(type);
-  }
-  static get is() { return "revogr-viewport-scroll"; }
-  static get originalStyleUrls() { return {
-    "$": ["revogr-viewport-scroll-style.scss"]
-  }; }
-  static get styleUrls() { return {
-    "$": ["revogr-viewport-scroll-style.css"]
-  }; }
-  static get properties() { return {
-    "contentWidth": {
-      "type": "number",
-      "mutable": false,
-      "complexType": {
-        "original": "number",
-        "resolved": "number",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Width of inner content"
-      },
-      "attribute": "content-width",
-      "reflect": false,
-      "defaultValue": "0"
-    },
-    "contentHeight": {
-      "type": "number",
-      "mutable": false,
-      "complexType": {
-        "original": "number",
-        "resolved": "number",
-        "references": {}
-      },
-      "required": false,
-      "optional": false,
-      "docs": {
-        "tags": [],
-        "text": "Height of inner content"
-      },
-      "attribute": "content-height",
-      "reflect": false,
-      "defaultValue": "0"
+    static get methods() {
+        return {
+            "setScroll": {
+                "complexType": {
+                    "signature": "(e: ViewPortScrollEvent) => Promise<void>",
+                    "parameters": [{
+                            "name": "e",
+                            "type": "{ dimension: DimensionType; coordinate: number; delta?: number; outside?: boolean; }",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "ViewPortScrollEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewPortScrollEvent"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "changeScroll": {
+                "complexType": {
+                    "signature": "(e: ViewPortScrollEvent, silent?: boolean) => Promise<ViewPortScrollEvent>",
+                    "parameters": [{
+                            "name": "e",
+                            "type": "{ dimension: DimensionType; coordinate: number; delta?: number; outside?: boolean; }",
+                            "docs": ""
+                        }, {
+                            "name": "silent",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "ViewPortScrollEvent": {
+                            "location": "import",
+                            "path": "../../types/interfaces",
+                            "id": "src/types/interfaces.ts::ViewPortScrollEvent"
+                        }
+                    },
+                    "return": "Promise<ViewPortScrollEvent>"
+                },
+                "docs": {
+                    "text": "update on delta in case we don't know existing position or external change",
+                    "tags": [{
+                            "name": "param",
+                            "text": "e"
+                        }]
+                }
+            },
+            "applyScroll": {
+                "complexType": {
+                    "signature": "(type: DimensionType, e: UIEvent) => Promise<void>",
+                    "parameters": [{
+                            "name": "type",
+                            "type": "\"rgCol\" | \"rgRow\"",
+                            "docs": ""
+                        }, {
+                            "name": "e",
+                            "type": "UIEvent",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "DimensionType": {
+                            "location": "import",
+                            "path": "../../types/dimension",
+                            "id": "src/types/dimension.ts::DimensionType"
+                        },
+                        "UIEvent": {
+                            "location": "global",
+                            "id": "global::UIEvent"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Extra layer for scroll event monitoring, where MouseWheel event is not passing\nWe need to trigger scroll event in case there is no mousewheel event",
+                    "tags": []
+                }
+            }
+        };
     }
-  }; }
-  static get events() { return [{
-      "method": "scrollViewport",
-      "name": "scrollViewport",
-      "bubbles": false,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "RevoGrid.ViewPortScrollEvent",
-        "resolved": "{ dimension: DimensionType; coordinate: number; delta?: number; }",
-        "references": {
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        }
-      }
-    }, {
-      "method": "resizeViewport",
-      "name": "resizeViewport",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "RevoGrid.ViewPortResizeEvent",
-        "resolved": "{ dimension: DimensionType; size: number; }",
-        "references": {
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        }
-      }
-    }, {
-      "method": "scrollchange",
-      "name": "scrollchange",
-      "bubbles": true,
-      "cancelable": true,
-      "composed": true,
-      "docs": {
-        "tags": [],
-        "text": ""
-      },
-      "complexType": {
-        "original": "{ type: RevoGrid.DimensionType; hasScroll: boolean; }",
-        "resolved": "{ type: DimensionType; hasScroll: boolean; }",
-        "references": {
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        }
-      }
-    }]; }
-  static get methods() { return {
-    "setScroll": {
-      "complexType": {
-        "signature": "(e: RevoGrid.ViewPortScrollEvent) => Promise<void>",
-        "parameters": [{
-            "tags": [],
-            "text": ""
-          }],
-        "references": {
-          "Promise": {
-            "location": "global"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        },
-        "return": "Promise<void>"
-      },
-      "docs": {
-        "text": "",
-        "tags": []
-      }
-    },
-    "changeScroll": {
-      "complexType": {
-        "signature": "(e: RevoGrid.ViewPortScrollEvent) => Promise<RevoGrid.ViewPortScrollEvent>",
-        "parameters": [{
-            "tags": [{
-                "text": "e",
-                "name": "param"
-              }],
-            "text": ""
-          }],
-        "references": {
-          "Promise": {
-            "location": "global"
-          },
-          "RevoGrid": {
-            "location": "import",
-            "path": "../../interfaces"
-          }
-        },
-        "return": "Promise<ViewPortScrollEvent>"
-      },
-      "docs": {
-        "text": "update on delta in case we don't know existing position or external change",
-        "tags": [{
-            "name": "param",
-            "text": "e"
-          }]
-      }
+    static get elementRef() { return "horizontalScroll"; }
+    static get listeners() {
+        return [{
+                "name": "mousewheel-vertical",
+                "method": "mousewheelVertical",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "mousewheel-horizontal",
+                "method": "mousewheelHorizontal",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }, {
+                "name": "scroll-coordinate",
+                "method": "scrollApply",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
     }
-  }; }
-  static get elementRef() { return "horizontalScroll"; }
 }
+//# sourceMappingURL=revogr-viewport-scroll.js.map