@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/core/esm2022/services/pagination.service.mjs

@@ -0,0 +1,336 @@
+import { isDefined } from '../utils/utils';
+import { Injectable } from '@angular/core';
+import { debounce, get, isEmpty, isEqual } from "lodash-es";
+import * as i0 from "@angular/core";
+export class PaginationService {
+    /**
+     * @description
+     * This function returns the updated fields and the current page index when navigated to the next set of data
+     * @param {object} parent table / list instance
+     * @param {object} newVal updated fields info
+     * @returns fieldDefs and current page index
+     */
+    updateFieldsOnPagination(parent, newVal) {
+        let fieldDefs = parent.widgetType === 'wm-table' ? parent.gridData : parent.fieldDefs;
+        // remove the deleted row from the list
+        if (parent.widgetType === 'wm-table' && (parent.gridOptions.isNavTypeScrollOrOndemand()) && parent.gridOptions.deletedRowIndex !== -1) {
+            fieldDefs.splice(parent.gridOptions.deletedRowIndex, 1);
+            parent.gridOptions.setDeletedRowIndex(-1);
+        }
+        // reset fieldDefs if last action performed is search or sort
+        if (parent.widgetType === 'wm-table' && (parent.gridOptions.isNavTypeScrollOrOndemand()) && (parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.SEARCH_OR_SORT || parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.FILTER_CRITERIA || parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.DATASET_UPDATE)) {
+            fieldDefs = [];
+            parent.gridOptions.setCurrentPage(1);
+        }
+        let currentPage;
+        if (parent.widgetType === 'wm-table') {
+            currentPage = parent.gridOptions.showviewlessbutton && (parent.gridOptions.mode === 'viewless') ? parent.gridOptions.getCurrentPage() : parent.currentPage;
+        }
+        else {
+            currentPage = parent.currentPage;
+        }
+        const dataNavigator = parent.dataNavigator;
+        const pagesize = parent.pagesize;
+        if (!isDefined(fieldDefs) || dataNavigator.isFirstPage()) {
+            fieldDefs = [];
+            currentPage = 1;
+        }
+        else if (fieldDefs.length / pagesize <= dataNavigator.pageCount) {
+            let itemsLength, itemsToPush = [];
+            // we push the newVal only when dn.currentPage gets incremented because that is when new items gets added to newVal
+            if (fieldDefs.length === currentPage * pagesize && (currentPage + 1) === dataNavigator.dn.currentPage) {
+                itemsToPush = newVal;
+                currentPage++;
+            }
+            else if (fieldDefs.length < currentPage * pagesize) {
+                if ((fieldDefs.length === (currentPage - 1) * pagesize) && ((currentPage - 1) === dataNavigator.dn.currentPage)) {
+                    // if dn.currentPage is not incremented still only old newVal is present hence we push empty array
+                    newVal = [];
+                }
+                else if (dataNavigator.dataSize < currentPage * pagesize) {
+                    // if number of elements added to dataNavigator is less than  product of currentPage and pageSize we only add elements extra elements added
+                    itemsLength = dataNavigator.dataSize - fieldDefs.length;
+                }
+                else {
+                    // if number of elements added to dataNavigator is greater than  product of currentPage and pageSize we add elements the extra elements in newVal
+                    itemsLength = currentPage * pagesize - fieldDefs.length;
+                    currentPage++;
+                }
+                const startIndex = newVal.length - itemsLength;
+                itemsToPush = newVal.slice(startIndex);
+            }
+            else if (fieldDefs.length === currentPage * pagesize && currentPage === dataNavigator.dn.currentPage) {
+                // if dn.currentPage is not incremented still only old newVal is present hence we push empty array
+                itemsToPush = [];
+            }
+            newVal = itemsToPush;
+        }
+        // Add unique records to fieldDefs
+        if (parent.widgetType === 'wm-table' && (parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.DELETE || parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.EDIT)) {
+            fieldDefs = this.getUniqueRecordsInFieldDef(fieldDefs, newVal);
+        }
+        else {
+            fieldDefs = [...fieldDefs, ...newVal];
+        }
+        return [fieldDefs, currentPage];
+    }
+    // Add the unique records to fieldDefs
+    getUniqueRecordsInFieldDef(fieldDefs, newVal) {
+        let flag = false;
+        if (!fieldDefs.length) {
+            fieldDefs = newVal;
+        }
+        else {
+            newVal.forEach(function (newObj) {
+                flag = false;
+                fieldDefs.forEach(function (obj) {
+                    if (isEqual(newObj, obj)) {
+                        flag = true;
+                    }
+                });
+                if (flag === false) {
+                    fieldDefs.push(newObj);
+                }
+            });
+        }
+        return fieldDefs;
+    }
+    /**
+     * @description
+     * This function registers scroll events on the scrollable el, if the page doesn't have a scroll el then wheel event is registered on the requested node
+     * @param {object} parent table / list instance
+     * @param {string} nodeName tbody/ul
+     * @param {number} debounceNum provided to lodash debounce
+     * @returns null
+     */
+    bindScrollEvt(parent, nodeName, debounceNum) {
+        const dataNavigator = parent.dataNavigator;
+        const $el = parent.$element;
+        const $rootEl = $el.find(nodeName);
+        const $firstChild = $rootEl.children().first();
+        const self = this;
+        let $scrollParent;
+        let scrollNode;
+        if (!$firstChild.length) {
+            return;
+        }
+        $scrollParent = $firstChild.scrollParent(false);
+        if ($scrollParent[0] === document) {
+            scrollNode = document.body;
+        }
+        else {
+            scrollNode = $scrollParent[0];
+        }
+        // Check if the parent (ListComponent) has horizontal direction. If yes, use horizontal scroll logic; else, vertical (existing).
+        // This branches the behavior without touching the original vertical code.
+        const isHorizontal = parent.direction === 'row';
+        if (isHorizontal) {
+            this.bindHorizontalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self);
+        }
+        else {
+            this.bindVerticalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self);
+        }
+    }
+    bindHorizontalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self) {
+        // Horizontal scroll logic (mirrors vertical but uses left/width/deltaX).
+        // Has scroll (check horizontal overflow).
+        if (scrollNode.scrollWidth > scrollNode.clientWidth) {
+            let lastScrollLeft = 0;
+            $scrollParent
+                .each((index, node) => {
+                // Get initial scrollLeft (horizontal position).
+                lastScrollLeft = node === document ? $(window).scrollLeft() : node.scrollLeft;
+            })
+                .off('scroll.scroll_evt_horizontal') // Use a distinct event namespace to avoid conflicts with vertical.
+                .on('scroll.scroll_evt_horizontal', function (evt) {
+                let target = evt.target;
+                let clientWidth;
+                let totalWidth;
+                let scrollLeft;
+                // ScrollingElement fallback for IE/Safari.
+                target = target === document ? (target.scrollingElement || document.body) : target;
+                if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {
+                    evt.stopPropagation();
+                }
+                clientWidth = target.clientWidth;
+                totalWidth = target.scrollWidth;
+                scrollLeft = target === document.body ? $(window).scrollLeft() : target.scrollLeft;
+                // Check if scrolling rightward and near the end (90% threshold for preload).
+                if ((lastScrollLeft < scrollLeft) && (totalWidth * 0.9 < scrollLeft + clientWidth)) {
+                    $(this).off('scroll.scroll_evt_horizontal'); // Unbind to prevent duplicates; rebind on next render.
+                    self.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();
+                }
+                lastScrollLeft = scrollLeft;
+            });
+            $rootEl.off('wheel.scroll_evt_horizontal');
+        }
+        else {
+            // Fallback to wheel event for non-scrollable horizontal lists (detect rightward scroll).
+            $rootEl.on('wheel.scroll_evt_horizontal', e => {
+                if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {
+                    e.stopPropagation();
+                }
+                if (e.originalEvent.deltaX > 0) { // Rightward wheel delta.
+                    $rootEl.off('wheel.scroll_evt_horizontal');
+                    this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();
+                }
+            });
+        }
+    }
+    // Method for vertical scroll event binding.
+    bindVerticalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self) {
+        if (scrollNode.scrollHeight > scrollNode.clientHeight) {
+            let lastScrollTop = 0;
+            $scrollParent
+                .each((index, node) => {
+                // scrollTop property is 0 or undefined for body in IE, safari.
+                lastScrollTop = node === document ? (node.body.scrollTop || $(window).scrollTop()) : node.scrollTop;
+            })
+                .off('scroll.scroll_evt')
+                .on('scroll.scroll_evt', function (evt) {
+                let target = evt.target;
+                let clientHeight;
+                let totalHeight;
+                let scrollTop;
+                // scrollingElement is undefined for IE, safari. use body as target Element
+                target = target === document ? (target.scrollingElement || document.body) : target;
+                if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {
+                    evt.stopPropagation();
+                }
+                clientHeight = target.clientHeight;
+                totalHeight = target.scrollHeight;
+                scrollTop = target === document.body ? $(window).scrollTop() : target.scrollTop;
+                if ((lastScrollTop < scrollTop) && (totalHeight * 0.9 < scrollTop + clientHeight)) {
+                    $(this).off('scroll.scroll_evt');
+                    self.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();
+                }
+                lastScrollTop = scrollTop;
+            });
+            $rootEl.off('wheel.scroll_evt');
+        }
+        else {
+            $rootEl.on('wheel.scroll_evt', e => {
+                if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {
+                    e.stopPropagation();
+                }
+                if (e.originalEvent.deltaY > 0) {
+                    $rootEl.off('wheel.scroll_evt');
+                    this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();
+                }
+            });
+        }
+    }
+    /**
+     * @description
+     * This function calls fetchNextDatasetOnScroll fn on debounced time
+     * @param {object} dataNavigator pagination instance
+     * @param {number} debounceNum provided to lodash debounce
+     * @returns debounced function definition
+     */
+    debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent) {
+        return debounce(() => this.fetchNextDatasetOnScroll(dataNavigator, parent), debounceNum);
+    }
+    /**
+     * @description
+     * This function calls next set of data when navigated to next page
+     * @param {object} dataNavigator pagination instance
+     * @returns null
+     */
+    fetchNextDatasetOnScroll(dataNavigator, parent) {
+        // Load next set of data only after the success of current call
+        if (!parent.variableInflight) {
+            // Fix for [WMS-23263]: set 'isNextPageData' flag to true & 'isDataUpdatedByUser' to false as next page data is being rendered on Scroll
+            if (parent.widgetType === 'wm-table') {
+                // set isNextPageData flag to true as next page data is being rendered
+                parent.gridOptions.setIsNextPageData(true);
+                parent.gridOptions.setIsDataUpdatedByUser(false);
+            }
+            dataNavigator.navigatePage('next');
+        }
+    }
+    /**
+     * @description
+     * This function registers scroll events on the scrollable el for mobile projects
+     * @param {object} parent list instance
+     * @param {number} debounceNum provided to lodash debounce
+     * @returns null
+     */
+    bindIScrollEvt(parent, debounceNum) {
+        const $element = parent.$element;
+        const dataNavigator = parent.dataNavigator;
+        const app = parent.app;
+        const $scrollParent = $element.closest('[wmsmoothscroll="true"]');
+        const iScroll = get($scrollParent[0], 'iscroll');
+        // when iscroll is not initialised the notify the smoothscroll and subscribe to the iscroll update
+        if (!iScroll) {
+            const iScrollSubscription = app.subscribe('iscroll-update', (_el) => {
+                if (!isEmpty(_el) && _el.isSameNode($scrollParent[0])) {
+                    this.setIscrollHandlers($scrollParent[0], dataNavigator, debounceNum);
+                    iScrollSubscription();
+                }
+            });
+            app.notify('no-iscroll', $scrollParent[0]);
+            return;
+        }
+        this.setIscrollHandlers($scrollParent[0], dataNavigator, debounceNum);
+    }
+    /**
+     * @description
+     * This function registers scrollEnd event on the scrollable el for mobile projects
+     * @param {object} el scrollable element scope
+     * @param {object} dataNavigator pagination instance
+     * @param {number} debounceNum provided to lodash debounce
+     * @returns null
+     */
+    setIscrollHandlers(el, dataNavigator, debounceNum) {
+        const list = $(el).find('[wmList]').first();
+        const isHorizontal = list.attr('direction') === 'row';
+        if (isHorizontal) {
+            this.setHorizontalIscrollHandlers(el, dataNavigator, debounceNum, parent);
+        }
+        else {
+            this.setVerticalIscrollHandlers(el, dataNavigator, debounceNum, parent);
+        }
+    }
+    setHorizontalIscrollHandlers(el, dataNavigator, debounceNum, parent) {
+        // Horizontal iScroll logic (on 'scrollEnd' event).
+        let lastScrollLeft = 0;
+        const wrapper = get(el.iscroll, 'wrapper');
+        const self = el.iscroll;
+        el.iscroll.on('scrollEnd', () => {
+            const clientWidth = wrapper.clientWidth;
+            const totalWidth = wrapper.scrollWidth;
+            const scrollLeft = Math.abs(el.iscroll.x); // Horizontal position (absolute for rightward).
+            // Check rightward scroll and near-end threshold (90%).
+            if ((lastScrollLeft < scrollLeft) && (totalWidth * 0.9 < scrollLeft + clientWidth)) {
+                this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();
+                if (self.indicatorRefresh) {
+                    self.indicatorRefresh();
+                }
+            }
+            lastScrollLeft = scrollLeft;
+        });
+    }
+    setVerticalIscrollHandlers(el, dataNavigator, debounceNum, parent) {
+        let lastScrollTop = 0;
+        const wrapper = get(el.iscroll, 'wrapper');
+        const self = el.iscroll;
+        el.iscroll.on('scrollEnd', () => {
+            const clientHeight = wrapper.clientHeight, totalHeight = wrapper.scrollHeight, scrollTop = Math.abs(el.iscroll.y);
+            if ((lastScrollTop < scrollTop) && (totalHeight * 0.9 < scrollTop + clientHeight)) {
+                this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();
+                if (self.indicatorRefresh) {
+                    self.indicatorRefresh();
+                }
+            }
+            lastScrollTop = scrollTop;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PaginationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PaginationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PaginationService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.service.js","sourceRoot":"","sources":["../../../../projects/core/src/services/pagination.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDefined } from '../utils/utils';\nimport { Injectable } from '@angular/core';\nimport {debounce, get, isEmpty, isEqual} from \"lodash-es\";\n\ndeclare const $;\n@Injectable({ providedIn: 'root' })\n\nexport class PaginationService {\n    /**\n     * @description\n     * This function returns the updated fields and the current page index when navigated to the next set of data\n     * @param {object} parent table / list instance\n     * @param {object} newVal updated fields info\n     * @returns fieldDefs and current page index\n     */\n    public updateFieldsOnPagination(parent, newVal) {\n        let fieldDefs = parent.widgetType === 'wm-table' ? parent.gridData : parent.fieldDefs;\n        // remove the deleted row from the list\n        if (parent.widgetType === 'wm-table' && (parent.gridOptions.isNavTypeScrollOrOndemand()) && parent.gridOptions.deletedRowIndex !== -1) {\n            fieldDefs.splice(parent.gridOptions.deletedRowIndex, 1);\n            parent.gridOptions.setDeletedRowIndex(-1);\n        }\n        // reset fieldDefs if last action performed is search or sort\n        if (parent.widgetType === 'wm-table' && (parent.gridOptions.isNavTypeScrollOrOndemand())  && (parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.SEARCH_OR_SORT || parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.FILTER_CRITERIA || parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.DATASET_UPDATE)) {\n            fieldDefs = [];\n            parent.gridOptions.setCurrentPage(1);\n        }\n        let currentPage;\n        if (parent.widgetType === 'wm-table') {\n            currentPage = parent.gridOptions.showviewlessbutton && (parent.gridOptions.mode === 'viewless') ? parent.gridOptions.getCurrentPage() : parent.currentPage;\n        } else {\n            currentPage = parent.currentPage;\n        }\n        const dataNavigator = parent.dataNavigator;\n        const pagesize = parent.pagesize;\n\n        if (!isDefined(fieldDefs) || dataNavigator.isFirstPage()) {\n            fieldDefs = [];\n            currentPage = 1;\n        } else if (fieldDefs.length / pagesize <= dataNavigator.pageCount) {\n            let itemsLength,\n                itemsToPush = [];\n            // we push the newVal only when dn.currentPage gets incremented because that is when new items gets added to newVal\n            if (fieldDefs.length === currentPage * pagesize && (currentPage + 1) === dataNavigator.dn.currentPage) {\n                itemsToPush = newVal;\n                currentPage++;\n            } else if (fieldDefs.length < currentPage * pagesize) {\n                if ((fieldDefs.length === (currentPage - 1) * pagesize) && ((currentPage - 1) === dataNavigator.dn.currentPage)) {\n                    // if dn.currentPage is not incremented still only old newVal is present hence we push empty array\n                    newVal = [];\n                } else if (dataNavigator.dataSize < currentPage * pagesize) {\n                    // if number of elements added to dataNavigator is less than  product of currentPage and pageSize we only add elements extra elements added\n                    itemsLength = dataNavigator.dataSize - fieldDefs.length;\n                } else {\n                    // if number of elements added to dataNavigator is greater than  product of currentPage and pageSize we add elements the extra elements in newVal\n                    itemsLength = currentPage * pagesize - fieldDefs.length;\n                    currentPage++;\n                }\n                const startIndex = newVal.length - itemsLength;\n                itemsToPush = newVal.slice(startIndex);\n            } else if (fieldDefs.length === currentPage * pagesize && currentPage === dataNavigator.dn.currentPage) {\n                // if dn.currentPage is not incremented still only old newVal is present hence we push empty array\n                itemsToPush = [];\n            }\n            newVal = itemsToPush;\n        }\n\n        // Add unique records to fieldDefs\n        if (parent.widgetType === 'wm-table' && (parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.DELETE  || parent.gridOptions.lastActionPerformed === parent.gridOptions.ACTIONS.EDIT)) {\n            fieldDefs = this.getUniqueRecordsInFieldDef(fieldDefs, newVal);\n        } else {\n            fieldDefs = [...fieldDefs, ...newVal];\n        }\n        return [fieldDefs, currentPage];\n    }\n\n    // Add the unique records to fieldDefs\n    public getUniqueRecordsInFieldDef(fieldDefs, newVal) {\n        let flag = false;\n        if (!fieldDefs.length) {\n            fieldDefs = newVal;\n        } else {\n            newVal.forEach(function (newObj) {\n                flag = false;\n                fieldDefs.forEach(function (obj) {\n                    if (isEqual(newObj, obj)) {\n                        flag = true;\n                    }\n                });\n                if (flag === false) {\n                    fieldDefs.push(newObj);\n                }\n            });\n        }\n        return fieldDefs;\n    }\n\n    /**\n     * @description\n     * This function registers scroll events on the scrollable el, if the page doesn't have a scroll el then wheel event is registered on the requested node\n     * @param {object} parent table / list instance\n     * @param {string} nodeName tbody/ul\n     * @param {number} debounceNum provided to lodash debounce\n     * @returns null\n     */\n    public bindScrollEvt(parent, nodeName, debounceNum) {\n        const dataNavigator = parent.dataNavigator;\n        const $el = parent.$element;\n        const $rootEl = $el.find(nodeName);\n        const $firstChild = $rootEl.children().first();\n\n        const self = this;\n        let $scrollParent;\n        let scrollNode;\n\n        if (!$firstChild.length) {\n            return;\n        }\n\n        $scrollParent = $firstChild.scrollParent(false);\n\n        if ($scrollParent[0] === document) {\n            scrollNode = document.body;\n        } else {\n            scrollNode = $scrollParent[0];\n        }\n\n        // Check if the parent (ListComponent) has horizontal direction. If yes, use horizontal scroll logic; else, vertical (existing).\n        // This branches the behavior without touching the original vertical code.\n        const isHorizontal = parent.direction === 'row';\n\n        if (isHorizontal) {\n            this.bindHorizontalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self);\n        } else {\n            this.bindVerticalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self);\n        }\n    }\n\n    private bindHorizontalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self) {\n        // Horizontal scroll logic (mirrors vertical but uses left/width/deltaX).\n        // Has scroll (check horizontal overflow).\n        if (scrollNode.scrollWidth > scrollNode.clientWidth) {\n            let lastScrollLeft = 0;\n            $scrollParent\n                .each((index: number, node) => {\n                    // Get initial scrollLeft (horizontal position).\n                    lastScrollLeft = node === document ? $(window).scrollLeft() : (node as HTMLElement).scrollLeft;\n                })\n                .off('scroll.scroll_evt_horizontal') // Use a distinct event namespace to avoid conflicts with vertical.\n                .on('scroll.scroll_evt_horizontal', function (evt) {\n                    let target = evt.target;\n                    let clientWidth;\n                    let totalWidth;\n                    let scrollLeft;\n                    // ScrollingElement fallback for IE/Safari.\n                    target = target === document ? (target.scrollingElement || document.body) : target;\n                    if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {\n                        evt.stopPropagation();\n                    }\n                    clientWidth = target.clientWidth;\n                    totalWidth = target.scrollWidth;\n                    scrollLeft = target === document.body ? $(window).scrollLeft() : target.scrollLeft;\n                    // Check if scrolling rightward and near the end (90% threshold for preload).\n                    if ((lastScrollLeft < scrollLeft) && (totalWidth * 0.9 < scrollLeft + clientWidth)) {\n                        $(this).off('scroll.scroll_evt_horizontal'); // Unbind to prevent duplicates; rebind on next render.\n                        self.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();\n                    }\n                    lastScrollLeft = scrollLeft;\n                });\n            $rootEl.off('wheel.scroll_evt_horizontal');\n        } else {\n            // Fallback to wheel event for non-scrollable horizontal lists (detect rightward scroll).\n            $rootEl.on('wheel.scroll_evt_horizontal', e => {\n                if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {\n                    e.stopPropagation();\n                }\n                if (e.originalEvent.deltaX > 0) { // Rightward wheel delta.\n                    $rootEl.off('wheel.scroll_evt_horizontal');\n                    this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();\n                }\n            });\n        }\n    }\n\n    // Method for vertical scroll event binding.\n    private bindVerticalScrollEvt(parent, $scrollParent, $rootEl, scrollNode, dataNavigator, debounceNum, self) {\n        if (scrollNode.scrollHeight > scrollNode.clientHeight) {\n            let lastScrollTop = 0;\n            $scrollParent\n                .each((index: number, node) => {\n                    // scrollTop property is 0 or undefined for body in IE, safari.\n                    lastScrollTop = node === document ? (node.body.scrollTop || $(window).scrollTop()) : (node as HTMLElement).scrollTop;\n                })\n                .off('scroll.scroll_evt')\n                .on('scroll.scroll_evt', function (evt) {\n                    let target = evt.target;\n                    let clientHeight;\n                    let totalHeight;\n                    let scrollTop;\n                    // scrollingElement is undefined for IE, safari. use body as target Element\n                    target = target === document ? (target.scrollingElement || document.body) : target;\n                    if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {\n                        evt.stopPropagation();\n                    }\n                    clientHeight = target.clientHeight;\n                    totalHeight = target.scrollHeight;\n                    scrollTop = target === document.body ? $(window).scrollTop() : target.scrollTop;\n                    if ((lastScrollTop < scrollTop) && (totalHeight * 0.9 < scrollTop + clientHeight)) {\n                        $(this).off('scroll.scroll_evt');\n                        self.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();\n                    }\n                    lastScrollTop = scrollTop;\n                });\n            $rootEl.off('wheel.scroll_evt');\n         } else {\n            $rootEl.on('wheel.scroll_evt', e => {\n                if (parent.widgetType === 'wm-table' && parent.gridOptions.isNavTypeScrollOrOndemand()) {\n                    e.stopPropagation();\n                }\n                if (e.originalEvent.deltaY > 0) {\n                    $rootEl.off('wheel.scroll_evt');\n                    this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();\n                }\n            });\n        }\n    }\n\n    /**\n     * @description\n     * This function calls fetchNextDatasetOnScroll fn on debounced time\n     * @param {object} dataNavigator pagination instance\n     * @param {number} debounceNum provided to lodash debounce\n     * @returns debounced function definition\n     */\n    public debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent) {\n        return debounce(() => this.fetchNextDatasetOnScroll(dataNavigator, parent), debounceNum);\n    }\n\n    /**\n     * @description\n     * This function calls next set of data when navigated to next page\n     * @param {object} dataNavigator pagination instance\n     * @returns null\n     */\n    public fetchNextDatasetOnScroll(dataNavigator, parent) {\n        // Load next set of data only after the success of current call\n        if (!parent.variableInflight) {\n            // Fix for [WMS-23263]: set 'isNextPageData' flag to true & 'isDataUpdatedByUser' to false as next page data is being rendered on Scroll\n            if (parent.widgetType === 'wm-table') {\n                // set isNextPageData flag to true as next page data is being rendered\n                parent.gridOptions.setIsNextPageData(true);\n                parent.gridOptions.setIsDataUpdatedByUser(false);\n            }\n            dataNavigator.navigatePage('next');\n        }\n    }\n\n    /**\n     * @description\n     * This function registers scroll events on the scrollable el for mobile projects\n     * @param {object} parent list instance\n     * @param {number} debounceNum provided to lodash debounce\n     * @returns null\n     */\n    public bindIScrollEvt(parent, debounceNum) {\n        const $element = parent.$element;\n        const dataNavigator = parent.dataNavigator;\n        const app = parent.app;\n\n        const $scrollParent = $element.closest('[wmsmoothscroll=\"true\"]');\n\n        const iScroll = get($scrollParent[0], 'iscroll');\n\n        // when iscroll is not initialised the notify the smoothscroll and subscribe to the iscroll update\n        if (!iScroll) {\n            const iScrollSubscription = app.subscribe('iscroll-update', (_el) => {\n                if (!isEmpty(_el) && _el.isSameNode($scrollParent[0])) {\n                    this.setIscrollHandlers($scrollParent[0], dataNavigator, debounceNum);\n                    iScrollSubscription();\n                }\n            });\n            app.notify('no-iscroll', $scrollParent[0]);\n            return;\n        }\n        this.setIscrollHandlers($scrollParent[0], dataNavigator, debounceNum);\n    }\n\n    /**\n     * @description\n     * This function registers scrollEnd event on the scrollable el for mobile projects\n     * @param {object} el scrollable element scope\n     * @param {object} dataNavigator pagination instance\n     * @param {number} debounceNum provided to lodash debounce\n     * @returns null\n     */\n    public setIscrollHandlers(el, dataNavigator, debounceNum) {\n        const list = $(el).find('[wmList]').first();  \n        const isHorizontal = list.attr('direction') === 'row';\n\n        if (isHorizontal) {\n            this.setHorizontalIscrollHandlers(el, dataNavigator, debounceNum, parent);\n        } else {\n            this.setVerticalIscrollHandlers(el, dataNavigator, debounceNum, parent);\n        }\n    }\n\n    private setHorizontalIscrollHandlers(el, dataNavigator, debounceNum, parent) {\n        // Horizontal iScroll logic (on 'scrollEnd' event).\n        let lastScrollLeft = 0;\n        const wrapper = get(el.iscroll, 'wrapper');\n        const self = el.iscroll;\n        el.iscroll.on('scrollEnd', () => {\n            const clientWidth = wrapper.clientWidth;\n            const totalWidth = wrapper.scrollWidth;\n            const scrollLeft = Math.abs(el.iscroll.x); // Horizontal position (absolute for rightward).\n            // Check rightward scroll and near-end threshold (90%).\n            if ((lastScrollLeft < scrollLeft) && (totalWidth * 0.9 < scrollLeft + clientWidth)) {\n                this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();\n                if (self.indicatorRefresh) {\n                    self.indicatorRefresh();\n                }\n            }\n            lastScrollLeft = scrollLeft;\n        });\n    }\n\n    private setVerticalIscrollHandlers(el, dataNavigator, debounceNum, parent) {\n        let lastScrollTop = 0;\n        const wrapper = get(el.iscroll, 'wrapper');\n        const self = el.iscroll;\n        el.iscroll.on('scrollEnd', () => {\n            const clientHeight = wrapper.clientHeight,\n                totalHeight = wrapper.scrollHeight,\n                scrollTop = Math.abs(el.iscroll.y);\n            if ((lastScrollTop < scrollTop) && (totalHeight * 0.9 < scrollTop + clientHeight)) {\n                this.debouncedFetchNextDatasetOnScroll(dataNavigator, debounceNum, parent)();\n                if (self.indicatorRefresh) {\n                    self.indicatorRefresh();\n                }\n            }\n            lastScrollTop = scrollTop;\n        });\n    }\n}"]}

package/core/esm2022/services/script-loader.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { _WM_APP_PROJECT } from '../utils/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export const ScriptStore = [];
+export class ScriptLoaderService {
+    constructor(http) {
+        this.http = http;
+        this.scripts = {};
+        ScriptStore.forEach((script) => {
+            this.scripts[script.name] = {
+                loaded: false,
+                src: script.src
+            };
+        });
+    }
+    load(...scripts) {
+        if (scripts && scripts.length) {
+            return Promise.all(scripts.map(s => {
+                return this.loadScript(s);
+            }));
+        }
+        return Promise.resolve();
+    }
+    loadScript(name) {
+        return new Promise((resolve, reject) => {
+            if (this.scripts[name] && this.scripts[name].loaded) {
+                resolve({ script: name, loaded: true });
+                return;
+            }
+            else if (!this.scripts[name]) {
+                this.scripts[name] = {
+                    loaded: false,
+                    src: name
+                };
+            }
+            //load script
+            let script = document.createElement('script');
+            script.type = 'text/javascript';
+            script.async = false;
+            const src = this.scripts[name].src;
+            if (src.startsWith("http")) {
+                script.src = src;
+            }
+            else {
+                script.src = (_WM_APP_PROJECT.cdnUrl || _WM_APP_PROJECT.ngDest) + src;
+            }
+            if (script.readyState) { //IE
+                script.onreadystatechange = () => {
+                    if (script.readyState === "loaded" || script.readyState === "complete") {
+                        script.onreadystatechange = null;
+                        this.scripts[name].loaded = true;
+                        resolve({ script: name, loaded: true });
+                    }
+                };
+            }
+            else { //Others
+                script.onload = () => {
+                    this.scripts[name].loaded = true;
+                    resolve({ script: name, loaded: true });
+                };
+            }
+            script.onerror = (error) => resolve({ script: name, loaded: false, status: 'Loaded' });
+            document.getElementsByTagName('head')[0].appendChild(script);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScriptLoaderService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScriptLoaderService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScriptLoaderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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