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

package/lib/commonjs/index.js

@@ -3,7 +3,20 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "DeepLinkHelper", {
+  enumerable: true,
+  get: function () {
+    return _deeplinkHelper.DeepLinkHelper;
+  }
+});
+Object.defineProperty(exports, "DeepLinkType", {
+  enumerable: true,
+  get: function () {
+    return _deeplinkHelper.DeepLinkType;
+  }
+});
 exports.MagicPixelEventBus = exports.MagicPixel = void 0;
+require("react-native-get-random-values");
 var _eedl = require("./eedl/eedl");
 var _dataStore = require("./common/data-store");
 var _logger = require("./common/logger");
@@ -16,22 +29,124 @@ var _networkService = require("./common/network-service");
 var _eventBus = require("./common/event-bus");
 var _visitId = require("./processors/visit-id.processor");
 var _geoLocation = require("./processors/geo-location.processor");
+var _deviceInfoHelper = require("./common/device-info-helper");
+var _deeplinkHelper = require("./common/deeplink-helper");
+var _storageHelper = require("./common/storage-helper");
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // Polyfill for crypto.getRandomValues() required by ULID
 const DL_INIT_EVENT = 'page_load';
+
+// Maximum number of events to buffer before SDK is ready
+const MAX_BUFFERED_EVENTS = 500;
+
+// Type for buffered events
+
 class MagicPixelImpl {
-  static async init(options) {
-    var _options$device_type;
+  /**
+   * Initialize the MagicPixel SDK
+   * This method is synchronous - it stores config immediately and runs async setup in background
+   * Events called before async setup completes are buffered and processed once ready
+   * @param options SDK initialization options
+   */
+  static init(options) {
+    // Guard against multiple init() calls
+    if (this.isReady) {
+      _logger.Logger.logDbg('MagicPixel SDK already initialized. Ignoring duplicate init() call.');
+      return;
+    }
+    if (this.isInitializing) {
+      _logger.Logger.logDbg('MagicPixel SDK initialization in progress. Ignoring duplicate init() call.');
+      return;
+    }
+    this.isInitializing = true;
+
+    // Sync setup - happens immediately
     _logger.Logger.setLogLevel(options.logLevel ?? 'none');
+    this.orgId = options.orgId;
+    this.onInitFailureCallback = options.onInitFailure;
+    _logger.Logger.logDbg('MagicPixel SDK init started');
+
+    // Async setup - runs in background, events are buffered until complete
+    this.initAsync(options).catch(err => {
+      _logger.Logger.logError('MagicPixel SDK initialization failed:', err);
+      _reporter.Reporter.reportError('sdk_init', err);
+
+      // Reset initializing flag so developer can retry if needed
+      this.isInitializing = false;
+
+      // Call failure callback if provided
+      if (this.onInitFailureCallback) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.onInitFailureCallback(error);
+      }
+    });
+  }
+
+  /**
+   * Shutdown the SDK and release all resources
+   * Call this when the app is closing or when you need to reinitialize the SDK
+   * After shutdown, you must call init() again to use the SDK
+   */
+  static shutdown() {
+    _logger.Logger.logDbg('MagicPixel SDK shutting down...');
+
+    // Clean up deeplink listener and callback
+    _deeplinkHelper.DeepLinkHelper.cleanup();
+
+    // Clear all EventBus listeners to prevent duplicates on reinit
+    _eventBus.EventBus.clearAll();
+
+    // Clear session-scoped data element values (in-memory store)
+    _storageHelper.StorageHelper.clearSessionStore();
+
+    // Clear event buffer
+    this.eventBuffer = [];
+
+    // Reset state flags
+    this.isReady = false;
+    this.isInitializing = false;
+    this.onInitFailureCallback = undefined;
+
+    // Reset customer data
+    this.customerInfo = undefined;
+    this.customerIdentifiers = {};
+    this.deepLinkUrl = undefined;
+    this.firstAppLaunch = true;
+
+    // Shutdown EEDL
+    this.dl.shutdown();
+    _logger.Logger.logDbg('MagicPixel SDK shutdown complete');
+  }
+
+  /**
+   * Async initialization - runs in background
+   */
+  static async initAsync(options) {
     await _networkService.NetworkService.refreshClientSdkJson(options);
     if (!_dataStore.DataStore.isDataStoreReady()) {
-      throw new Error('MagicPixel SDK is not ready. No tags will be processed');
+      throw new Error('MagicPixel SDK: DataStore not ready after config fetch. Initialization failed.');
     }
-    if (options && options.device_type && ((_options$device_type = options.device_type) === null || _options$device_type === void 0 ? void 0 : _options$device_type.trim().length) > 0) {
-      _dataStore.DataStore.overrideDeviceType(options.device_type);
-    }
-    this.setAppVersion(options.app_version);
+
+    // Initialize StorageHelper for data element storage duration
+    // This loads visitor-scoped values from AsyncStorage and clears expired ones (>30 days)
+    await _storageHelper.StorageHelper.initialize();
+
+    // Auto-detect device info - always use detected values to prevent hardcoded values
+    const autoDetectedInfo = await _deviceInfoHelper.DeviceInfoHelper.getAppInfo();
+    _logger.Logger.logDbg('Auto-detected device info:', autoDetectedInfo);
+
+    // Set device type from auto-detection (Expo/react-native-device-info)
+    // This is more reliable than dimension-based detection which fails on high-res phones
+    const detectedDeviceType = autoDetectedInfo.is_tablet ? 'tablet' : 'mobile';
+    _dataStore.DataStore.overrideDeviceType(detectedDeviceType);
+    _logger.Logger.logDbg('Device type set from auto-detection:', detectedDeviceType);
+
+    // Always use auto-detected app_version (ignore options.app_version)
+    this.setAppVersion(autoDetectedInfo.app_version);
+
+    // Set device info with auto-detected values (cannot be overridden)
+    await this.setDeviceInfo();
     await _visitId.VisitIdProcessor.init(options === null || options === void 0 ? void 0 : options.orgId);
     const fbp = await _visitId.VisitIdProcessor.getFacebookFBP();
     if (fbp) {
@@ -41,9 +156,38 @@ class MagicPixelImpl {
       _logger.Logger.logDbg('No facebook client id found. not setting');
     }
 
+    // Auto-detect deeplink if app was opened via deeplink (e.g., ad click)
+    // Supports: custom schemes (myapp://), universal links (https://), app links, HTTP links
+    const initialDeepLink = await _deeplinkHelper.DeepLinkHelper.initialize((url, linkType) => {
+      try {
+        _logger.Logger.logDbg(`Deeplink detected (${linkType}):`, url);
+
+        // Store deeplink URL - will be attached to next page_load event
+        this.setDeepLinkUrl(url);
+
+        // Fire deeplink opened event
+        // URL params will be parsed and attached to page_load event automatically
+        this.recordEvent('deeplink_opened', {
+          deep_link_url: url,
+          link_type: linkType
+        });
+      } catch (err) {
+        _logger.Logger.logError('Error processing deeplink:', err);
+        _reporter.Reporter.reportError('deeplink_callback', err);
+      }
+    });
+    if (initialDeepLink) {
+      _logger.Logger.logDbg('App opened with initial deeplink:', initialDeepLink);
+    }
+
     // Initialize EEDL with any global event listeners
     await this.dl.init({});
 
+    // Set event deduplication window if specified (default is 5000ms)
+    if (typeof options.eventDeduplicationWindowMs !== 'undefined') {
+      this.dl.setDeduplicationWindow(options.eventDeduplicationWindowMs);
+    }
+
     // Make geo location API call after initialization
     try {
       await _geoLocation.GeoLocationProcessor.makeGeoLocationApiCall();
@@ -57,9 +201,8 @@ class MagicPixelImpl {
       const eventId = eventDataModel['ev._id'];
       _logger.Logger.logDbg('Tracking Event:: ', eventName, 'with id:: ', eventId);
       if (_dataStore.DataStore.shouldExecuteTMForEvent(eventName)) {
-        // if this is something the tag manager is interested in - fire tag manager
-        _dataStore.DataStore.enQueueTMFire(false, `custom_event_${eventName}`, eventName, eventId, eventDataModel);
-        await this.checkAndFireTM();
+        // Call runTM directly - no queuing, EEDL manages sequential processing
+        await this.runTM(false, `custom_event_${eventName}`, eventName, eventId, eventDataModel);
       }
     });
     const isFirstOpen = await _visitId.VisitIdProcessor.isFirstOpenAfterInstall();
@@ -68,8 +211,32 @@ class MagicPixelImpl {
       this.recordEvent('app_first_open', {});
     }
     this.ready();
+
+    // Mark SDK as ready and flush any buffered events
+    this.isReady = true;
+    this.isInitializing = false;
+    _logger.Logger.logDbg('SDK is ready, flushing event buffer');
+    this.flushEventBuffer();
   }
   static recordEvent(eventName, payload) {
+    // Buffer event if SDK is not ready yet
+    if (!this.isReady) {
+      _logger.Logger.logDbg(`SDK not ready, buffering event: ${eventName}`);
+      // Evict oldest event if buffer at capacity
+      if (this.eventBuffer.length >= MAX_BUFFERED_EVENTS) {
+        const evicted = this.eventBuffer.shift();
+        _logger.Logger.logDbg(`Event buffer at capacity (${MAX_BUFFERED_EVENTS}), evicted oldest:`, (evicted === null || evicted === void 0 ? void 0 : evicted.type) === 'event' ? evicted.name : 'pageLoad');
+      }
+      this.eventBuffer.push({
+        type: 'event',
+        name: eventName,
+        data: payload
+      });
+      return;
+    }
+    this.processRecordEvent(eventName, payload);
+  }
+  static processRecordEvent(eventName, payload) {
     if (this.customerInfo) {
       const newPayload = {
         ...payload,
@@ -88,32 +255,38 @@ class MagicPixelImpl {
   static ready() {
     this.dl.ready();
   }
-  static getDebugId() {
-    return _dataStore.DataStore.getDebugId();
-  }
-  static async checkAndFireTM() {
-    try {
-      if (!_dataStore.DataStore.isTagManagerProcessing()) {
-        const item = _dataStore.DataStore.deQueueTMFire();
-        if (item) {
-          _logger.Logger.logDbg('Executing TM For: ', item.name, ', Event:: ', item.dcrName, ', Event id:: ', item.eventId, 'Payload:: ', item.dcrPayload);
-          await this.runTM(item.sseOnly, item.name, item.dcrName, item.eventId, item.dcrPayload);
-        }
-      } else {
-        _logger.Logger.logDbg('Tag Manager is processing or is not ready. This event will start after that');
+
+  /**
+   * Flush buffered events after SDK is ready
+   * Events are processed in the order they were received
+   */
+  static flushEventBuffer() {
+    if (this.eventBuffer.length === 0) {
+      _logger.Logger.logDbg('No buffered events to flush');
+      return;
+    }
+    _logger.Logger.logDbg(`Flushing ${this.eventBuffer.length} buffered event(s)`);
+
+    // Process all buffered events in order
+    while (this.eventBuffer.length > 0) {
+      const event = this.eventBuffer.shift();
+      if (event.type === 'pageLoad') {
+        _logger.Logger.logDbg(`Processing buffered page load: ${event.data.page_name}`);
+        this.processRecordPageLoad(event.data);
+      } else if (event.type === 'event') {
+        _logger.Logger.logDbg(`Processing buffered event: ${event.name}`);
+        this.processRecordEvent(event.name, event.data);
       }
-    } catch (err) {
-      _logger.Logger.logError('Error check and process tm', err);
-      _reporter.Reporter.reportError('m:checkAndFireTM', err);
     }
+    _logger.Logger.logDbg('Event buffer flushed');
+  }
+  static getDebugId() {
+    return _dataStore.DataStore.getDebugId();
   }
   static async runTM(sseOnly, triggerName, evtName, evtId, eventData) {
     try {
       _logger.Logger.logDbg('Running:: ', sseOnly, triggerName, evtName, evtId, eventData);
 
-      // set tag manager in process status
-      _dataStore.DataStore.setTagManagerProcessing(true);
-
       // process all the data elements and cache them for this run
       await _dataElement.DataElementProcessor.processDataElements(_dataStore.DataStore.getSdkDataElements(), eventData);
       const sdk = _dataStore.DataStore.getClientSdk();
@@ -128,7 +301,8 @@ class MagicPixelImpl {
           _dataStore.DataStore.setPrivacyCompliance(false);
         }
       } else {
-        _logger.Logger.logDbg('Set: PR Comp: ', false);
+        // No privacy manager configured - default to true (tracking allowed)
+        _logger.Logger.logDbg('Set: PR Comp: ', true, '(no privacy manager configured)');
         _dataStore.DataStore.setPrivacyCompliance(true);
       }
       if (_dataStore.DataStore.getSdkPageLangKey()) {
@@ -141,48 +315,47 @@ class MagicPixelImpl {
       //set page_browser default data element with page_os because backend expects this
       _dataStore.DataStore.setDataElement('page_browser', _dataStore.DataStore.getOperatingSystem().toLowerCase());
       _reporter.Reporter.initReporter(sdk.s.ev, sdk.s.ev_id, _dataStore.DataStore.getDeviceType(), _dataStore.DataStore.getPageLang(), _dataStore.DataStore.getDeviceOs(), _dataStore.DataStore.getPageName(), evtName, evtId, _dataStore.DataStore.getClientDownStream(), _dataStore.DataStore.getCoreVersion(), []);
+
+      // Store developer payload (base64 encoded) for report
+      if (eventData) {
+        _reporter.Reporter.reportDevPayload(eventData, evtId);
+      }
       const validQCList = _qc.QcProcessor.processQc(_dataStore.DataStore.getSdkQC(), evtName, evtId);
       if ((validQCList === null || validQCList === void 0 ? void 0 : validQCList.length) > 0) {
         _logger.Logger.logDbg('Found Valid QCs to process', _dataStore.DataStore.getValidQcInfo());
         _tag.TagProcessor.processTags(evtName, evtId).then(() => {
-          this._fireTM(sdk.s.ev, sdk.s.ev_id, evtName, evtId);
+          this._fireTM(sdk.s.ev, sdk.s.ev_id, evtName, evtId, eventData);
         }).catch(err => {
           _logger.Logger.logError('Error processing tag lists.', err);
           _reporter.Reporter.reportError('i::processTags', err);
-          this._fireTM(sdk.s.ev, sdk.s.ev_id, evtName, evtId);
+          this._fireTM(sdk.s.ev, sdk.s.ev_id, evtName, evtId, eventData);
         });
       } else {
-        this._fireTM(sdk.s.ev, sdk.s.ev_id, evtName, evtId);
+        this._fireTM(sdk.s.ev, sdk.s.ev_id, evtName, evtId, eventData);
       }
     } catch (runTMErr) {
       _logger.Logger.logError('Error in runTM', runTMErr);
       _reporter.Reporter.reportError('m::runTM', runTMErr);
     }
   }
-  static _fireTM(envName, envId, evtName, evtId) {
+  static _fireTM(envName, envId, evtName, evtId, eventData) {
     // increment visit_depth if event name is page_load because that's the only way we can track page views in an app for now
     if (evtName === DL_INIT_EVENT) {
-      _visitId.VisitIdProcessor.incrementVisitDepth().finally(() => {
-        this._fireTMPrivate(envName, envId, evtName, evtId);
-      });
-    } else {
-      this._fireTMPrivate(envName, envId, evtName, evtId);
+      // Synchronous increment - no race condition possible
+      _visitId.VisitIdProcessor.incrementVisitDepth();
     }
+
+    // Continue immediately after sync increment
+    this._fireTMPrivate(envName, envId, evtName, evtId, eventData);
   }
-  static _fireTMPrivate(envName, envId, evtName, evtId) {
+  static _fireTMPrivate(envName, envId, evtName, evtId, eventData) {
     if (_dataStore.DataStore.hasOneSSTTag() && _dataStore.DataStore.shouldFireSstForEvent(evtName)) {
-      _reporter.Reporter.postSST(_dataStore.DataStore.getDataElements(), envName, envId, _dataStore.DataStore.getSSTDownStream(), evtName, evtId).catch(err => {
+      _reporter.Reporter.postSST(_dataStore.DataStore.getDataElements(), envName, envId, _dataStore.DataStore.getSSTDownStream(), evtName, evtId, eventData).catch(err => {
         _reporter.Reporter.reportError('l::postSST', err);
       });
     }
-    _dataStore.DataStore.setTagManagerProcessing(false);
-    _utils.Utils.sleep(250).then(async () => {
-      try {
-        await this.checkAndFireTM();
-      } catch (err) {
-        _reporter.Reporter.reportError('i::runTM', err);
-      }
-    });
+    // Note: EEDL handles queue progression via its own .finally() block
+    // No need to call processNext() here - it would be redundant
   }
   static setCustomerInfo(customerInfo) {
     this.customerInfo = customerInfo;
@@ -194,7 +367,39 @@ class MagicPixelImpl {
   static setDeepLinkUrl(deepLinkUrl) {
     this.deepLinkUrl = deepLinkUrl;
   }
-  static setDeviceInfo(deviceInfo) {
+
+  /**
+   * Set device info with auto-detected values
+   * Standard fields (os_version, device_model_name, package_name) are always auto-detected
+   * Optional customFields parameter allows adding custom tracking fields only
+   * @param customFields Optional custom fields to add (cannot override standard fields)
+   */
+  static async setDeviceInfo(customFields) {
+    // Always auto-detect standard device info (cannot be overridden)
+    const autoDetectedInfo = await _deviceInfoHelper.DeviceInfoHelper.getAppInfo();
+
+    // Standard fields are always auto-detected to prevent hardcoded values
+    const deviceInfo = {
+      os_version: autoDetectedInfo.os_version,
+      device_model_name: autoDetectedInfo.device_model_name,
+      package_name: autoDetectedInfo.package_name
+    };
+
+    // Add any custom fields (if provided)
+    if (customFields) {
+      // Filter out attempts to override standard fields
+      const allowedCustomFields = {
+        ...customFields
+      };
+      delete allowedCustomFields.os_version;
+      delete allowedCustomFields.device_model_name;
+      delete allowedCustomFields.package_name;
+      Object.assign(deviceInfo, allowedCustomFields);
+      if (Object.keys(allowedCustomFields).length !== Object.keys(customFields).length) {
+        _logger.Logger.logDbg('Warning: Attempted to override standard device fields. Using auto-detected values instead.');
+      }
+    }
+    _logger.Logger.logDbg('Setting device info:', deviceInfo);
     _dataStore.DataStore.setDeviceInfo(deviceInfo);
   }
   static setFacebookClientId(fbp) {
@@ -202,11 +407,34 @@ class MagicPixelImpl {
   }
   static setAppVersion(appVersion) {
     var _appVersion$trim;
-    if (appVersion && (appVersion === null || appVersion === void 0 ? void 0 : (_appVersion$trim = appVersion.trim()) === null || _appVersion$trim === void 0 ? void 0 : _appVersion$trim.length) > 0) {
+    if (appVersion && (appVersion === null || appVersion === void 0 || (_appVersion$trim = appVersion.trim()) === null || _appVersion$trim === void 0 ? void 0 : _appVersion$trim.length) > 0) {
       this.customerIdentifiers.app_version = appVersion;
     }
   }
   static recordPageLoad(pageLoadInfo) {
+    // Buffer page load if SDK is not ready yet
+    if (!this.isReady) {
+      _logger.Logger.logDbg(`SDK not ready, buffering page load: ${pageLoadInfo.page_name}`);
+      // Evict oldest event if buffer at capacity
+      if (this.eventBuffer.length >= MAX_BUFFERED_EVENTS) {
+        const evicted = this.eventBuffer.shift();
+        _logger.Logger.logDbg(`Event buffer at capacity (${MAX_BUFFERED_EVENTS}), evicted oldest:`, (evicted === null || evicted === void 0 ? void 0 : evicted.type) === 'event' ? evicted.name : 'pageLoad');
+      }
+      this.eventBuffer.push({
+        type: 'pageLoad',
+        data: {
+          ...pageLoadInfo
+        } // Clone to preserve original data
+      });
+      return;
+    }
+    this.processRecordPageLoad(pageLoadInfo);
+  }
+  static processRecordPageLoad(pageLoadInfo) {
+    // Retry visitor ID fetch if it failed during init (fire and forget)
+    _visitId.VisitIdProcessor.retryVisitorIdIfNeeded().catch(err => {
+      _logger.Logger.logError('Error retrying visitor ID fetch:', err);
+    });
     pageLoadInfo.is_entry = this.firstAppLaunch ? 1 : 0;
 
     // Use stored deepLinkUrl if it exists AND either:
@@ -215,13 +443,26 @@ class MagicPixelImpl {
     if (this.deepLinkUrl && !pageLoadInfo.deep_link_url) {
       pageLoadInfo.deep_link_url = this.deepLinkUrl;
     }
+
+    // Set page_url for attribution framework
+    // Priority: deep_link_url (if present) > constructed URL (v_<orgId>://<screen_name>)
+    // Using deep_link_url allows urlp data elements to extract attribution params (gclid, fbclid, etc.)
+    if (pageLoadInfo.deep_link_url) {
+      pageLoadInfo.page_url = pageLoadInfo.deep_link_url;
+      _logger.Logger.logDbg('Setting page_url from deep_link_url:', pageLoadInfo.page_url);
+    } else if (this.orgId && pageLoadInfo.page_name) {
+      pageLoadInfo.page_url = `v_${this.orgId}://${pageLoadInfo.page_name}`;
+      _logger.Logger.logDbg('Setting page_url from orgId/page_name:', pageLoadInfo.page_url);
+    } else {
+      _logger.Logger.logDbg('Not setting page_url. No deep_link_url and orgId or page_name is missing. Org Id is: ', this.orgId, 'page_name is: ', pageLoadInfo.page_name);
+    }
     const deviceInfo = _dataStore.DataStore.getDeviceInfo();
     if (this.customerInfo) {
       const newPayload = {
         ...pageLoadInfo,
         ...this.customerInfo,
         ...(this.customerIdentifiers ?? {}),
-        ..._utils.Utils.parseQueryParamsToObject(pageLoadInfo === null || pageLoadInfo === void 0 ? void 0 : pageLoadInfo.deep_link_url)
+        page_params: _utils.Utils.parseQueryParamsToObject(pageLoadInfo === null || pageLoadInfo === void 0 ? void 0 : pageLoadInfo.deep_link_url)
       };
       if (deviceInfo) {
         newPayload.device_info = deviceInfo;
@@ -231,7 +472,7 @@ class MagicPixelImpl {
       const newPayload = {
         ...pageLoadInfo,
         ...(this.customerIdentifiers ?? {}),
-        ..._utils.Utils.parseQueryParamsToObject(pageLoadInfo === null || pageLoadInfo === void 0 ? void 0 : pageLoadInfo.deep_link_url)
+        page_params: _utils.Utils.parseQueryParamsToObject(pageLoadInfo === null || pageLoadInfo === void 0 ? void 0 : pageLoadInfo.deep_link_url)
       };
       if (deviceInfo) {
         newPayload.device_info = deviceInfo;
@@ -317,7 +558,13 @@ _defineProperty(MagicPixelImpl, "dl", new _eedl.MpDataLayerHelper('mpDlEvent', '
 _defineProperty(MagicPixelImpl, "customerInfo", void 0);
 _defineProperty(MagicPixelImpl, "customerIdentifiers", {});
 _defineProperty(MagicPixelImpl, "deepLinkUrl", undefined);
+_defineProperty(MagicPixelImpl, "orgId", undefined);
 _defineProperty(MagicPixelImpl, "firstAppLaunch", true);
+// SDK readiness state and event buffer
+_defineProperty(MagicPixelImpl, "isReady", false);
+_defineProperty(MagicPixelImpl, "isInitializing", false);
+_defineProperty(MagicPixelImpl, "eventBuffer", []);
+_defineProperty(MagicPixelImpl, "onInitFailureCallback", void 0);
 const MagicPixelEventBus = exports.MagicPixelEventBus = _eventBus.EventBus;
 const MagicPixel = exports.MagicPixel = MagicPixelImpl;
 //# sourceMappingURL=index.js.map