@progress/kendo-pdfviewer-common 0.3.0-dev.202409251459 → 0.3.0-dev.202410100645

package/dist/npm/links/link-service.js

@@ -0,0 +1,501 @@
+"use strict";
+/* Copyright 2015 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var _a, _PDFLinkService_isValidExplicitDest;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFLinkService = exports.LinkTarget = void 0;
+const tslib_1 = require("tslib");
+const ui_utils_1 = require("../annotations/shared/ui_utils");
+const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
+const LinkTarget = {
+    NONE: 0, // Default value.
+    SELF: 1,
+    BLANK: 2,
+    PARENT: 3,
+    TOP: 4,
+};
+exports.LinkTarget = LinkTarget;
+/**
+ * @typedef {Object} PDFLinkServiceOptions
+ * @property {EventBus} eventBus - The application event bus.
+ * @property {number} [externalLinkTarget] - Specifies the `target` attribute
+ *   for external links. Must use one of the values from {LinkTarget}.
+ *   Defaults to using no target.
+ * @property {string} [externalLinkRel] - Specifies the `rel` attribute for
+ *   external links. Defaults to stripping the referrer.
+ * @property {boolean} [ignoreDestinationZoom] - Ignores the zoom argument,
+ *   thus preserving the current zoom level in the viewer, when navigating
+ *   to internal destinations. The default value is `false`.
+ */
+/**
+ * Performs navigation functions inside PDF, such as opening specified page,
+ * or destination.
+ * @implements {IPDFLinkService}
+ */
+class PDFLinkService {
+    /**
+     * @param {PDFLinkServiceOptions} options
+     */
+    constructor({ eventBus = null, externalLinkTarget = null, externalLinkRel = null, ignoreDestinationZoom = false, } = {}) {
+        // todo: props
+        this.eventBus = null;
+        this.externalLinkTarget = null;
+        this.externalLinkRel = null;
+        this._ignoreDestinationZoom = null;
+        this.baseUrl = null;
+        this.pdfDocument = null;
+        this.pdfViewer = null;
+        this.pdfHistory = null;
+        // todo: props
+        this.externalLinkEnabled = true;
+        this.eventBus = eventBus;
+        this.externalLinkTarget = externalLinkTarget;
+        this.externalLinkRel = externalLinkRel;
+        this._ignoreDestinationZoom = ignoreDestinationZoom;
+        this.baseUrl = null;
+        this.pdfDocument = null;
+        this.pdfViewer = null;
+        this.pdfHistory = null;
+    }
+    setDocument(pdfDocument, baseUrl = null) {
+        this.baseUrl = baseUrl;
+        this.pdfDocument = pdfDocument;
+    }
+    setViewer(pdfViewer) {
+        this.pdfViewer = pdfViewer;
+    }
+    setHistory(pdfHistory) {
+        this.pdfHistory = pdfHistory;
+    }
+    /**
+     * @type {number}
+     */
+    get pagesCount() {
+        return this.pdfDocument ? this.pdfDocument.numPages : 0;
+    }
+    /**
+     * @type {number}
+     */
+    get page() {
+        return this.pdfDocument ? this.pdfViewer.currentPageNumber : 1;
+    }
+    /**
+     * @param {number} value
+     */
+    set page(value) {
+        if (this.pdfDocument) {
+            this.pdfViewer.currentPageNumber = value;
+        }
+    }
+    /**
+     * @type {number}
+     */
+    get rotation() {
+        return this.pdfDocument ? this.pdfViewer.pagesRotation : 0;
+    }
+    /**
+     * @param {number} value
+     */
+    set rotation(value) {
+        if (this.pdfDocument) {
+            this.pdfViewer.pagesRotation = value;
+        }
+    }
+    /**
+     * @type {boolean}
+     */
+    get isInPresentationMode() {
+        return this.pdfDocument ? this.pdfViewer.isInPresentationMode : false;
+    }
+    /**
+     * This method will, when available, also update the browser history.
+     *
+     * @param {string|Array} dest - The named, or explicit, PDF destination.
+     */
+    goToDestination(dest) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.pdfDocument) {
+                return;
+            }
+            let namedDest, explicitDest, pageNumber;
+            if (typeof dest === "string") {
+                namedDest = dest;
+                explicitDest = yield this.pdfDocument.getDestination(dest);
+            }
+            else {
+                namedDest = null;
+                explicitDest = yield dest;
+            }
+            if (!Array.isArray(explicitDest)) {
+                // console.error(
+                //     `goToDestination: "${explicitDest}" is not a valid destination array, for dest="${dest}".`
+                // );
+                return;
+            }
+            // Dest array looks like that: <page-ref> </XYZ|/FitXXX> <args..>
+            const [destRef] = explicitDest;
+            if (destRef && typeof destRef === "object") {
+                pageNumber = this.pdfDocument.cachedPageNumber(destRef);
+                if (!pageNumber) {
+                    // Fetch the page reference if it's not yet available. This could
+                    // only occur during loading, before all pages have been resolved.
+                    try {
+                        pageNumber = (yield this.pdfDocument.getPageIndex(destRef)) + 1;
+                    }
+                    catch (_b) {
+                        console.error(`goToDestination: "${destRef}" is not a valid page reference, for dest="${dest}".`);
+                        return;
+                    }
+                }
+            }
+            else if (Number.isInteger(destRef)) {
+                pageNumber = destRef + 1;
+            }
+            if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
+                console.error(`goToDestination: "${pageNumber}" is not a valid page number, for dest="${dest}".`);
+                return;
+            }
+            if (this.pdfHistory) {
+                // Update the browser history before scrolling the new destination into
+                // view, to be able to accurately capture the current document position.
+                this.pdfHistory.pushCurrentPosition();
+                this.pdfHistory.push({ namedDest, explicitDest, pageNumber });
+            }
+            this.pdfViewer.scrollPageIntoView({
+                pageNumber,
+                destArray: explicitDest,
+                ignoreDestinationZoom: this._ignoreDestinationZoom,
+            });
+        });
+    }
+    /**
+     * This method will, when available, also update the browser history.
+     *
+     * @param {number|string} val - The page number, or page label.
+     */
+    goToPage(val) {
+        if (!this.pdfDocument) {
+            return;
+        }
+        const pageNumber = (typeof val === "string" && this.pdfViewer.pageLabelToPageNumber(val)) ||
+            val | 0;
+        if (!(Number.isInteger(pageNumber) &&
+            pageNumber > 0 &&
+            pageNumber <= this.pagesCount)) {
+            console.error(`PDFLinkService.goToPage: "${val}" is not a valid page.`);
+            return;
+        }
+        if (this.pdfHistory) {
+            // Update the browser history before scrolling the new page into view,
+            // to be able to accurately capture the current document position.
+            this.pdfHistory.pushCurrentPosition();
+            this.pdfHistory.pushPage(pageNumber);
+        }
+        this.pdfViewer.scrollPageIntoView({ pageNumber });
+    }
+    /**
+     * Adds various attributes (href, title, target, rel) to hyperlinks.
+     * @param {HTMLAnchorElement} link
+     * @param {string} url
+     * @param {boolean} [newWindow]
+     */
+    addLinkAttributes(link, url, newWindow = false) {
+        if (!url || typeof url !== "string") {
+            throw new Error('A valid "url" parameter must provided.');
+        }
+        const target = newWindow ? LinkTarget.BLANK : this.externalLinkTarget, rel = this.externalLinkRel;
+        if (this.externalLinkEnabled) {
+            link.href = link.title = url;
+        }
+        else {
+            link.href = "";
+            link.title = `Disabled: ${url}`;
+            link.onclick = () => false;
+        }
+        let targetStr = ""; // LinkTarget.NONE
+        switch (target) {
+            case LinkTarget.NONE:
+                break;
+            case LinkTarget.SELF:
+                targetStr = "_self";
+                break;
+            case LinkTarget.BLANK:
+                targetStr = "_blank";
+                break;
+            case LinkTarget.PARENT:
+                targetStr = "_parent";
+                break;
+            case LinkTarget.TOP:
+                targetStr = "_top";
+                break;
+            default: break;
+        }
+        link.target = targetStr;
+        link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
+    }
+    /**
+     * @param {string|Array} dest - The PDF destination object.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getDestinationHash(dest) {
+        if (typeof dest === "string") {
+            if (dest.length > 0) {
+                return this.getAnchorUrl("#" + escape(dest));
+            }
+        }
+        else if (Array.isArray(dest)) {
+            const str = JSON.stringify(dest);
+            if (str.length > 0) {
+                return this.getAnchorUrl("#" + escape(str));
+            }
+        }
+        return this.getAnchorUrl("");
+    }
+    /**
+     * Prefix the full url on anchor links to make sure that links are resolved
+     * relative to the current URL instead of the one defined in <base href>.
+     * @param {string} anchor - The anchor hash, including the #.
+     * @returns {string} The hyperlink to the PDF object.
+     */
+    getAnchorUrl(anchor) {
+        return this.baseUrl ? this.baseUrl + anchor : anchor;
+    }
+    /**
+     * @param {string} hash
+     */
+    setHash(hash) {
+        if (!this.pdfDocument) {
+            return;
+        }
+        let pageNumber, dest;
+        if (hash.includes("=")) {
+            const params = (0, ui_utils_1.parseQueryString)(hash);
+            if (params.has("search")) {
+                const query = params.get("search").replaceAll('"', ""), phrase = params.get("phrase") === "true";
+                this.eventBus.dispatch("findfromurlhash", {
+                    source: this,
+                    query: phrase ? query : query.match(/\S+/g),
+                });
+            }
+            // borrowing syntax from "Parameters for Opening PDF Files"
+            if (params.has("page")) {
+                pageNumber = params.get("page") | 0 || 1;
+            }
+            if (params.has("zoom")) {
+                // Build the destination array.
+                const zoomArgs = params.get("zoom").split(","); // scale,left,top
+                const zoomArg = zoomArgs[0];
+                const zoomArgNumber = parseFloat(zoomArg);
+                if (!zoomArg.includes("Fit")) {
+                    // If the zoomArg is a number, it has to get divided by 100. If it's
+                    // a string, it should stay as it is.
+                    dest = [
+                        null,
+                        { name: "XYZ" },
+                        zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
+                        zoomArgs.length > 2 ? zoomArgs[2] | 0 : null,
+                        zoomArgNumber ? zoomArgNumber / 100 : zoomArg,
+                    ];
+                }
+                else if (zoomArg === "Fit" || zoomArg === "FitB") {
+                    dest = [null, { name: zoomArg }];
+                }
+                else if (zoomArg === "FitH" ||
+                    zoomArg === "FitBH" ||
+                    zoomArg === "FitV" ||
+                    zoomArg === "FitBV") {
+                    dest = [
+                        null,
+                        { name: zoomArg },
+                        zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
+                    ];
+                }
+                else if (zoomArg === "FitR") {
+                    if (zoomArgs.length !== 5) {
+                        console.error('PDFLinkService.setHash: Not enough parameters for "FitR".');
+                    }
+                    else {
+                        dest = [
+                            null,
+                            { name: zoomArg },
+                            zoomArgs[1] | 0,
+                            zoomArgs[2] | 0,
+                            zoomArgs[3] | 0,
+                            zoomArgs[4] | 0,
+                        ];
+                    }
+                }
+                else {
+                    console.error(`PDFLinkService.setHash: "${zoomArg}" is not a valid zoom value.`);
+                }
+            }
+            if (dest) {
+                this.pdfViewer.scrollPageIntoView({
+                    pageNumber: pageNumber || this.page,
+                    destArray: dest,
+                    allowNegativeOffset: true,
+                });
+            }
+            else if (pageNumber) {
+                this.page = pageNumber; // simple page
+            }
+            if (params.has("pagemode")) {
+                this.eventBus.dispatch("pagemode", {
+                    source: this,
+                    mode: params.get("pagemode"),
+                });
+            }
+            // Ensure that this parameter is *always* handled last, in order to
+            // guarantee that it won't be overridden (e.g. by the "page" parameter).
+            if (params.has("nameddest")) {
+                this.goToDestination(params.get("nameddest"));
+            }
+            // if (typeof PDFJSDev === "undefined" || !PDFJSDev.test("MOZCENTRAL")) {
+            return;
+            // }
+            // // Support opening of PDF attachments in the Firefox PDF Viewer,
+            // // which uses a couple of non-standard hash parameters; refer to
+            // // `DownloadManager.openOrDownloadData` in the firefoxcom.js file.
+            // if (!params.has("filename") || !params.has("filedest")) {
+            //     return;
+            // }
+            // hash = params.get("filedest");
+        }
+        // Named (or explicit) destination.
+        dest = unescape(hash);
+        try {
+            dest = JSON.parse(dest);
+            if (!Array.isArray(dest)) {
+                // Avoid incorrectly rejecting a valid named destination, such as
+                // e.g. "4.3" or "true", because `JSON.parse` converted its type.
+                dest = dest.toString();
+            }
+        }
+        catch (e) {
+            if (!e) {
+                return;
+            }
+        }
+        if (typeof dest === "string" || tslib_1.__classPrivateFieldGet(_a, _a, "m", _PDFLinkService_isValidExplicitDest).call(_a, dest)) {
+            this.goToDestination(dest);
+            return;
+        }
+        // console.error(
+        //     `PDFLinkService.setHash: "${unescape(hash)}" is not a valid destination.`
+        // );
+    }
+    /**
+     * @param {string} action
+     */
+    executeNamedAction(action) {
+        var _b, _c;
+        if (!this.pdfDocument) {
+            return;
+        }
+        // See PDF reference, table 8.45 - Named action
+        switch (action) {
+            case "GoBack":
+                (_b = this.pdfHistory) === null || _b === void 0 ? void 0 : _b.back();
+                break;
+            case "GoForward":
+                (_c = this.pdfHistory) === null || _c === void 0 ? void 0 : _c.forward();
+                break;
+            case "NextPage":
+                this.pdfViewer.nextPage();
+                break;
+            case "PrevPage":
+                this.pdfViewer.previousPage();
+                break;
+            case "LastPage":
+                this.page = this.pagesCount;
+                break;
+            case "FirstPage":
+                this.page = 1;
+                break;
+            default:
+                break; // No action according to spec
+        }
+        this.eventBus.dispatch("namedaction", {
+            source: this,
+            action,
+        });
+    }
+    /**
+     * @param {Object} action
+     */
+    executeSetOCGState(action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.pdfDocument) {
+                return;
+            }
+            const pdfDocument = this.pdfDocument, optionalContentConfig = yield this.pdfViewer.optionalContentConfigPromise;
+            if (pdfDocument !== this.pdfDocument) {
+                return; // The document was closed while the optional content resolved.
+            }
+            optionalContentConfig.setOCGState(action);
+            this.pdfViewer.optionalContentConfigPromise = Promise.resolve(optionalContentConfig);
+        });
+    }
+}
+exports.PDFLinkService = PDFLinkService;
+_a = PDFLinkService, _PDFLinkService_isValidExplicitDest = function _PDFLinkService_isValidExplicitDest(dest) {
+    if (!Array.isArray(dest) || dest.length < 2) {
+        return false;
+    }
+    const [page, zoom, ...args] = dest;
+    if (!(typeof page === "object" &&
+        Number.isInteger(page === null || page === void 0 ? void 0 : page.num) &&
+        Number.isInteger(page === null || page === void 0 ? void 0 : page.gen)) &&
+        !Number.isInteger(page)) {
+        return false;
+    }
+    if (!(typeof zoom === "object" && typeof (zoom === null || zoom === void 0 ? void 0 : zoom.name) === "string")) {
+        return false;
+    }
+    const argsLen = args.length;
+    let allowNull = true;
+    switch (zoom.name) {
+        case "XYZ":
+            if (argsLen < 2 || argsLen > 3) {
+                return false;
+            }
+            break;
+        case "Fit":
+        case "FitB":
+            return argsLen === 0;
+        case "FitH":
+        case "FitBH":
+        case "FitV":
+        case "FitBV":
+            if (argsLen > 1) {
+                return false;
+            }
+            break;
+        case "FitR":
+            if (argsLen !== 4) {
+                return false;
+            }
+            allowNull = false;
+            break;
+        default:
+            return false;
+    }
+    for (const arg of args) {
+        if (!(typeof arg === "number" || (allowNull && arg === null))) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/npm/main.d.ts

@@ -1,5 +1,7 @@
 export * from './scroller';
 export * from './search';
 export * from './utils';
+export * from './widget/pdfviewer';
+export * from './enums/PdfViewerInteractionMode';
 export { PDFDocumentProxy } from 'pdfjs-dist';
 export { TypedArray } from 'pdfjs-dist/types/src/display/api';

package/dist/npm/main.js

@@ -4,3 +4,5 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./scroller"), exports);
 tslib_1.__exportStar(require("./search"), exports);
 tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./widget/pdfviewer"), exports);
+tslib_1.__exportStar(require("./enums/PdfViewerInteractionMode"), exports);

package/dist/npm/scroller.d.ts

@@ -1,7 +1,9 @@
+import { Component } from './common/component';
+export declare const throttle: (func: Function, wait: number, options?: any) => Function;
 /**
  * @hidden
  */
-export declare class Scroller {
+export declare class Scroller extends Component {
     options: any;
     state: any;
     element: any;
@@ -23,8 +25,10 @@ export declare class Scroller {
     enablePanEventsTracking(): void;
     disablePanEventsTracking(): void;
     shouldTrackPanEvents(): boolean;
-    onElementScroll: () => void;
-    onDemandScroll: () => void;
+    enableScrollEventsTracking(): void;
+    disableScrollEventsTracking(): void;
+    shouldTrackScrollEvents(): boolean;
+    onElementScroll: (e: any) => void;
     onDragStart: (e: any) => void;
     onDrag: (e: any) => void;
     onDragEnd: () => void;

package/dist/npm/scroller.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scroller = void 0;
+exports.Scroller = exports.throttle = void 0;
 const kendo_draggable_1 = require("@progress/kendo-draggable");
-const utils_1 = require("./utils");
+const component_1 = require("./common/component");
+const core_1 = require("./common/core");
 const throttle = function (func, wait, options = {}) {
     let timeout, context, args, result;
     let previous = 0;
@@ -40,6 +41,7 @@ const throttle = function (func, wait, options = {}) {
     };
     return throttled;
 };
+exports.throttle = throttle;
 const preventDefault = (e) => {
     if (e.preventDefault) {
         e.preventDefault();
@@ -55,15 +57,16 @@ const matchesElementSelector = (element, selector) => {
     return element.closest(selector);
 };
 const FRAMES_PER_SECOND = 1000 / 60;
-const SCROLL = 'scroll';
+const SCROLL = "scroll";
 /**
  * @hidden
  */
-class Scroller {
+class Scroller extends component_1.Component {
     constructor(element, options) {
+        super(element, options);
         this.options = {
             events: {
-                [SCROLL]: () => undefined
+                [SCROLL]: core_1.noop,
             },
             filter: '',
             // throttle the scroll events to get a more similar experience
@@ -73,10 +76,13 @@ class Scroller {
             // the drag directions are actually reversed, e.g.
             // dragging to the right actually moves the document to the left
             scrollDirectionModifier: -1,
-            scrollThrottleDelay: FRAMES_PER_SECOND
+            scrollThrottleDelay: FRAMES_PER_SECOND,
         };
-        this.onElementScroll = () => {
+        this.onElementScroll = (e) => {
             const element = this.element;
+            if (!this.shouldTrackScrollEvents()) {
+                return;
+            }
             if (this.state.trackNextElementScroll) {
                 this.scrollTo(element.scrollLeft, element.scrollTop);
             }
@@ -84,21 +90,9 @@ class Scroller {
                 // reset the state, so that consecutive scroll events can be handled
                 this.state.trackNextElementScroll = true;
             }
-        };
-        this.onDemandScroll = () => {
-            const pages = this.options.pages, currentPageIndex = (0, utils_1.currentPage)(this.element.parentElement), page = pages[currentPageIndex], nextPage = pages[currentPageIndex + 1], previousPage = pages[currentPageIndex - 1], pageInfo = page === null || page === void 0 ? void 0 : page._pageInfo, nextPageInfo = nextPage === null || nextPage === void 0 ? void 0 : nextPage._pageInfo, previousPageInfo = previousPage === null || previousPage === void 0 ? void 0 : previousPage._pageInfo, error = (e) => {
-                throw new Error(e);
-            };
-            // Render the current and surrounding pages if they have not been rendered already.
-            if (page && !pageInfo.rendered && !pageInfo.renderInProgress) {
-                (0, utils_1.renderPage)(page, pageInfo.emptyPage, error);
-            }
-            if (nextPage && !nextPageInfo.rendered && !nextPageInfo.renderInProgress) {
-                (0, utils_1.renderPage)(nextPage, nextPageInfo.emptyPage, error);
-            }
-            if (previousPage && !previousPageInfo.rendered && !previousPageInfo.renderInProgress) {
-                (0, utils_1.renderPage)(previousPage, previousPageInfo.emptyPage, error);
-            }
+            this.trigger(SCROLL, {
+                originalEvent: e
+            });
         };
         this.onDragStart = (e) => {
             this.state.dragStarted = false;
@@ -146,8 +140,7 @@ class Scroller {
                 return;
             }
         };
-        this.element = element;
-        this.options = Object.assign({}, this.options, options);
+        this.extendOptions(options);
         this.resetState();
         this.bindEvents();
     }
@@ -157,7 +150,7 @@ class Scroller {
     initDraggable() {
         this.destroyDraggable();
         if (this.options.panScrollThrottleDelay > 0) {
-            this.throttledOnDrag = throttle(this.onDrag, this.options.panScrollThrottleDelay);
+            this.throttledOnDrag = (0, exports.throttle)(this.onDrag, this.options.panScrollThrottleDelay);
         }
         else {
             this.throttledOnDrag = this.onDrag;
@@ -188,15 +181,12 @@ class Scroller {
     }
     bindElementScroll() {
         if (this.options.scrollThrottleDelay > 0) {
-            this.throttledOnElementScroll = throttle(this.onElementScroll, this.options.scrollThrottleDelay);
+            this.throttledOnElementScroll = (0, exports.throttle)(this.onElementScroll, this.options.scrollThrottleDelay);
         }
         else {
             this.throttledOnElementScroll = this.onElementScroll;
         }
         this.element.addEventListener(SCROLL, this.throttledOnElementScroll);
-        if (this.options.loadOnDemand) {
-            this.element.addEventListener(SCROLL, this.onDemandScroll);
-        }
     }
     unbindEvents() {
         this.unbindElementScroll();
@@ -211,9 +201,6 @@ class Scroller {
             this.throttledOnElementScroll.cancel();
             this.throttledOnElementScroll = null;
         }
-        if (this.options.loadOnDemand) {
-            this.element.removeEventListener(SCROLL, this.onDemandScroll);
-        }
         this.element.removeEventListener(SCROLL, this.throttledOnElementScroll);
     }
     setState(newState) {
@@ -222,6 +209,7 @@ class Scroller {
     resetState() {
         this.setState({
             trackPanEvents: false,
+            trackScrollEvents: false,
             trackNextElementScroll: false,
             location: { pageX: 0, pageY: 0 },
             locationDelta: { x: 0, y: 0 }
@@ -238,6 +226,18 @@ class Scroller {
     shouldTrackPanEvents() {
         return this.state.trackPanEvents;
     }
+    enableScrollEventsTracking() {
+        this.state.trackScrollEvents = true;
+        this.unbindElementScroll();
+        this.bindElementScroll();
+    }
+    disableScrollEventsTracking() {
+        this.unbindElementScroll();
+        this.state.trackScrollEvents = false;
+    }
+    shouldTrackScrollEvents() {
+        return this.state.trackScrollEvents;
+    }
     calculateEventLocationDelta(e) {
         this.state.locationDelta = {
             x: e.pageX - this.state.location.pageX,