@wavemaker/app-ng-runtime 11.14.1-6.6324 → 11.14.1-8.6337

package/core/bundles/index.umd.js

@@ -1450,11 +1450,11 @@
        }
    };
 
-   const $RAF$1 = window.requestAnimationFrame;
+   const $RAF = window.requestAnimationFrame;
    const $RAFQueue = [];
    const invokeLater = fn => {
        if (!$RAFQueue.length) {
-           $RAF$1(() => {
+           $RAF(() => {
                $RAFQueue.forEach(f => f());
                $RAFQueue.length = 0;
            });
@@ -2191,14 +2191,89 @@
        return fnExecutor(expr, ExpressionType.Action);
    };
 
+   // Constants
+   const WIDGET_ID_REGEX = /^(widget-[^_]+)/;
+   const WIDGET_PROPERTY_REGEX = /^widget-[^_]+_(.+)$/;
+   const ARRAY_INDEX_PLACEHOLDER = '[$i]';
+   const ARRAY_INDEX_ZERO = '[0]';
+   const DEBOUNCE_WAIT = 100;
+   const MAX_WATCH_CYCLES = 5;
    const registry = new Map();
    const watchIdGenerator = new IDGenerator('watch-id-');
-   const FIRST_TIME_WATCH = {};
-   Object.freeze(FIRST_TIME_WATCH);
-   const isFirstTimeChange = v => v === FIRST_TIME_WATCH;
+   const FIRST_TIME_WATCH = Object.freeze({});
+   // State
    let muted = false;
+   let changedByWatch = false;
+   let skipWatchers = false;
+   let ngZone;
    let appRef;
-   const debounce = (fn, wait = 50) => {
+   /********************************************************************
+    * CLEANUP SCHEDULER WITH:
+    *  - Significant watcher delta trigger (+/-)
+    *  - UI stabilization delay (1–2 seconds)
+    *  - Cooldown to prevent repeated scheduling
+    ********************************************************************/
+   const CLEANUP_TRIGGER_DELTA = 300; // watcher change threshold
+   const CLEANUP_DELAY = 1500; // delay before running cleanup
+   const CLEANUP_COOLDOWN = 4000; // prevent re-scheduling for 4s
+   let lastWatcherCount = 0;
+   let scheduledCleanup = null;
+   let lastScheduledTime = 0;
+   function getWatcherCount() {
+       let count = 0;
+       registry.forEach(bucket => count += bucket.size);
+       return count;
+   }
+   const cleanupStaleWatchers = () => {
+       // console.log(".........Cleaning up stale watchers...registry.size....", registry.size);
+       let removed = 0;
+       registry.forEach((bucket, widgetId) => {
+           if (!document.querySelector(`[widget-id="${widgetId}"]`)) {
+               for (const key in bucket) {
+                   if (bucket.hasOwnProperty(key) && key !== "scopeType" && key !== "scopeName" && typeof bucket[key] !== "function") {
+                       let watchInfo = bucket[key];
+                       if (watchInfo && watchInfo.destroyFn) {
+                           watchInfo.destroyFn();
+                       }
+                   }
+               }
+               removed++;
+               registry.delete(widgetId);
+               return;
+           }
+       });
+       return removed;
+   };
+   const scheduleThresholdCleanup = () => {
+       const now = performance.now();
+       let lastTriggerPeriod = now - lastScheduledTime;
+       // If a cleanup was scheduled recently, skip scheduling
+       if (lastTriggerPeriod < CLEANUP_COOLDOWN) {
+           return;
+       }
+       const current = getWatcherCount();
+       const delta = Math.abs(current - lastWatcherCount); // significant + or -
+       // If change not large enough, skip scheduling
+       if (delta <= CLEANUP_TRIGGER_DELTA) {
+           lastWatcherCount = current;
+           return;
+       }
+       // Prevent re-scheduling: set timestamp early
+       lastScheduledTime = now;
+       // Clear previous scheduled cleanup (if any)
+       if (scheduledCleanup) {
+           clearTimeout(scheduledCleanup);
+       }
+       // Schedule cleanup after UI stabilizes (delay prevents aggressive cleanup)
+       scheduledCleanup = setTimeout(() => {
+           cleanupStaleWatchers();
+           scheduledCleanup = null;
+       }, CLEANUP_DELAY);
+       lastWatcherCount = current;
+   };
+   // Utility functions
+   const isFirstTimeChange = (v) => v === FIRST_TIME_WATCH;
+   const debounce = (fn, wait = DEBOUNCE_WAIT) => {
        let timeout;
        return (...args) => {
            window['__zone_symbol__clearTimeout'](timeout);
@@ -2212,115 +2287,350 @@
        muted = false;
        triggerWatchers();
    };
+   /**
+    * Extracts widget ID from identifier (e.g., "widget-id23_eventsource" -> "widget-id23")
+    */
+   const getWidgetId = (identifier) => {
+       if (!identifier || typeof identifier !== 'string') {
+           return null;
+       }
+       const match = identifier.match(WIDGET_ID_REGEX);
+       return match ? match[1] : null;
+   };
+   /**
+    * Extracts property name from identifier (e.g., "widget-id23_eventsource" -> "eventsource")
+    */
+   const getPropertyName = (identifier) => {
+       if (!identifier || typeof identifier !== 'string') {
+           return identifier;
+       }
+       const match = identifier.match(WIDGET_PROPERTY_REGEX);
+       return match ? match[1] : identifier;
+   };
+   /**
+    * Array consumer wrapper for array-based expressions
+    */
    const arrayConsumer = (listenerFn, restExpr, newVal, oldVal) => {
-       let data = newVal, formattedData;
-       if (lodashEs.isArray(data)) {
-           formattedData = data.map(function (datum) {
-               return findValueOf(datum, restExpr);
-           });
-           // If resulting structure is an array of array, flatten it
-           if (lodashEs.isArray(formattedData[0])) {
-               formattedData = lodashEs.flatten(formattedData);
-           }
-           listenerFn(formattedData, oldVal);
+       if (!lodashEs.isArray(newVal)) {
+           return;
+       }
+       let formattedData = newVal.map(datum => findValueOf(datum, restExpr));
+       // Flatten if result is array of arrays
+       if (lodashEs.isArray(formattedData[0])) {
+           formattedData = lodashEs.flatten(formattedData);
        }
+       listenerFn(formattedData, oldVal);
    };
-   const getUpdatedWatcInfo = (expr, acceptsArray, listener) => {
-       // listener doesn't accept array
-       // replace all `[$i]` with `[0]` and return the expression
-       let regex = /\[\$i\]/g, $I = '[$i]', $0 = '[0]';
+   /**
+    * Updates watch info for array expressions
+    */
+   const getUpdatedWatchInfo = (expr, acceptsArray, listener) => {
+       const regex = /\[\$i\]/g;
        if (!acceptsArray) {
            return {
-               'expr': expr.replace(regex, $0),
-               'listener': listener
+               expr: expr.replace(regex, ARRAY_INDEX_ZERO),
+               listener
            };
        }
-       // listener accepts array
-       // replace all except the last `[$i]` with `[0]` and return the expression.
-       var index = expr.lastIndexOf($I), _expr = expr.substr(0, index).replace($I, $0), restExpr = expr.substr(index + 5), arrayConsumerFn = listener;
-       if (restExpr) {
-           arrayConsumerFn = arrayConsumer.bind(undefined, listener, restExpr);
-       }
+       const lastIndex = expr.lastIndexOf(ARRAY_INDEX_PLACEHOLDER);
+       const baseExpr = expr.substring(0, lastIndex).replace(ARRAY_INDEX_PLACEHOLDER, ARRAY_INDEX_ZERO);
+       const restExpr = expr.substring(lastIndex + 5);
+       const arrayConsumerFn = restExpr
+           ? arrayConsumer.bind(undefined, listener, restExpr)
+           : listener;
        return {
-           'expr': _expr,
-           'listener': arrayConsumerFn
+           expr: baseExpr,
+           listener: arrayConsumerFn
        };
    };
+   /**
+    * Determines if an expression is static (doesn't need to be watched)
+    */
+   const STATIC_EXPRESSION_NAMES = [
+       "row.getProperty('investment')",
+       "row.getProperty('factsheetLink')",
+       "row.getProperty('isRebalanceEligible')"
+   ];
+   const isStaticExpression = (expr) => {
+       if (typeof expr !== 'string') {
+           return false;
+       }
+       const trimmedExpr = expr.trim();
+       // Expressions that always evaluate to localization strings
+       // if (trimmedExpr.includes('appLocale')) {
+       //     return true;
+       // }
+       // Hard-coded static expression names
+       if (STATIC_EXPRESSION_NAMES.includes(trimmedExpr)) {
+           return true;
+       }
+       return false;
+   };
+   /**
+    * Gets the scope type from the scope object
+    */
+   const getScopeType = ($scope) => {
+       if (!$scope) {
+           return null;
+       }
+       if ($scope.pageName)
+           return 'Page';
+       if ($scope.prefabName)
+           return 'Prefab';
+       if ($scope.partialName)
+           return 'Partial';
+       // Check for App scope
+       if ($scope.Variables !== undefined &&
+           $scope.Actions !== undefined &&
+           !$scope.pageName &&
+           !$scope.prefabName &&
+           !$scope.partialName) {
+           return 'App';
+       }
+       if ($scope.constructor?.name === 'AppRef') {
+           return 'App';
+       }
+       return null;
+   };
+   /**
+    * Gets scope name based on scope type
+    */
+   const getScopeName = ($scope, scopeType) => {
+       if (!scopeType || !$scope) {
+           return null;
+       }
+       switch (scopeType) {
+           case 'Prefab': return $scope.prefabName || null;
+           case 'Partial': return $scope.partialName || null;
+           case 'Page': return $scope.pageName || null;
+           default: return null;
+       }
+   };
+   /**
+    * Main watch function
+    */
    const $watch = (expr, $scope, $locals, listener, identifier = watchIdGenerator.nextUid(), doNotClone = false, config = {}, isMuted) => {
-       if (expr.indexOf('[$i]') !== -1) {
-           let watchInfo = getUpdatedWatcInfo(expr, config && (config.arrayType || config.isList), listener);
+       // Handle array expressions
+       if (expr.includes(ARRAY_INDEX_PLACEHOLDER)) {
+           const watchInfo = getUpdatedWatchInfo(expr, config.arrayType || config.isList || false, listener);
            expr = watchInfo.expr;
            listener = watchInfo.listener;
        }
+       // Handle static expressions
+       if (isStaticExpression(expr)) {
+           try {
+               const fn = $parseExpr(expr);
+               const staticValue = fn($scope, $locals);
+               listener(staticValue, FIRST_TIME_WATCH);
+           }
+           catch (e) {
+               console.warn(`Error evaluating static expression '${expr}':`, e);
+               listener(undefined, FIRST_TIME_WATCH);
+           }
+           return () => { }; // No-op unsubscribe
+       }
        const fn = $parseExpr(expr);
-       registry.set(identifier, {
-           fn: fn.bind(expr, $scope, $locals),
+       const scopeType = getScopeType($scope);
+       const scopeName = getScopeName($scope, scopeType);
+       const destroyFn = () => $unwatch(identifier);
+       const watchInfo = {
+           fn: fn.bind(null, $scope, $locals),
            listener,
            expr,
            last: FIRST_TIME_WATCH,
            doNotClone,
-           isMuted: isMuted
+           isMuted,
+           scopeType,
+           scopeName,
+           destroyFn
+       };
+       // Store in registry
+       const widgetId = getWidgetId(identifier);
+       if (widgetId) {
+           const propertyName = getPropertyName(identifier);
+           if (!registry.has(widgetId)) {
+               registry.set(widgetId, {});
+           }
+           const widgetGroup = registry.get(widgetId);
+           widgetGroup[propertyName] = watchInfo;
+       }
+       else {
+           registry.set(identifier, watchInfo);
+       }
+       return destroyFn;
+   };
+   /**
+    * Unwatches a single identifier
+    */
+   const $unwatch = (identifier) => {
+       const widgetId = getWidgetId(identifier);
+       if (widgetId) {
+           const propertyName = getPropertyName(identifier);
+           const widgetGroup = registry.get(widgetId);
+           //@ts-ignore
+           if (widgetGroup && typeof widgetGroup === 'object' && !widgetGroup.fn) {
+               const watchInfo = widgetGroup[propertyName];
+               if (watchInfo) {
+                   delete widgetGroup[propertyName];
+                   // Clean up empty widget groups
+                   if (Object.keys(widgetGroup).length === 0) {
+                       registry.delete(widgetId);
+                   }
+                   return true;
+               }
+           }
+       }
+       // Fallback to direct lookup
+       if (registry.has(identifier)) {
+           registry.delete(identifier);
+           return true;
+       }
+       return false;
+   };
+   /**
+    * Unwatches all watchers for a specific widget ID
+    */
+   const $unwatchAll = (widgetId) => {
+       if (!widgetId || typeof widgetId !== 'string') {
+           return 0;
+       }
+       const widgetGroup = registry.get(widgetId);
+       if (widgetGroup && typeof widgetGroup === 'object' && !widgetGroup.fn) {
+           const count = Object.keys(widgetGroup).length;
+           registry.delete(widgetId);
+           return count;
+       }
+       // Fallback: find all identifiers starting with this widget ID
+       let removedCount = 0;
+       const identifiersToRemove = [];
+       registry.forEach((_, key) => {
+           if (key.startsWith(widgetId + '_')) {
+               identifiersToRemove.push(key);
+           }
        });
-       return () => $unwatch(identifier);
+       identifiersToRemove.forEach(identifier => {
+           if ($unwatch(identifier)) {
+               removedCount++;
+           }
+       });
+       return removedCount;
    };
-   const $unwatch = identifier => registry.delete(identifier);
-   let changedByWatch = false;
-   const $RAF = window.requestAnimationFrame;
-   let ngZone;
-   const triggerWatchers = (ignoreMuted) => {
+   /**
+    * Unwatches all watchers for a specific scope (Page, Prefab, Partial, or App)
+    * Now works directly with the main registry instead of separate scoped registries
+    */
+   const $unwatchAllByScope = (scopeType, scopeName) => {
+       if (!scopeType) {
+           return 0;
+       }
+       let removedCount = 0;
+       const identifiersToRemove = [];
+       registry.forEach((value, key) => {
+           // Handle grouped structure (widget groups)
+           if (value && typeof value === 'object' && !value.fn) {
+               Object.entries(value).forEach(([propertyName, watchInfo]) => {
+                   if (watchInfo?.scopeType === scopeType &&
+                       (!scopeName || watchInfo.scopeName === scopeName)) {
+                       identifiersToRemove.push(`${key}_${propertyName}`);
+                   }
+               });
+           }
+           else {
+               // Direct watchInfo
+               const watchInfo = value;
+               if (watchInfo?.scopeType === scopeType &&
+                   (!scopeName || watchInfo.scopeName === scopeName)) {
+                   identifiersToRemove.push(key);
+               }
+           }
+       });
+       // Unwatch all collected identifiers
+       identifiersToRemove.forEach(identifier => {
+           if ($unwatch(identifier)) {
+               removedCount++;
+           }
+       });
+       return removedCount;
+   };
+   /**
+    * Processes a single watch info during trigger cycle
+    */
+   const processWatchInfo = (watchInfo) => {
+       if (!watchInfo?.fn || (watchInfo.isMuted?.() ?? false)) {
+           return false;
+       }
+       let newValue;
+       try {
+           newValue = watchInfo.fn();
+       }
+       catch (e) {
+           console.warn(`Error executing expression: '${watchInfo.expr}'`, e);
+           return false;
+       }
+       if (lodashEs.isEqual(newValue, watchInfo.last)) {
+           return false;
+       }
+       // Change detected
+       changedByWatch = true;
+       watchInfo.last = lodashEs.isObject(newValue) && !watchInfo.doNotClone
+           ? lodashEs.clone(newValue)
+           : newValue;
+       watchInfo.listener(newValue, watchInfo.last === newValue ? FIRST_TIME_WATCH : watchInfo.last);
+       changedByWatch = false;
+       return true;
+   };
+   /**
+    * Triggers all watchers
+    */
+   const triggerWatchers = (ignoreMuted = false) => {
        if (muted && !ignoreMuted) {
            return;
        }
-       const limit = 5;
        let pass = 1;
        let changeDetected;
        do {
            changeDetected = false;
-           registry.forEach(watchInfo => {
-               if (watchInfo.isMuted && watchInfo.isMuted()) {
-                   return;
-               }
-               const fn = watchInfo.fn;
-               const listener = watchInfo.listener;
-               const ov = watchInfo.last;
-               let nv;
-               try {
-                   nv = fn();
-               }
-               catch (e) {
-                   console.warn(`error in executing expression: '${watchInfo.expr}'`);
+           registry.forEach((value) => {
+               // Handle grouped structure
+               if (value && typeof value === 'object' && !value.fn) {
+                   Object.values(value).forEach((watchInfo) => {
+                       if (processWatchInfo(watchInfo)) {
+                           changeDetected = true;
+                       }
+                   });
                }
-               if (!lodashEs.isEqual(nv, ov)) {
-                   changeDetected = true;
-                   changedByWatch = true;
-                   watchInfo.last = nv;
-                   // @ts-ignore
-                   if (lodashEs.isObject(nv) && !watchInfo.doNotClone && nv.__cloneable__ !== false) {
-                       watchInfo.last = lodashEs.clone(nv);
+               else {
+                   // Direct watchInfo
+                   if (processWatchInfo(value)) {
+                       changeDetected = true;
                    }
-                   listener(nv, ov);
-                   resetChangeFromWatch();
                }
            });
            pass++;
-       } while (changeDetected && pass < limit);
-       if (changeDetected && pass === limit) {
-           console.warn(`Number of watch cycles gone above set limit of: ${limit} `);
+       } while (changeDetected && pass < MAX_WATCH_CYCLES);
+       // Schedule cleanup after watchers are triggered
+       scheduleThresholdCleanup();
+       if (changeDetected && pass === MAX_WATCH_CYCLES) {
+           console.warn(`Watch cycles exceeded limit of ${MAX_WATCH_CYCLES}`);
        }
    };
-   const setNgZone = zone => ngZone = zone;
-   const setAppRef = ref => {
+   // Angular zone integration
+   const setNgZone = (zone) => {
+       ngZone = zone;
+   };
+   const setAppRef = (ref) => {
        appRef = ref;
    };
    const isChangeFromWatch = () => changedByWatch;
-   const resetChangeFromWatch = () => changedByWatch = false;
-   window.watchRegistry = registry;
-   let skipWatchers;
+   const resetChangeFromWatch = () => {
+       changedByWatch = false;
+   };
+   // Debounced trigger
    const debouncedTriggerWatchers = debounce(() => {
        skipWatchers = true;
        ngZone.run(() => triggerWatchers());
-   }, 100);
-   const $invokeWatchers = (force, ignoreMuted) => {
+   }, DEBOUNCE_WAIT);
+   const $invokeWatchers = (force = false, ignoreMuted = false) => {
        if (force) {
            triggerWatchers(ignoreMuted);
        }
@@ -2334,7 +2644,8 @@
    };
    const $appDigest = (() => {
        let queued = false;
-       return (force) => {
+       const $RAF = window.requestAnimationFrame;
+       return (force = false) => {
            if (!appRef) {
                return;
            }
@@ -2346,16 +2657,16 @@
                if (queued) {
                    return;
                }
-               else {
-                   queued = true;
-                   $RAF(() => {
-                       ngZone.run(() => appRef.tick());
-                       queued = false;
-                   });
-               }
+               queued = true;
+               $RAF(() => {
+                   ngZone.run(() => appRef.tick());
+                   queued = false;
+               });
            }
        };
    })();
+   // Export registry for debugging
+   window.watchRegistry = registry;
 
    exports.ComponentType = void 0;
    (function (ComponentType) {
@@ -5164,6 +5475,8 @@
    exports.$parseEvent = $parseEvent;
    exports.$parseExpr = $parseExpr;
    exports.$unwatch = $unwatch;
+   exports.$unwatchAll = $unwatchAll;
+   exports.$unwatchAllByScope = $unwatchAllByScope;
    exports.$watch = $watch;
    exports.AbstractDialogService = AbstractDialogService;
    exports.AbstractHttpService = AbstractHttpService;

package/core/esm2022/public_api.mjs

@@ -8,7 +8,7 @@ export * from './enums/enums';
 export * from './utils/event-notifier';
 export { $parseExpr, $parseEvent, registerFnByExpr, setPipeProvider, getFnByExpr, getFnForBindExpr, getFnForEventExpr } from './utils/expression-parser';
 export { isDefined, isObject, toBoolean, isIE, isAndroid, isAndroidTablet, isIphone, isIpod, isIpad, isIos, isSafari, isLargeTabletLandscape, isLargeTabletPortrait, isMobile, getAndroidVersion, isKitkatDevice, encodeUrl, encodeUrlParams, initCaps, spaceSeparate, replaceAt, periodSeparate, prettifyLabel, deHyphenate, prettifyLabels, isInsecureContentRequest, stringStartsWith, getEvaluatedExprValue, isImageFile, isAudioFile, isVideoFile, isValidImageUrl, isValidWebURL, getResourceURL, triggerFn, hasOffsetStr, getFormattedDate, getDateObj, addEventListenerOnElement, getClonedObject, getFiles, generateGUId, validateAccessRoles, getValidJSON, xmlToJson, findValueOf, extractType, isNumberType, isEmptyObject, scrollToElement, isElementInViewport, isPageable, replace, isDateTimeType, getValidDateObject, getNativeDateObject, getBlob, isEqualWithFields, loadStyleSheet, loadStyleSheets, loadScript, loadScripts, _WM_APP_PROJECT, setSessionStorageItem, getSessionStorageItem, noop, convertToBlob, AppConstants, openLink, fetchContent, toPromise, retryIfFails, getAbortableDefer, createCSSRule, getUrlParams, getMomentLocaleObject, getRouteNameFromLink, isAppleProduct, defer, executePromiseChain, isDataSourceEqual, validateDataSourceCtx, processFilterExpBindNode, extendProto, removeExtraSlashes, getDisplayDateTimeFormat, addForIdAttributes, adjustContainerPosition, adjustContainerRightEdges, setTranslation3dPosition, getWebkitTraslationMatrix, closePopover, detectChanges, triggerItemAction, getDatasourceFromExpr, extractCurrentItemExpr, findRootContainer, VALIDATOR, transformFileURI, appendScriptToHead, getAppSetting, setListClass, findParent, getNavClass, getSheetPositionClass } from './utils/utils';
-export { FIRST_TIME_WATCH, isFirstTimeChange, debounce, muteWatchers, unMuteWatchers, $watch, $unwatch, setNgZone, setAppRef, isChangeFromWatch, resetChangeFromWatch, $invokeWatchers, $appDigest } from './utils/watcher';
+export { FIRST_TIME_WATCH, isFirstTimeChange, debounce, muteWatchers, unMuteWatchers, $watch, $unwatch, $unwatchAll, $unwatchAllByScope, setNgZone, setAppRef, isChangeFromWatch, resetChangeFromWatch, $invokeWatchers, $appDigest } from './utils/watcher';
 export * from './utils/id-generator';
 export * from './types/types';
 export { Viewport } from './services/viewport.service';
@@ -23,4 +23,4 @@ export { StatePersistence } from './services/state-persistence.service';
 export { PaginationService } from './services/pagination.service';
 export * from './utils/wm-project-properties';
 export * from './utils/lru-cache';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_api.js","sourceRoot":"","sources":["../../../projects/core/src/public_api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of core\n */\nexport * from './utils/build-utils';\nexport * from './constants/currency-constants';\nexport {\n    appendNode,\n    insertBefore,\n    insertAfter,\n    removeNode,\n    removeClass,\n    addClass,\n    switchClass,\n    toggleClass,\n    setCSS,\n    setCSSFromObj,\n    setProperty,\n    setAttr,\n    setHtml,\n    removeAttr,\n    createElement,\n    toDimension\n} from './utils/dom';\nexport * from './enums/enums';\nexport * from './utils/event-notifier';\nexport {\n    ParseExprResult,\n    $parseExpr,\n    $parseEvent,\n    registerFnByExpr,\n    setPipeProvider,\n    getFnByExpr,\n    getFnForBindExpr,\n    getFnForEventExpr\n} from './utils/expression-parser';\nexport {\n    EVENT_LIFE,\n    isDefined,\n    isObject,\n    toBoolean,\n    isIE,\n    isAndroid,\n    isAndroidTablet,\n    isIphone,\n    isIpod,\n    isIpad,\n    isIos,\n    isSafari,\n    isLargeTabletLandscape,\n    isLargeTabletPortrait,\n    isMobile,\n    getAndroidVersion,\n    isKitkatDevice,\n    encodeUrl,\n    encodeUrlParams,\n    initCaps,\n    spaceSeparate,\n    replaceAt,\n    periodSeparate,\n    prettifyLabel,\n    deHyphenate,\n    prettifyLabels,\n    isInsecureContentRequest,\n    stringStartsWith,\n    getEvaluatedExprValue,\n    isImageFile,\n    isAudioFile,\n    isVideoFile,\n    isValidImageUrl,\n    isValidWebURL,\n    getResourceURL,\n    triggerFn,\n    hasOffsetStr,\n    getFormattedDate,\n    getDateObj,\n    addEventListenerOnElement,\n    getClonedObject,\n    getFiles,\n    generateGUId,\n    validateAccessRoles,\n    getValidJSON,\n    xmlToJson,\n    findValueOf,\n    extractType,\n    isNumberType,\n    isEmptyObject,\n    scrollToElement,\n    isElementInViewport,\n    isPageable,\n    replace,\n    isDateTimeType,\n    getValidDateObject,\n    getNativeDateObject,\n    getBlob,\n    isEqualWithFields,\n    loadStyleSheet,\n    loadStyleSheets,\n    loadScript,\n    loadScripts,\n    _WM_APP_PROJECT,\n    setSessionStorageItem,\n    getSessionStorageItem,\n    noop,\n    convertToBlob,\n    AppConstants,\n    openLink,\n    fetchContent,\n    toPromise,\n    retryIfFails,\n    getAbortableDefer,\n    createCSSRule,\n    getUrlParams,\n    getMomentLocaleObject,\n    getRouteNameFromLink,\n    isAppleProduct,\n    defer,\n    executePromiseChain,\n    isDataSourceEqual,\n    validateDataSourceCtx,\n    processFilterExpBindNode,\n    extendProto,\n    removeExtraSlashes,\n    getDisplayDateTimeFormat,\n    addForIdAttributes,\n    adjustContainerPosition,\n    adjustContainerRightEdges,\n    setTranslation3dPosition,\n    getWebkitTraslationMatrix,\n    closePopover,\n    detectChanges,\n    triggerItemAction,\n    getDatasourceFromExpr,\n    extractCurrentItemExpr,\n    findRootContainer,\n    VALIDATOR,\n    transformFileURI,\n    appendScriptToHead,\n    getAppSetting,\n    setListClass,\n    findParent,\n    getNavClass,\n    getSheetPositionClass\n} from './utils/utils';\nexport {\n    FIRST_TIME_WATCH,\n    isFirstTimeChange,\n    debounce,\n    muteWatchers,\n    unMuteWatchers,\n    $watch,\n    $unwatch,\n    setNgZone,\n    setAppRef,\n    isChangeFromWatch,\n    resetChangeFromWatch,\n    $invokeWatchers,\n    $appDigest\n} from './utils/watcher';\nexport * from './utils/id-generator';\nexport * from './types/types';\nexport { Viewport, ViewportEvent } from './services/viewport.service';\nexport * from './services/constant.service';\nexport * from './services/utils.service';\nexport * from './services/field-type.service';\nexport * from './services/field-widget.service';\nexport * from './services/script-loader.service';\nexport * from './services/user-custom-pipe-manager.service';\nexport * from './services/custom-icons-loader.service';\nexport { StatePersistence } from './services/state-persistence.service';\nexport { PaginationService } from './services/pagination.service';\nexport * from './utils/wm-project-properties';\nexport * from './utils/lru-cache';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"public_api.js","sourceRoot":"","sources":["../../../projects/core/src/public_api.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Public API Surface of core\n */\nexport * from './utils/build-utils';\nexport * from './constants/currency-constants';\nexport {\n    appendNode,\n    insertBefore,\n    insertAfter,\n    removeNode,\n    removeClass,\n    addClass,\n    switchClass,\n    toggleClass,\n    setCSS,\n    setCSSFromObj,\n    setProperty,\n    setAttr,\n    setHtml,\n    removeAttr,\n    createElement,\n    toDimension\n} from './utils/dom';\nexport * from './enums/enums';\nexport * from './utils/event-notifier';\nexport {\n    ParseExprResult,\n    $parseExpr,\n    $parseEvent,\n    registerFnByExpr,\n    setPipeProvider,\n    getFnByExpr,\n    getFnForBindExpr,\n    getFnForEventExpr\n} from './utils/expression-parser';\nexport {\n    EVENT_LIFE,\n    isDefined,\n    isObject,\n    toBoolean,\n    isIE,\n    isAndroid,\n    isAndroidTablet,\n    isIphone,\n    isIpod,\n    isIpad,\n    isIos,\n    isSafari,\n    isLargeTabletLandscape,\n    isLargeTabletPortrait,\n    isMobile,\n    getAndroidVersion,\n    isKitkatDevice,\n    encodeUrl,\n    encodeUrlParams,\n    initCaps,\n    spaceSeparate,\n    replaceAt,\n    periodSeparate,\n    prettifyLabel,\n    deHyphenate,\n    prettifyLabels,\n    isInsecureContentRequest,\n    stringStartsWith,\n    getEvaluatedExprValue,\n    isImageFile,\n    isAudioFile,\n    isVideoFile,\n    isValidImageUrl,\n    isValidWebURL,\n    getResourceURL,\n    triggerFn,\n    hasOffsetStr,\n    getFormattedDate,\n    getDateObj,\n    addEventListenerOnElement,\n    getClonedObject,\n    getFiles,\n    generateGUId,\n    validateAccessRoles,\n    getValidJSON,\n    xmlToJson,\n    findValueOf,\n    extractType,\n    isNumberType,\n    isEmptyObject,\n    scrollToElement,\n    isElementInViewport,\n    isPageable,\n    replace,\n    isDateTimeType,\n    getValidDateObject,\n    getNativeDateObject,\n    getBlob,\n    isEqualWithFields,\n    loadStyleSheet,\n    loadStyleSheets,\n    loadScript,\n    loadScripts,\n    _WM_APP_PROJECT,\n    setSessionStorageItem,\n    getSessionStorageItem,\n    noop,\n    convertToBlob,\n    AppConstants,\n    openLink,\n    fetchContent,\n    toPromise,\n    retryIfFails,\n    getAbortableDefer,\n    createCSSRule,\n    getUrlParams,\n    getMomentLocaleObject,\n    getRouteNameFromLink,\n    isAppleProduct,\n    defer,\n    executePromiseChain,\n    isDataSourceEqual,\n    validateDataSourceCtx,\n    processFilterExpBindNode,\n    extendProto,\n    removeExtraSlashes,\n    getDisplayDateTimeFormat,\n    addForIdAttributes,\n    adjustContainerPosition,\n    adjustContainerRightEdges,\n    setTranslation3dPosition,\n    getWebkitTraslationMatrix,\n    closePopover,\n    detectChanges,\n    triggerItemAction,\n    getDatasourceFromExpr,\n    extractCurrentItemExpr,\n    findRootContainer,\n    VALIDATOR,\n    transformFileURI,\n    appendScriptToHead,\n    getAppSetting,\n    setListClass,\n    findParent,\n    getNavClass,\n    getSheetPositionClass\n} from './utils/utils';\nexport {\n    FIRST_TIME_WATCH,\n    isFirstTimeChange,\n    debounce,\n    muteWatchers,\n    unMuteWatchers,\n    $watch,\n    $unwatch,\n    $unwatchAll,\n    $unwatchAllByScope,\n    setNgZone,\n    setAppRef,\n    isChangeFromWatch,\n    resetChangeFromWatch,\n    $invokeWatchers,\n    $appDigest\n} from './utils/watcher';\nexport * from './utils/id-generator';\nexport * from './types/types';\nexport { Viewport, ViewportEvent } from './services/viewport.service';\nexport * from './services/constant.service';\nexport * from './services/utils.service';\nexport * from './services/field-type.service';\nexport * from './services/field-widget.service';\nexport * from './services/script-loader.service';\nexport * from './services/user-custom-pipe-manager.service';\nexport * from './services/custom-icons-loader.service';\nexport { StatePersistence } from './services/state-persistence.service';\nexport { PaginationService } from './services/pagination.service';\nexport * from './utils/wm-project-properties';\nexport * from './utils/lru-cache';\n"]}