@mparticle/web-sdk 2.56.0 → 2.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.56.0",
+    "version": "2.58.0",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [

package/src/constants.ts

@@ -139,6 +139,8 @@ const Constants = {
         identityUrl: 'identity.mparticle.com/v1/',
         aliasUrl: 'jssdks.mparticle.com/v1/identity/',
         userAudienceUrl: 'nativesdks.mparticle.com/v1/',
+        loggingUrl: 'apps.rokt-api.com/v1/log',
+        errorUrl: 'apps.rokt-api.com/v1/errors',
     },
     // These are the paths that are used to construct the CNAME urls
     CNAMEUrlPaths: {
@@ -148,6 +150,8 @@ const Constants = {
         configUrl: '/tags/JS/v2/',
         identityUrl: '/identity/v1/',
         aliasUrl: '/webevents/v1/identity/',
+        loggingUrl: '/v1/log',
+        errorUrl: '/v1/errors',
     },
     Base64CookieKeys: {
         csm: 1,

package/src/identityApiClient.ts

@@ -1,4 +1,4 @@
-import Constants, { HTTP_ACCEPTED, HTTP_BAD_REQUEST, HTTP_OK } from './constants';
+import Constants, { HTTP_ACCEPTED, HTTP_BAD_REQUEST, HTTP_OK, HTTP_SERVER_ERROR } from './constants';
 import {
     AsyncUploader,
     FetchUploader,
@@ -25,6 +25,7 @@ import {
     IIdentityResponse,
 } from './identity-user-interfaces';
 import { IMParticleWebSDKInstance } from './mp-instance';
+import { ErrorCodes } from './logging/types';
 
 const { HTTPCodes, Messages, IdentityMethods } = Constants;
 
@@ -284,15 +285,26 @@ export default function IdentityAPIClient(
                     break;
                     
                 // Our Identity API will return:
-                // - 401 if the `x-mp-key` is incorrect or missing
-                // - 403 if the there is a permission or account issue related to the `x-mp-key`
+                // 401 if the `x-mp-key` is incorrect or missing
+                // 403 if the there is a permission or account issue related to the `x-mp-key`
                 // 401 and 403 have no response bodies and should be rejected outright
+                // 5xx server error throws error but RoktManager continues
                 default: {
-                    throw new Error('Received HTTP Code of ' + response.status);
+                    if (response.status >= HTTP_SERVER_ERROR) {
+                        throw new Error('Received HTTP Code of ' + response.status);
+                    }
+                    
+                    mpInstance._Store.identityCallInFlight = false;
+                    mpInstance._Store.identityCallFailed = false;
+                    const errorMessage = 'Received HTTP Code of ' + response.status;
+                    Logger.error('Error sending identity request to servers - ' + errorMessage);
+                    invokeCallback(callback, HTTPCodes.noHttpCoverage, errorMessage);
+                    return;
                 }
             }
 
             mpInstance._Store.identityCallInFlight = false;
+            mpInstance._Store.identityCallFailed = false;
 
             Logger.verbose(message);
             if (mpInstance._RoktManager?.isInitialized) {
@@ -310,19 +322,20 @@ export default function IdentityAPIClient(
             );
         } catch (err) {
             mpInstance._Store.identityCallInFlight = false;
+            mpInstance._Store.identityCallFailed = true;
             if (mpInstance._RoktManager?.isInitialized) {
                 const requestCount = mpInstance._Store.identifyRequestCount;
                 mpInstance.captureTiming(`${requestCount}-identityRequestEnd`);
             }
-            
-            const errorMessage = (err as Error).message || err.toString();
 
-            Logger.error('Error sending identity request to servers' + ' - ' + errorMessage);
-            invokeCallback(
-                callback,
-                HTTPCodes.noHttpCoverage,
-                errorMessage,
+            const errorMessage = (err as Error).message || err.toString();
+            Logger.error(
+                'Error sending identity request to servers' + ' - ' + errorMessage,
+                ErrorCodes.IDENTITY_REQUEST
             );
+
+            mpInstance.processQueueOnIdentityFailure?.();
+            invokeCallback(callback, HTTPCodes.noHttpCoverage, errorMessage);
         }
     };
 

package/src/logger.ts

@@ -1,4 +1,6 @@
 import { LogLevelType, SDKInitConfig, SDKLoggerApi } from './sdkRuntimeModels';
+import { ReportingLogger } from './logging/reportingLogger';
+import { ErrorCodes } from './logging/types';
 
 export type ILoggerConfig = Pick<SDKInitConfig, 'logLevel' | 'logger'>;
 export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'verbose'>>;
@@ -6,10 +8,14 @@ export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'v
 export class Logger {
     private logLevel: LogLevelType;
     private logger: IConsoleLogger;
+    private reportingLogger: ReportingLogger;
 
-    constructor(config: ILoggerConfig) {
+    constructor(config: ILoggerConfig,
+        reportingLogger?: ReportingLogger,
+    ) {
         this.logLevel = config.logLevel ?? LogLevelType.Warning;
         this.logger = config.logger ?? new ConsoleLogger();
+        this.reportingLogger = reportingLogger;
     }
 
     public verbose(msg: string): void {
@@ -22,21 +28,24 @@ export class Logger {
     }
 
     public warning(msg: string): void {
-        if(this.logLevel === LogLevelType.None) 
+        if(this.logLevel === LogLevelType.None)
             return;
 
-        if (this.logger.warning && 
+        if (this.logger.warning &&
             (this.logLevel === LogLevelType.Verbose || this.logLevel === LogLevelType.Warning)) {
             this.logger.warning(msg);
         }
     }
 
-    public error(msg: string): void {
-        if(this.logLevel === LogLevelType.None) 
+    public error(msg: string, codeForReporting?: ErrorCodes): void {
+        if(this.logLevel === LogLevelType.None)
             return;
 
         if (this.logger.error) {
             this.logger.error(msg);
+            if (codeForReporting) {
+                this.reportingLogger?.error(msg, codeForReporting);
+            }
         }
     }
 

package/src/logging/reportingLogger.ts

@@ -0,0 +1,192 @@
+import { ErrorCodes, LogRequestBody, WSDKErrorSeverity } from "./types";
+import { FetchUploader, IFetchPayload } from "../uploaders";
+import { IStore, SDKConfig } from "../store";
+import { SDKInitConfig } from "../sdkRuntimeModels";
+import Constants from "../constants";
+
+// Header key constants
+const HEADER_ACCEPT = 'Accept' as const;
+const HEADER_CONTENT_TYPE = 'Content-Type' as const;
+const HEADER_ROKT_LAUNCHER_VERSION = 'rokt-launcher-version' as const;
+const HEADER_ROKT_LAUNCHER_INSTANCE_GUID = 'rokt-launcher-instance-guid' as const;
+const HEADER_ROKT_WSDK_VERSION = 'rokt-wsdk-version' as const;
+
+interface IReportingLoggerPayload extends IFetchPayload {
+    headers: IFetchPayload['headers'] & {
+        [HEADER_ROKT_LAUNCHER_INSTANCE_GUID]?: string;
+        [HEADER_ROKT_LAUNCHER_VERSION]: string;
+        [HEADER_ROKT_WSDK_VERSION]: string;
+    };
+    body: string;
+}
+
+export class ReportingLogger {
+    private readonly isEnabled: boolean;
+    private readonly reporter: string = 'mp-wsdk';
+    private readonly rateLimiter: IRateLimiter;
+    private store: IStore | null;
+    private readonly loggingUrl: string;
+    private readonly errorUrl: string;
+    private readonly isLoggingEnabled: boolean;
+
+    constructor(
+        config: SDKConfig | SDKInitConfig | any,
+        private readonly sdkVersion: string,
+        store?: IStore,
+        private readonly launcherInstanceGuid?: string,
+        rateLimiter?: IRateLimiter,
+    ) {
+        this.loggingUrl = `https://${config.loggingUrl || Constants.DefaultBaseUrls.loggingUrl}`;
+        this.errorUrl = `https://${config.errorUrl || Constants.DefaultBaseUrls.errorUrl}`;
+        this.isLoggingEnabled = config.isLoggingEnabled || false;
+        this.store = store ?? null;
+        this.isEnabled = this.isReportingEnabled();
+        this.rateLimiter = rateLimiter ?? new RateLimiter();
+    }
+
+    public setStore(store: IStore): void {
+        this.store = store;
+    }
+
+    public info(msg: string, code?: ErrorCodes) {
+        this.sendLog(WSDKErrorSeverity.INFO, msg, code);
+    }
+
+    public error(msg: string, code?: ErrorCodes, stackTrace?: string) {
+        this.sendError(WSDKErrorSeverity.ERROR, msg, code, stackTrace);
+    }
+
+    public warning(msg: string, code?: ErrorCodes) { 
+        this.sendError(WSDKErrorSeverity.WARNING, msg, code);
+    }
+    
+    private sendToServer(url: string, severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
+        if (!this.canSendLog(severity))
+            return;
+
+        try {
+            const logRequest = this.buildLogRequest(severity, msg, code, stackTrace);
+            const uploader = new FetchUploader(url);
+            const payload: IReportingLoggerPayload = {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(logRequest),
+            };
+            uploader.upload(payload).catch((error) => {
+                console.error('ReportingLogger: Failed to send log', error);
+            });
+        } catch (error) {
+            console.error('ReportingLogger: Failed to send log', error);
+        }
+    }
+
+    private sendLog(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
+        this.sendToServer(this.loggingUrl, severity, msg, code, stackTrace);
+    }
+
+    private sendError(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): void {
+        this.sendToServer(this.errorUrl, severity, msg, code, stackTrace);
+    }
+ 
+    private buildLogRequest(severity: WSDKErrorSeverity, msg: string, code?: ErrorCodes, stackTrace?: string): LogRequestBody {
+        return {
+            additionalInformation: {
+                message: msg,
+                version: this.getVersion(),
+            },
+            severity: severity,
+            code: code ?? ErrorCodes.UNKNOWN_ERROR,
+            url: this.getUrl(),
+            deviceInfo: this.getUserAgent(),
+            stackTrace: stackTrace,
+            reporter: this.reporter,
+            // Integration will be set to integrationName once the kit connects via RoktManager.attachKit()
+            integration: this.store?.getIntegrationName() ?? 'mp-wsdk'
+        };
+    }
+
+    private getVersion(): string {
+        return this.store?.getIntegrationName?.() ?? `mParticle_wsdkv_${this.sdkVersion}`;
+    }
+    
+    private isReportingEnabled(): boolean {
+        return this.isDebugModeEnabled() ||
+               (this.isRoktDomainPresent() && this.isFeatureFlagEnabled());
+    }
+
+    private isRoktDomainPresent(): boolean {
+        return typeof window !== 'undefined' && Boolean(window['ROKT_DOMAIN']);
+    }
+
+    private isFeatureFlagEnabled = (): boolean => this.isLoggingEnabled;
+
+    private isDebugModeEnabled(): boolean {
+        return (
+            typeof window !== 'undefined' &&
+            (window.
+                location?.
+                search?.
+                toLowerCase()?.
+                includes('mp_enable_logging=true') ?? false)
+        );
+    }
+
+    private canSendLog(severity: WSDKErrorSeverity): boolean {
+        return this.isEnabled && !this.isRateLimited(severity);
+    }
+
+    private isRateLimited(severity: WSDKErrorSeverity): boolean {
+        return this.rateLimiter.incrementAndCheck(severity);
+    }
+
+    private getUrl(): string | undefined {
+        return typeof window !== 'undefined' ? window.location?.href : undefined;
+    }
+
+    private getUserAgent(): string | undefined {
+        return typeof window !== 'undefined' ? window.navigator?.userAgent : undefined;
+    }
+
+    private getHeaders(): IReportingLoggerPayload['headers'] {
+        const headers: IReportingLoggerPayload['headers'] = {
+            [HEADER_ACCEPT]: 'text/plain;charset=UTF-8',
+            [HEADER_CONTENT_TYPE]: 'application/json',
+            [HEADER_ROKT_LAUNCHER_VERSION]: this.getVersion(),
+            [HEADER_ROKT_WSDK_VERSION]: 'joint',
+        };
+
+        if (this.launcherInstanceGuid) {
+            headers[HEADER_ROKT_LAUNCHER_INSTANCE_GUID] = this.launcherInstanceGuid;
+        }
+
+        const accountId = this.store?.getRoktAccountId?.();
+        if (accountId) {
+            headers['rokt-account-id'] = accountId;
+        }
+
+        return headers;
+    }
+}
+
+export interface IRateLimiter {
+    incrementAndCheck(severity: WSDKErrorSeverity): boolean;
+}
+
+export class RateLimiter implements IRateLimiter {
+    private readonly rateLimits: Map<WSDKErrorSeverity, number> = new Map([
+        [WSDKErrorSeverity.ERROR, 10],
+        [WSDKErrorSeverity.WARNING, 10],
+        [WSDKErrorSeverity.INFO, 10],
+    ]);
+    private logCount: Map<WSDKErrorSeverity, number> = new Map();
+
+    public incrementAndCheck(severity: WSDKErrorSeverity): boolean {
+        const count = this.logCount.get(severity) || 0;
+        const limit = this.rateLimits.get(severity) || 10;
+        
+        const newCount = count + 1;
+        this.logCount.set(severity, newCount);
+        
+        return newCount > limit;
+    }
+}

package/src/logging/types.ts

@@ -0,0 +1,32 @@
+import { valueof } from '../utils';
+
+export const ErrorCodes = {
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    UNHANDLED_EXCEPTION: 'UNHANDLED_EXCEPTION',
+    IDENTITY_REQUEST: 'IDENTITY_REQUEST',
+} as const;
+
+export type ErrorCodes = valueof<typeof ErrorCodes>;
+
+export type ErrorCode = ErrorCodes | string;
+
+export const WSDKErrorSeverity = {
+    ERROR: 'ERROR',
+    INFO: 'INFO',
+    WARNING: 'WARNING',
+} as const;
+
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+
+export type ErrorsRequestBody = {
+    additionalInformation?: Record<string, string>;
+    code: ErrorCode;
+    severity: WSDKErrorSeverity;
+    stackTrace?: string;
+    deviceInfo?: string;
+    integration?: string;
+    reporter?: string;
+    url?: string;
+};
+
+export type LogRequestBody = ErrorsRequestBody;

package/src/mp-instance.ts

@@ -52,6 +52,7 @@ import ForegroundTimer from './foregroundTimeTracker';
 import RoktManager, { IRoktOptions } from './roktManager';
 import filteredMparticleUser from './filteredMparticleUser';
 import CookieConsentManager, { ICookieConsentManager } from './cookieConsentManager';
+import { ReportingLogger } from './logging/reportingLogger';
 
 export interface IErrorLogMessage {
     message?: string;
@@ -84,15 +85,18 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
     _CookieConsentManager: ICookieConsentManager;
+    _ReportingLogger: ReportingLogger;
     _RoktManager: RoktManager;
     _SessionManager: ISessionManager;
     _ServerModel: IServerModel;
     _Store: IStore;
     _instanceName: string;
     _preInit: IPreInit;
-    _timeOnSiteTimer: ForegroundTimer; 
+    _timeOnSiteTimer: ForegroundTimer;
     setLauncherInstanceGuid: () => void;
+    getLauncherInstanceGuid: () => string;
     captureTiming(metricName: string);
+    processQueueOnIdentityFailure?: () => void;
 }
 
 const { Messages, HTTPCodes, FeatureFlags, CaptureIntegrationSpecificIdsV2Modes } = Constants;
@@ -132,7 +136,26 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         integrationDelays: {},
         forwarderConstructors: [],
     };
+
     this._RoktManager = new RoktManager();
+    
+    this._RoktManager.setOnReadyCallback(() => {
+        self.processQueueOnIdentityFailure();
+    });
+    
+    /**
+     * Processes message and ready queue when identity requests fails but Rokt is ready.
+     */
+    this.processQueueOnIdentityFailure = function() {
+        if (self._Store?.isInitialized) {
+            return;
+        }
+        
+        if (self._Store?.identityCallFailed && self._RoktManager?.isReady()) {
+            self._RoktManager.processMessageQueue();
+            self._preInit.readyQueue = processReadyQueue(self._preInit.readyQueue);
+        }
+    };
 
     // required for forwarders once they reference the mparticle instance
     this.IdentityType = IdentityType;
@@ -225,12 +248,14 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
-    this._resetForTests = function(config, keepPersistence, instance) {
+    this._resetForTests = function(config, keepPersistence, instance, reportingLogger?: ReportingLogger) {
         if (instance._Store) {
             delete instance._Store;
         }
-        instance.Logger = new Logger(config);
+        instance.Logger = new Logger(config, reportingLogger);
         instance._Store = new Store(config, instance);
+        // Update ReportingLogger with the new Store reference to avoid stale data
+        reportingLogger?.setStore(instance._Store);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(
             window.localStorage
         );
@@ -249,12 +274,18 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         };
     };
     /**
-     * A callback method that is invoked after mParticle is initialized.
+     * Executes callback when the SDK is ready, or Rokt is ready but identify requests fail due to server errors.
+     * This ensures Rokt methods like selectPlacements continue to work during backend outages.
      * @method ready
-     * @param {Function} function A function to be called after mParticle is initialized
+     * @param {Function} f Callback to execute
      */
     this.ready = function(f) {
-        if (self.isInitialized() && typeof f === 'function') {
+        const shouldExecute = isFunction(f) && (
+            self._Store?.isInitialized || 
+            (self._Store?.identityCallFailed && self._RoktManager.isReady())
+        );
+        
+        if (shouldExecute) {
             f();
         } else {
             self._preInit.readyQueue.push(f);
@@ -1346,7 +1377,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
             };
         }
     };
-    
+
     const launcherInstanceGuidKey = Constants.Rokt.LauncherInstanceGuidKey;
     this.setLauncherInstanceGuid = function() {
         if (!window[launcherInstanceGuidKey] 
@@ -1355,6 +1386,10 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
+    this.getLauncherInstanceGuid = function() {
+        return window[launcherInstanceGuidKey];
+    };
+
     this.captureTiming = function(metricsName) {
         if (typeof window !== 'undefined' && window.performance?.mark) {
             window.performance.mark(metricsName);
@@ -1420,6 +1455,8 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
         // Configure Rokt Manager with user and filtered user
         const roktConfig: IKitConfigs = parseConfig(config, 'Rokt', 181);
         if (roktConfig) {
+            const accountId = roktConfig.settings?.accountId;
+            mpInstance._Store.setRoktAccountId(accountId);
             const { userAttributeFilters } = roktConfig;
             const roktFilteredUser = filteredMparticleUser(
                 currentUserMPID,
@@ -1553,9 +1590,16 @@ function createIdentityCache(mpInstance) {
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
-    mpInstance.Logger = new Logger(config);
+    mpInstance._ReportingLogger = new ReportingLogger(
+        config,
+        Constants.sdkVersion,
+        undefined,
+        mpInstance.getLauncherInstanceGuid(),
+    );
+    mpInstance.Logger = new Logger(config, mpInstance._ReportingLogger);
     mpInstance._Store = new Store(config, mpInstance, apiKey);
     window.mParticle.Store = mpInstance._Store;
+    mpInstance._ReportingLogger.setStore(mpInstance._Store);
     mpInstance.Logger.verbose(StartingInitialization);
 
     // Initialize CookieConsentManager with privacy flags from launcherOptions
@@ -1620,9 +1664,12 @@ function processIdentityCallback(
 }
 
 function queueIfNotInitialized(func, self) {
-    if (!self.isInitialized()) {
-        self.ready(function() {
-            func();
+    // Core SDK methods must wait for Store initialization
+    if (!self._Store?.isInitialized) {
+        self._preInit.readyQueue.push(function() {
+            if (self._Store?.isInitialized) {
+                func();
+            }
         });
         return true;
     }

package/src/roktManager.ts

@@ -59,6 +59,12 @@ export interface RoktKitFilterSettings {
     filteredUser?: IMParticleUser | null;
 }
 
+export interface IRoktKitSettings {
+    accountId?: string;
+    placementAttributesMapping?: string;
+    hashedEmailUserIdentityType?: string;
+}
+
 export interface IRoktKit {
     filters: RoktKitFilterSettings;
     filteredUser: IMParticleUser | null;
@@ -69,6 +75,8 @@ export interface IRoktKit {
     setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void;
     use: <T>(name: string) => Promise<T>;
     launcherOptions?: Dictionary<any>;
+    settings?: IRoktKitSettings;
+    integrationName?: string;
 }
 
 export interface IRoktOptions {
@@ -102,7 +110,16 @@ export default class RoktManager {
     private domain?: string;
     private mappedEmailShaIdentityType?: string | null;
     private captureTiming?: (metricsName: string) => void;
+    private onReadyCallback: (() => void) | null = null;
     private initialized: boolean = false;
+
+    /**
+     * Sets a callback to be invoked when RoktManager becomes ready
+     */
+    public setOnReadyCallback(callback: () => void): void {
+        this.onReadyCallback = callback;
+    }
+  
     /**
      * Initializes the RoktManager with configuration settings and user data.
      * 
@@ -133,6 +150,8 @@ export default class RoktManager {
         this.logger = logger;
         this.captureTiming = captureTiming;
 
+        this.captureTiming?.(PerformanceMarkType.JointSdkRoktKitInit);
+
         this.filters = {
             userAttributeFilters,
             filterUserAttributes: KitFilterHelper.filterUserAttributes,
@@ -170,7 +189,22 @@ export default class RoktManager {
 
     public attachKit(kit: IRoktKit): void {
         this.kit = kit;
+
+        if (kit.settings?.accountId) {
+            this.store.setRoktAccountId(kit.settings.accountId);
+        }
+
+        if (kit.integrationName) {
+            this.store?.setIntegrationName(kit.integrationName);
+        }
+
         this.processMessageQueue();
+
+        try {
+            this.onReadyCallback?.();
+        } catch (e) {
+            this.logger?.error('RoktManager: Error in onReadyCallback: ' + e);
+        }
     }
 
     /**
@@ -189,9 +223,7 @@ export default class RoktManager {
      * });
      */
     public async selectPlacements(options: IRoktSelectPlacementsOptions): Promise<IRoktSelection> {
-        if (this.captureTiming) {
-            this.captureTiming(PerformanceMarkType.JointSdkSelectPlacements);
-        }
+        this.captureTiming?.(PerformanceMarkType.JointSdkSelectPlacements);
         
         // Queue if kit isn't ready OR if identity is in flight
         if (!this.isReady() || this.store?.identityCallInFlight) {
@@ -406,7 +438,7 @@ export default class RoktManager {
         this.store.setLocalSessionAttribute(key, value);
     }
 
-    private isReady(): boolean {
+    public isReady(): boolean {
         // The Rokt Manager is ready when a kit is attached and has a launcher
         return Boolean(this.kit && this.kit.launcher);
     }
@@ -453,7 +485,7 @@ export default class RoktManager {
         }
     }
 
-    private processMessageQueue(): void {
+    public processMessageQueue(): void {
         if (!this.isReady() || this.messageQueue.size === 0) {
             return;
         }
@@ -573,4 +605,4 @@ export default class RoktManager {
         
         return false; // Values are the same
     }
-}
+}