@magicpixel/rn-mp-client-sdk 1.13.0 → 1.13.20

package/src/processors/visit-id.processor.ts

@@ -7,12 +7,35 @@ import type { VisitInfo, VisitorInfo } from '../common/app-types';
 import { Utils } from '../common/utils';
 
 export class VisitIdProcessor {
+  // Track if visitor ID fetch failed so we can retry on page_load
+  private static visitorIdFetchFailed = false;
+
   static async init(orgId: string): Promise<void> {
     await this.initDebugId(orgId);
     await this.setOrResetVisitorId();
     await this.setOrResetVisitInfo(false);
   }
 
+  /**
+   * Check if visitor ID needs to be retried
+   * Called on each page_load to retry if initial fetch failed
+   */
+  static async retryVisitorIdIfNeeded(): Promise<void> {
+    if (!this.visitorIdFetchFailed) {
+      return; // No retry needed
+    }
+
+    Logger.logDbg('Retrying visitor ID fetch on page_load...');
+    await this.setOrResetVisitorId();
+  }
+
+  /**
+   * Check if visitor ID is available
+   */
+  static hasVisitorId(): boolean {
+    return !this.visitorIdFetchFailed && DataStore.getVisitorInfo() !== null;
+  }
+
   static async isFirstOpenAfterInstall(): Promise<boolean> {
     try {
       const firstOpenFlag = await DataStore.getDataFromStorage<string>(
@@ -78,6 +101,7 @@ export class VisitIdProcessor {
 
       if (!visitInfo) {
         // may be first time visit, set up a new visit info object and return
+        // Initialize visitDepth to 0, will be incremented to 1 on first page_load
         visitInfo = {
           visitId: Utils.getUniqueID(),
           visitCt: 1,
@@ -92,7 +116,7 @@ export class VisitIdProcessor {
           visitInfo.visitDepth = (visitInfo?.visitDepth ?? 0) + 1;
         } else {
           visitInfo.visitCt = visitInfo.visitCt + 1;
-          visitInfo.visitDepth = 0;
+          visitInfo.visitDepth = 0; // Reset to 0, will be incremented to 1 on first page_load of new session
         }
         visitInfo.visitTs = Date.now();
         visitInfo.visitVer = 1;
@@ -108,45 +132,91 @@ export class VisitIdProcessor {
     }
   }
 
-  static async incrementVisitDepth(): Promise<void> {
-    return this.setOrResetVisitInfo(true);
+  /**
+   * Synchronously increment visit depth in memory, persist to storage in background
+   * This prevents race conditions when multiple page_load events fire quickly
+   */
+  static incrementVisitDepth(): void {
+    try {
+      // Read from in-memory cache (synchronous)
+      const visitInfo: VisitInfo = DataStore.getVisitInfo();
+
+      if (!visitInfo) {
+        Logger.logError('Visit info not initialized. Cannot increment depth.');
+        return;
+      }
+
+      // Increment depth synchronously in memory
+      visitInfo.visitDepth = (visitInfo.visitDepth ?? 0) + 1;
+      visitInfo.visitTs = Date.now();
+
+      // Update in-memory cache immediately (synchronous)
+      DataStore.setVisitInfo(visitInfo);
+      DataStore.addCommonCookie('x-mp-vid', DataStore.visitInfoToString());
+
+      Logger.logDbg('Visit depth incremented to:', visitInfo.visitDepth);
+
+      // Persist to AsyncStorage in background (fire and forget)
+      DataStore.storeData(Constants.KEY_MP_IDL_VISIT_ID_INFO, visitInfo).catch(
+        (err) => {
+          Logger.logError('Error persisting visit depth to storage:', err);
+          Reporter.reportError('incrementVisitDepth::persist', err);
+        }
+      );
+    } catch (err) {
+      Logger.logError('Error incrementing visit depth:', err);
+      Reporter.reportError('incrementVisitDepth', err);
+    }
   }
 
   static async setOrResetVisitorId(): Promise<void> {
     try {
-      let visitorInfoData: VisitorInfo = await DataStore.getDataFromStorage(
-        Constants.KEY_MP_IDL_VISITOR_ID_INFO
-      );
+      let visitorInfoData: VisitorInfo | null =
+        await DataStore.getDataFromStorage(
+          Constants.KEY_MP_IDL_VISITOR_ID_INFO
+        );
 
       if (
         !visitorInfoData ||
         (visitorInfoData && visitorInfoData?.mId.indexOf('-') === -1)
       ) {
-        Logger.logDbg('VisitorInfo not found. Refreshing from server');
+        Logger.logDbg('VisitorInfo not found. Fetching from server with retry');
         // get a new visit id and device id from server and store it in storage
-        visitorInfoData = await NetworkService.fetchIdlInfo(
+        // Use retry method for better reliability
+        visitorInfoData = await NetworkService.fetchIdlInfoWithRetry(
           DataStore.getIdlUrl()
         );
       }
 
       if (!visitorInfoData) {
-        return;
-      } else {
-        DataStore.setVisitorInfo(visitorInfoData);
-        // store to db as well
-        await DataStore.storeData(
-          Constants.KEY_MP_IDL_VISITOR_ID_INFO,
-          visitorInfoData
+        // Mark as failed so we can retry on page_load
+        this.visitorIdFetchFailed = true;
+        Logger.logError(
+          'Failed to fetch visitor ID after retries. Will retry on next page_load.'
         );
-
-        const cookieValue = encodeURIComponent(JSON.stringify(visitorInfoData));
-        DataStore.addCommonCookie('x-mplidl', cookieValue);
-        DataStore.addCommonCookie('x-mpidl', cookieValue);
-        DataStore.addCommonCookie('x-lmid', visitorInfoData.mId);
-        DataStore.addCommonCookie('x-ldid', visitorInfoData.dId);
+        return;
       }
+
+      // Success - clear the failure flag
+      this.visitorIdFetchFailed = false;
+
+      DataStore.setVisitorInfo(visitorInfoData);
+      // store to db as well
+      await DataStore.storeData(
+        Constants.KEY_MP_IDL_VISITOR_ID_INFO,
+        visitorInfoData
+      );
+
+      const cookieValue = encodeURIComponent(JSON.stringify(visitorInfoData));
+      DataStore.addCommonCookie('x-mplidl', cookieValue);
+      DataStore.addCommonCookie('x-mpidl', cookieValue);
+      DataStore.addCommonCookie('x-lmid', visitorInfoData.mId);
+      DataStore.addCommonCookie('x-ldid', visitorInfoData.dId);
+
+      Logger.logDbg('Visitor ID set successfully:', visitorInfoData.mId);
     } catch (err) {
-      Logger.logError(err);
+      Logger.logError('Error in setOrResetVisitorId:', err);
+      this.visitorIdFetchFailed = true;
       DataStore.setVisitorInfo(null);
       Reporter.reportError('setOrResetVisitorId', err);
     }

package/lib/commonjs/processors/trans-function.processor.js

@@ -1,73 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TransFunctionProcessor = void 0;
-var _dataStore = require("../common/data-store");
-var _logger = require("../common/logger");
-var _utils = require("../common/utils");
-var _reporter = require("../common/reporter");
-/**
- * Process all the data elements at once, or if a set of keys are specified, processes only
- * those keys and updates the dataElements object in global-fns file
- * @param dataElements
- * @param sdkTransFunctions
- * @param optTfnKeys
- */
-
-class TransFunctionProcessor {
-  static processTransformationFunctions(dataElements, sdkTransFunctions, optTfnKeys) {
-    const tfn = _dataStore.DataStore.getTransFunctions();
-    const tfnKeys = optTfnKeys && optTfnKeys.length > 0 ? optTfnKeys : Object.keys(sdkTransFunctions);
-    try {
-      for (const key of tfnKeys) {
-        try {
-          const tfnItem = sdkTransFunctions[key];
-          /**
-           * How to process transformation functions
-           * 1) Find all the data elements in the resource params of trans function
-           * 2) make them into an object (key value) where key is the resourceKey and value is the value of data elements
-           * 3) Invoke the tfn and get the value and store it against the tfn key
-           */
-
-          if (tfnItem) {
-            if (tfnItem.rParams) {
-              const tfnFnInput = {};
-              for (const paramKey of Object.keys(tfnItem.rParams)) {
-                // tfn can have only data elements as of now.
-                const rParam = tfnItem.rParams[paramKey];
-                const deId = rParam === null || rParam === void 0 ? void 0 : rParam.de;
-                if (deId) {
-                  let paramValue = dataElements[deId] || '';
-                  if (rParam.rqd && !paramValue) {
-                    _logger.Logger.logDbg(`Value required for: ${paramKey}, in transformation function. But not found`);
-                    break;
-                  }
-                  if (rParam.tf) {
-                    paramValue = _utils.Utils.applyTransformationResourceParam(paramValue, rParam.tf);
-                  }
-                  tfnFnInput[paramKey] = paramValue;
-                }
-              }
-              // invoke the function and get the value
-              tfn[key] = tfnItem.fn(tfnFnInput);
-            }
-          } else {
-            tfn[key] = '';
-          }
-        } catch (err) {
-          _logger.Logger.logError('Error processing transformation function: ', key, ' with error: ', err);
-          // TODO: Report as metric to client
-        }
-      }
-    } catch (err) {
-      _logger.Logger.logError('Error processing transformation functions: ', err);
-      _reporter.Reporter.reportError('m::processTransformationFunctions', err);
-    }
-    _dataStore.DataStore.setTransFunctions(tfn);
-    return tfn;
-  }
-}
-exports.TransFunctionProcessor = TransFunctionProcessor;
-//# sourceMappingURL=trans-function.processor.js.map

package/lib/commonjs/processors/trans-function.processor.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_dataStore","require","_logger","_utils","_reporter","TransFunctionProcessor","processTransformationFunctions","dataElements","sdkTransFunctions","optTfnKeys","tfn","DataStore","getTransFunctions","tfnKeys","length","Object","keys","key","tfnItem","rParams","tfnFnInput","paramKey","rParam","deId","de","paramValue","rqd","Logger","logDbg","tf","Utils","applyTransformationResourceParam","fn","err","logError","Reporter","reportError","setTransFunctions","exports"],"sources":["trans-function.processor.ts"],"sourcesContent":["/**\n * Process all the data elements at once, or if a set of keys are specified, processes only\n * those keys and updates the dataElements object in global-fns file\n * @param dataElements\n * @param sdkTransFunctions\n * @param optTfnKeys\n */\nimport type { MapLike } from '../common/app-types';\nimport type { ClientSdkTfnItem } from '../models/mp-client-sdk';\nimport { DataStore } from '../common/data-store';\nimport { Logger } from '../common/logger';\nimport { Utils } from '../common/utils';\nimport { Reporter } from '../common/reporter';\n\nexport class TransFunctionProcessor {\n  static processTransformationFunctions(\n    dataElements: MapLike<any>,\n    sdkTransFunctions: MapLike<ClientSdkTfnItem>,\n    optTfnKeys?: string[]\n  ): MapLike<any> {\n    const tfn = DataStore.getTransFunctions();\n    const tfnKeys =\n      optTfnKeys && optTfnKeys.length > 0\n        ? optTfnKeys\n        : Object.keys(sdkTransFunctions);\n    try {\n      for (const key of tfnKeys) {\n        try {\n          const tfnItem = sdkTransFunctions[key];\n          /**\n           * How to process transformation functions\n           * 1) Find all the data elements in the resource params of trans function\n           * 2) make them into an object (key value) where key is the resourceKey and value is the value of data elements\n           * 3) Invoke the tfn and get the value and store it against the tfn key\n           */\n\n          if (tfnItem) {\n            if (tfnItem.rParams) {\n              const tfnFnInput: any = {};\n              for (const paramKey of Object.keys(tfnItem.rParams)) {\n                // tfn can have only data elements as of now.\n                const rParam = tfnItem.rParams[paramKey];\n                const deId = rParam?.de;\n                if (deId) {\n                  let paramValue = dataElements[deId] || '';\n                  if (rParam.rqd && !paramValue) {\n                    Logger.logDbg(\n                      `Value required for: ${paramKey}, in transformation function. But not found`\n                    );\n                    break;\n                  }\n                  if (rParam.tf) {\n                    paramValue = Utils.applyTransformationResourceParam(\n                      paramValue,\n                      rParam.tf\n                    );\n                  }\n                  tfnFnInput[paramKey] = paramValue;\n                }\n              }\n              // invoke the function and get the value\n              tfn[key] = tfnItem.fn(tfnFnInput);\n            }\n          } else {\n            tfn[key] = '';\n          }\n        } catch (err) {\n          Logger.logError(\n            'Error processing transformation function: ',\n            key,\n            ' with error: ',\n            err\n          );\n          // TODO: Report as metric to client\n        }\n      }\n    } catch (err) {\n      Logger.logError('Error processing transformation functions: ', err);\n      Reporter.reportError('m::processTransformationFunctions', err);\n    }\n\n    DataStore.setTransFunctions(tfn);\n    return tfn;\n  }\n}\n"],"mappings":";;;;;;AASA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA;AAZA;AACA;AACA;AACA;AACA;AACA;AACA;;AAQO,MAAMI,sBAAsB,CAAC;EAClC,OAAOC,8BAA8BA,CACnCC,YAA0B,EAC1BC,iBAA4C,EAC5CC,UAAqB,EACP;IACd,MAAMC,GAAG,GAAGC,oBAAS,CAACC,iBAAiB,CAAC,CAAC;IACzC,MAAMC,OAAO,GACXJ,UAAU,IAAIA,UAAU,CAACK,MAAM,GAAG,CAAC,GAC/BL,UAAU,GACVM,MAAM,CAACC,IAAI,CAACR,iBAAiB,CAAC;IACpC,IAAI;MACF,KAAK,MAAMS,GAAG,IAAIJ,OAAO,EAAE;QACzB,IAAI;UACF,MAAMK,OAAO,GAAGV,iBAAiB,CAACS,GAAG,CAAC;UACtC;AACV;AACA;AACA;AACA;AACA;;UAEU,IAAIC,OAAO,EAAE;YACX,IAAIA,OAAO,CAACC,OAAO,EAAE;cACnB,MAAMC,UAAe,GAAG,CAAC,CAAC;cAC1B,KAAK,MAAMC,QAAQ,IAAIN,MAAM,CAACC,IAAI,CAACE,OAAO,CAACC,OAAO,CAAC,EAAE;gBACnD;gBACA,MAAMG,MAAM,GAAGJ,OAAO,CAACC,OAAO,CAACE,QAAQ,CAAC;gBACxC,MAAME,IAAI,GAAGD,MAAM,aAANA,MAAM,uBAANA,MAAM,CAAEE,EAAE;gBACvB,IAAID,IAAI,EAAE;kBACR,IAAIE,UAAU,GAAGlB,YAAY,CAACgB,IAAI,CAAC,IAAI,EAAE;kBACzC,IAAID,MAAM,CAACI,GAAG,IAAI,CAACD,UAAU,EAAE;oBAC7BE,cAAM,CAACC,MAAM,CACX,uBAAuBP,QAAQ,6CACjC,CAAC;oBACD;kBACF;kBACA,IAAIC,MAAM,CAACO,EAAE,EAAE;oBACbJ,UAAU,GAAGK,YAAK,CAACC,gCAAgC,CACjDN,UAAU,EACVH,MAAM,CAACO,EACT,CAAC;kBACH;kBACAT,UAAU,CAACC,QAAQ,CAAC,GAAGI,UAAU;gBACnC;cACF;cACA;cACAf,GAAG,CAACO,GAAG,CAAC,GAAGC,OAAO,CAACc,EAAE,CAACZ,UAAU,CAAC;YACnC;UACF,CAAC,MAAM;YACLV,GAAG,CAACO,GAAG,CAAC,GAAG,EAAE;UACf;QACF,CAAC,CAAC,OAAOgB,GAAG,EAAE;UACZN,cAAM,CAACO,QAAQ,CACb,4CAA4C,EAC5CjB,GAAG,EACH,eAAe,EACfgB,GACF,CAAC;UACD;QACF;MACF;IACF,CAAC,CAAC,OAAOA,GAAG,EAAE;MACZN,cAAM,CAACO,QAAQ,CAAC,6CAA6C,EAAED,GAAG,CAAC;MACnEE,kBAAQ,CAACC,WAAW,CAAC,mCAAmC,EAAEH,GAAG,CAAC;IAChE;IAEAtB,oBAAS,CAAC0B,iBAAiB,CAAC3B,GAAG,CAAC;IAChC,OAAOA,GAAG;EACZ;AACF;AAAC4B,OAAA,CAAAjC,sBAAA,GAAAA,sBAAA","ignoreList":[]}

package/lib/module/processors/trans-function.processor.js

@@ -1,66 +0,0 @@
-/**
- * Process all the data elements at once, or if a set of keys are specified, processes only
- * those keys and updates the dataElements object in global-fns file
- * @param dataElements
- * @param sdkTransFunctions
- * @param optTfnKeys
- */
-
-import { DataStore } from '../common/data-store';
-import { Logger } from '../common/logger';
-import { Utils } from '../common/utils';
-import { Reporter } from '../common/reporter';
-export class TransFunctionProcessor {
-  static processTransformationFunctions(dataElements, sdkTransFunctions, optTfnKeys) {
-    const tfn = DataStore.getTransFunctions();
-    const tfnKeys = optTfnKeys && optTfnKeys.length > 0 ? optTfnKeys : Object.keys(sdkTransFunctions);
-    try {
-      for (const key of tfnKeys) {
-        try {
-          const tfnItem = sdkTransFunctions[key];
-          /**
-           * How to process transformation functions
-           * 1) Find all the data elements in the resource params of trans function
-           * 2) make them into an object (key value) where key is the resourceKey and value is the value of data elements
-           * 3) Invoke the tfn and get the value and store it against the tfn key
-           */
-
-          if (tfnItem) {
-            if (tfnItem.rParams) {
-              const tfnFnInput = {};
-              for (const paramKey of Object.keys(tfnItem.rParams)) {
-                // tfn can have only data elements as of now.
-                const rParam = tfnItem.rParams[paramKey];
-                const deId = rParam === null || rParam === void 0 ? void 0 : rParam.de;
-                if (deId) {
-                  let paramValue = dataElements[deId] || '';
-                  if (rParam.rqd && !paramValue) {
-                    Logger.logDbg(`Value required for: ${paramKey}, in transformation function. But not found`);
-                    break;
-                  }
-                  if (rParam.tf) {
-                    paramValue = Utils.applyTransformationResourceParam(paramValue, rParam.tf);
-                  }
-                  tfnFnInput[paramKey] = paramValue;
-                }
-              }
-              // invoke the function and get the value
-              tfn[key] = tfnItem.fn(tfnFnInput);
-            }
-          } else {
-            tfn[key] = '';
-          }
-        } catch (err) {
-          Logger.logError('Error processing transformation function: ', key, ' with error: ', err);
-          // TODO: Report as metric to client
-        }
-      }
-    } catch (err) {
-      Logger.logError('Error processing transformation functions: ', err);
-      Reporter.reportError('m::processTransformationFunctions', err);
-    }
-    DataStore.setTransFunctions(tfn);
-    return tfn;
-  }
-}
-//# sourceMappingURL=trans-function.processor.js.map

package/lib/module/processors/trans-function.processor.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["DataStore","Logger","Utils","Reporter","TransFunctionProcessor","processTransformationFunctions","dataElements","sdkTransFunctions","optTfnKeys","tfn","getTransFunctions","tfnKeys","length","Object","keys","key","tfnItem","rParams","tfnFnInput","paramKey","rParam","deId","de","paramValue","rqd","logDbg","tf","applyTransformationResourceParam","fn","err","logError","reportError","setTransFunctions"],"sources":["trans-function.processor.ts"],"sourcesContent":["/**\n * Process all the data elements at once, or if a set of keys are specified, processes only\n * those keys and updates the dataElements object in global-fns file\n * @param dataElements\n * @param sdkTransFunctions\n * @param optTfnKeys\n */\nimport type { MapLike } from '../common/app-types';\nimport type { ClientSdkTfnItem } from '../models/mp-client-sdk';\nimport { DataStore } from '../common/data-store';\nimport { Logger } from '../common/logger';\nimport { Utils } from '../common/utils';\nimport { Reporter } from '../common/reporter';\n\nexport class TransFunctionProcessor {\n  static processTransformationFunctions(\n    dataElements: MapLike<any>,\n    sdkTransFunctions: MapLike<ClientSdkTfnItem>,\n    optTfnKeys?: string[]\n  ): MapLike<any> {\n    const tfn = DataStore.getTransFunctions();\n    const tfnKeys =\n      optTfnKeys && optTfnKeys.length > 0\n        ? optTfnKeys\n        : Object.keys(sdkTransFunctions);\n    try {\n      for (const key of tfnKeys) {\n        try {\n          const tfnItem = sdkTransFunctions[key];\n          /**\n           * How to process transformation functions\n           * 1) Find all the data elements in the resource params of trans function\n           * 2) make them into an object (key value) where key is the resourceKey and value is the value of data elements\n           * 3) Invoke the tfn and get the value and store it against the tfn key\n           */\n\n          if (tfnItem) {\n            if (tfnItem.rParams) {\n              const tfnFnInput: any = {};\n              for (const paramKey of Object.keys(tfnItem.rParams)) {\n                // tfn can have only data elements as of now.\n                const rParam = tfnItem.rParams[paramKey];\n                const deId = rParam?.de;\n                if (deId) {\n                  let paramValue = dataElements[deId] || '';\n                  if (rParam.rqd && !paramValue) {\n                    Logger.logDbg(\n                      `Value required for: ${paramKey}, in transformation function. But not found`\n                    );\n                    break;\n                  }\n                  if (rParam.tf) {\n                    paramValue = Utils.applyTransformationResourceParam(\n                      paramValue,\n                      rParam.tf\n                    );\n                  }\n                  tfnFnInput[paramKey] = paramValue;\n                }\n              }\n              // invoke the function and get the value\n              tfn[key] = tfnItem.fn(tfnFnInput);\n            }\n          } else {\n            tfn[key] = '';\n          }\n        } catch (err) {\n          Logger.logError(\n            'Error processing transformation function: ',\n            key,\n            ' with error: ',\n            err\n          );\n          // TODO: Report as metric to client\n        }\n      }\n    } catch (err) {\n      Logger.logError('Error processing transformation functions: ', err);\n      Reporter.reportError('m::processTransformationFunctions', err);\n    }\n\n    DataStore.setTransFunctions(tfn);\n    return tfn;\n  }\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,SAASA,SAAS,QAAQ,sBAAsB;AAChD,SAASC,MAAM,QAAQ,kBAAkB;AACzC,SAASC,KAAK,QAAQ,iBAAiB;AACvC,SAASC,QAAQ,QAAQ,oBAAoB;AAE7C,OAAO,MAAMC,sBAAsB,CAAC;EAClC,OAAOC,8BAA8BA,CACnCC,YAA0B,EAC1BC,iBAA4C,EAC5CC,UAAqB,EACP;IACd,MAAMC,GAAG,GAAGT,SAAS,CAACU,iBAAiB,CAAC,CAAC;IACzC,MAAMC,OAAO,GACXH,UAAU,IAAIA,UAAU,CAACI,MAAM,GAAG,CAAC,GAC/BJ,UAAU,GACVK,MAAM,CAACC,IAAI,CAACP,iBAAiB,CAAC;IACpC,IAAI;MACF,KAAK,MAAMQ,GAAG,IAAIJ,OAAO,EAAE;QACzB,IAAI;UACF,MAAMK,OAAO,GAAGT,iBAAiB,CAACQ,GAAG,CAAC;UACtC;AACV;AACA;AACA;AACA;AACA;;UAEU,IAAIC,OAAO,EAAE;YACX,IAAIA,OAAO,CAACC,OAAO,EAAE;cACnB,MAAMC,UAAe,GAAG,CAAC,CAAC;cAC1B,KAAK,MAAMC,QAAQ,IAAIN,MAAM,CAACC,IAAI,CAACE,OAAO,CAACC,OAAO,CAAC,EAAE;gBACnD;gBACA,MAAMG,MAAM,GAAGJ,OAAO,CAACC,OAAO,CAACE,QAAQ,CAAC;gBACxC,MAAME,IAAI,GAAGD,MAAM,aAANA,MAAM,uBAANA,MAAM,CAAEE,EAAE;gBACvB,IAAID,IAAI,EAAE;kBACR,IAAIE,UAAU,GAAGjB,YAAY,CAACe,IAAI,CAAC,IAAI,EAAE;kBACzC,IAAID,MAAM,CAACI,GAAG,IAAI,CAACD,UAAU,EAAE;oBAC7BtB,MAAM,CAACwB,MAAM,CACX,uBAAuBN,QAAQ,6CACjC,CAAC;oBACD;kBACF;kBACA,IAAIC,MAAM,CAACM,EAAE,EAAE;oBACbH,UAAU,GAAGrB,KAAK,CAACyB,gCAAgC,CACjDJ,UAAU,EACVH,MAAM,CAACM,EACT,CAAC;kBACH;kBACAR,UAAU,CAACC,QAAQ,CAAC,GAAGI,UAAU;gBACnC;cACF;cACA;cACAd,GAAG,CAACM,GAAG,CAAC,GAAGC,OAAO,CAACY,EAAE,CAACV,UAAU,CAAC;YACnC;UACF,CAAC,MAAM;YACLT,GAAG,CAACM,GAAG,CAAC,GAAG,EAAE;UACf;QACF,CAAC,CAAC,OAAOc,GAAG,EAAE;UACZ5B,MAAM,CAAC6B,QAAQ,CACb,4CAA4C,EAC5Cf,GAAG,EACH,eAAe,EACfc,GACF,CAAC;UACD;QACF;MACF;IACF,CAAC,CAAC,OAAOA,GAAG,EAAE;MACZ5B,MAAM,CAAC6B,QAAQ,CAAC,6CAA6C,EAAED,GAAG,CAAC;MACnE1B,QAAQ,CAAC4B,WAAW,CAAC,mCAAmC,EAAEF,GAAG,CAAC;IAChE;IAEA7B,SAAS,CAACgC,iBAAiB,CAACvB,GAAG,CAAC;IAChC,OAAOA,GAAG;EACZ;AACF","ignoreList":[]}

package/lib/typescript/common/event-bus.d.ts

@@ -1,6 +0,0 @@
-import type { EventBusCallback } from './app-types';
-export declare class EventBus {
-    private static eventRegister;
-    static on(eventName: string, callback: EventBusCallback): void;
-    static triggerEvent(eventName: string, payload: any): void;
-}

package/lib/typescript/common/network-service.d.ts

@@ -1,8 +0,0 @@
-import type { MapLike, SdkInitOptions, VisitorInfo } from './app-types';
-export declare class NetworkService {
-    static fetchIdlInfo(url: string): Promise<VisitorInfo>;
-    static refreshClientSdkJson(sdkInitOptions: SdkInitOptions): Promise<void>;
-    static sendPostRequest(url: string, body: MapLike): void;
-    static sendGetRequest(url: string): void;
-    private static sendNetworkRequest;
-}

package/lib/typescript/processors/trans-function.processor.d.ts

@@ -1,12 +0,0 @@
-/**
- * Process all the data elements at once, or if a set of keys are specified, processes only
- * those keys and updates the dataElements object in global-fns file
- * @param dataElements
- * @param sdkTransFunctions
- * @param optTfnKeys
- */
-import type { MapLike } from '../common/app-types';
-import type { ClientSdkTfnItem } from '../models/mp-client-sdk';
-export declare class TransFunctionProcessor {
-    static processTransformationFunctions(dataElements: MapLike<any>, sdkTransFunctions: MapLike<ClientSdkTfnItem>, optTfnKeys?: string[]): MapLike<any>;
-}

package/lib/typescript/processors/visit-id.processor.d.ts

@@ -1,9 +0,0 @@
-export declare class VisitIdProcessor {
-    static init(orgId: string): Promise<void>;
-    static isFirstOpenAfterInstall(): Promise<boolean>;
-    static getFacebookFBP(): Promise<string>;
-    static initDebugId(orgId: string): Promise<void>;
-    static setOrResetVisitInfo(incrementDepth: boolean): Promise<void>;
-    static incrementVisitDepth(): Promise<void>;
-    static setOrResetVisitorId(): Promise<void>;
-}

package/src/processors/trans-function.processor.ts

@@ -1,85 +0,0 @@
-/**
- * Process all the data elements at once, or if a set of keys are specified, processes only
- * those keys and updates the dataElements object in global-fns file
- * @param dataElements
- * @param sdkTransFunctions
- * @param optTfnKeys
- */
-import type { MapLike } from '../common/app-types';
-import type { ClientSdkTfnItem } from '../models/mp-client-sdk';
-import { DataStore } from '../common/data-store';
-import { Logger } from '../common/logger';
-import { Utils } from '../common/utils';
-import { Reporter } from '../common/reporter';
-
-export class TransFunctionProcessor {
-  static processTransformationFunctions(
-    dataElements: MapLike<any>,
-    sdkTransFunctions: MapLike<ClientSdkTfnItem>,
-    optTfnKeys?: string[]
-  ): MapLike<any> {
-    const tfn = DataStore.getTransFunctions();
-    const tfnKeys =
-      optTfnKeys && optTfnKeys.length > 0
-        ? optTfnKeys
-        : Object.keys(sdkTransFunctions);
-    try {
-      for (const key of tfnKeys) {
-        try {
-          const tfnItem = sdkTransFunctions[key];
-          /**
-           * How to process transformation functions
-           * 1) Find all the data elements in the resource params of trans function
-           * 2) make them into an object (key value) where key is the resourceKey and value is the value of data elements
-           * 3) Invoke the tfn and get the value and store it against the tfn key
-           */
-
-          if (tfnItem) {
-            if (tfnItem.rParams) {
-              const tfnFnInput: any = {};
-              for (const paramKey of Object.keys(tfnItem.rParams)) {
-                // tfn can have only data elements as of now.
-                const rParam = tfnItem.rParams[paramKey];
-                const deId = rParam?.de;
-                if (deId) {
-                  let paramValue = dataElements[deId] || '';
-                  if (rParam.rqd && !paramValue) {
-                    Logger.logDbg(
-                      `Value required for: ${paramKey}, in transformation function. But not found`
-                    );
-                    break;
-                  }
-                  if (rParam.tf) {
-                    paramValue = Utils.applyTransformationResourceParam(
-                      paramValue,
-                      rParam.tf
-                    );
-                  }
-                  tfnFnInput[paramKey] = paramValue;
-                }
-              }
-              // invoke the function and get the value
-              tfn[key] = tfnItem.fn(tfnFnInput);
-            }
-          } else {
-            tfn[key] = '';
-          }
-        } catch (err) {
-          Logger.logError(
-            'Error processing transformation function: ',
-            key,
-            ' with error: ',
-            err
-          );
-          // TODO: Report as metric to client
-        }
-      }
-    } catch (err) {
-      Logger.logError('Error processing transformation functions: ', err);
-      Reporter.reportError('m::processTransformationFunctions', err);
-    }
-
-    DataStore.setTransFunctions(tfn);
-    return tfn;
-  }
-}