@splitsoftware/splitio-commons 2.4.2-rc.1 → 2.4.2-rc.2

package/cjs/storages/inLocalStorage/storageAdapter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storageAdapter = void 0;
+var constants_1 = require("./constants");
+function isTillKey(key) {
+    return key.endsWith('.till');
+}
+function storageAdapter(log, prefix, wrapper) {
+    var cache = {};
+    var connectPromise;
+    var disconnectPromise = Promise.resolve();
+    return {
+        load: function () {
+            return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then(function (storedCache) {
+                cache = JSON.parse(storedCache || '{}');
+            }).catch(function (e) {
+                log.error(constants_1.LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
+            }));
+        },
+        save: function () {
+            return disconnectPromise = disconnectPromise.then(function () {
+                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch(function (e) {
+                    log.error(constants_1.LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
+                });
+            });
+        },
+        get length() {
+            return Object.keys(cache).length;
+        },
+        getItem: function (key) {
+            return cache[key] || null;
+        },
+        key: function (index) {
+            return Object.keys(cache)[index] || null;
+        },
+        removeItem: function (key) {
+            delete cache[key];
+            if (isTillKey(key))
+                this.save();
+        },
+        setItem: function (key, value) {
+            cache[key] = value;
+            if (isTillKey(key))
+                this.save();
+        }
+    };
+}
+exports.storageAdapter = storageAdapter;

package/cjs/storages/inLocalStorage/validateCache.js

@@ -11,10 +11,10 @@ var MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
+function validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache) {
     var log = settings.log;
     // Check expiration
-    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
+    var lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp)) {
         var cacheExpirationInDays = (0, lang_1.isFiniteNumber)(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
         var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
@@ -25,11 +25,11 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
     }
     // Check hash
     var storageHashKey = keys.buildHashKey();
-    var storageHash = localStorage.getItem(storageHashKey);
+    var storageHash = storage.getItem(storageHashKey);
     var currentStorageHash = (0, KeyBuilder_1.getStorageHash)(settings);
     if (storageHash !== currentStorageHash) {
         try {
-            localStorage.setItem(storageHashKey, currentStorageHash);
+            storage.setItem(storageHashKey, currentStorageHash);
         }
         catch (e) {
             log.error(constants_1.LOG_PREFIX + e);
@@ -42,7 +42,7 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
     }
     // Clear on init
     if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
+        var lastClearTimestamp = parseInt(storage.getItem(keys.buildLastClear()), 10);
         if ((0, lang_1.isNaNNumber)(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
             log.info(constants_1.LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
             return true;
@@ -57,24 +57,26 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-function validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments) {
-    var currentTimestamp = Date.now();
-    var isThereCache = splits.getChangeNumber() > -1;
-    if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
-        splits.clear();
-        rbSegments.clear();
-        segments.clear();
-        largeSegments.clear();
-        // Update last clear timestamp
-        try {
-            localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
-        }
-        catch (e) {
-            settings.log.error(constants_1.LOG_PREFIX + e);
+function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
+    return Promise.resolve(storage.load && storage.load()).then(function () {
+        var currentTimestamp = Date.now();
+        var isThereCache = splits.getChangeNumber() > -1;
+        if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
+            splits.clear();
+            rbSegments.clear();
+            segments.clear();
+            largeSegments.clear();
+            // Update last clear timestamp
+            try {
+                storage.setItem(keys.buildLastClear(), currentTimestamp + '');
+            }
+            catch (e) {
+                settings.log.error(constants_1.LOG_PREFIX + e);
+            }
+            return false;
         }
-        return false;
-    }
-    // Check if ready from cache
-    return isThereCache;
+        // Check if ready from cache
+        return isThereCache;
+    });
 }
 exports.validateCache = validateCache;

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -45,10 +45,9 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    var isCacheLoaded_1 = storage.validateCache ? storage.validateCache() : false;
-                    Promise.resolve().then(function () {
+                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded_1)
+                        if (isCacheLoaded)
                             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);

package/cjs/sync/polling/pollingManagerCS.js

@@ -7,6 +7,7 @@ var splitsSyncTask_1 = require("./syncTasks/splitsSyncTask");
 var key_1 = require("../../utils/key");
 var constants_1 = require("../../readiness/constants");
 var constants_2 = require("../../logger/constants");
+var AbstractSplitsCacheSync_1 = require("../../storages/AbstractSplitsCacheSync");
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -34,7 +35,7 @@ function pollingManagerCSFactory(params) {
     readiness.splits.on(constants_1.SDK_SPLITS_ARRIVED, function () {
         if (!splitsSyncTask.isRunning())
             return; // noop if not doing polling
-        var usingSegments = storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+        var usingSegments = (0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage);
         if (usingSegments !== mySegmentsSyncTask.isRunning()) {
             log.info(constants_2.POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
             if (usingSegments) {
@@ -49,10 +50,10 @@ function pollingManagerCSFactory(params) {
         var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
-            if (!readiness.isReady() && !storage.splits.usesSegments() && !storage.rbSegments.usesSegments())
+            if (!readiness.isReady() && !(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                 readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);
         }
-        if (!storage.splits.usesSegments() && !storage.rbSegments.usesSegments())
+        if (!(0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
             setTimeout(smartReady, 0);
         else
             readiness.splits.once(constants_1.SDK_SPLITS_ARRIVED, smartReady);
@@ -66,7 +67,7 @@ function pollingManagerCSFactory(params) {
         start: function () {
             log.info(constants_2.POLLING_START);
             splitsSyncTask.start();
-            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                 startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -5,6 +5,7 @@ var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var constants_3 = require("../../streaming/constants");
+var AbstractSplitsCacheSync_1 = require("../../../storages/AbstractSplitsCacheSync");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -12,7 +13,7 @@ var constants_3 = require("../../streaming/constants");
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
 function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var segments = storage.segments, largeSegments = storage.largeSegments;
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -34,7 +35,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
             shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
         // Notify update if required
-        if ((splits.usesSegments() || rbSegments.usesSegments()) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED);
         }

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -46,7 +46,7 @@ function parseSegments(ruleEntity, matcherType) {
 exports.parseSegments = parseSegments;
 /**
  * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there are set filter defined, names filter is ignored
+ * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
  *
  * @param featureFlag - feature flag to be evaluated
  * @param filters - splitFiltersValidation bySet | byName

package/cjs/sync/syncManagerOnline.js

@@ -7,6 +7,7 @@ var constants_2 = require("../logger/constants");
 var consent_1 = require("../consent");
 var constants_3 = require("../utils/constants");
 var constants_4 = require("../readiness/constants");
+var AbstractSplitsCacheSync_1 = require("../storages/AbstractSplitsCacheSync");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -68,35 +69,39 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
              */
             start: function () {
                 running = true;
-                if (startFirstTime) {
-                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-                    if (isCacheLoaded)
-                        Promise.resolve().then(function () { readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED); });
-                }
-                // start syncing splits and segments
-                if (pollingManager) {
-                    // If synchronization is disabled pushManager and pollingManager should not start
-                    if (syncEnabled) {
-                        if (pushManager) {
-                            // Doesn't call `syncAll` when the syncManager is resuming
-                            if (startFirstTime) {
-                                pollingManager.syncAll();
+                // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
+                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
+                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    if (!running)
+                        return;
+                    if (startFirstTime) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (isCacheLoaded)
+                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED);
+                    }
+                    // start syncing splits and segments
+                    if (pollingManager) {
+                        // If synchronization is disabled pushManager and pollingManager should not start
+                        if (syncEnabled) {
+                            if (pushManager) {
+                                // Doesn't call `syncAll` when the syncManager is resuming
+                                if (startFirstTime) {
+                                    pollingManager.syncAll();
+                                }
+                                pushManager.start();
+                            }
+                            else {
+                                pollingManager.start();
                             }
-                            pushManager.start();
                         }
                         else {
-                            pollingManager.start();
-                        }
-                    }
-                    else {
-                        if (startFirstTime) {
-                            pollingManager.syncAll();
+                            if (startFirstTime) {
+                                pollingManager.syncAll();
+                            }
                         }
                     }
-                }
-                // start periodic data recording (events, impressions, telemetry).
-                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
-                startFirstTime = false;
+                    startFirstTime = false;
+                });
             },
             /**
              * Method used to stop/pause the syncManager.
@@ -130,7 +135,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                         if (pushManager) {
                             if (pollingManager.isRunning()) {
                                 // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                                if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -140,7 +145,7 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                             }
                         }
                         else {
-                            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                            if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage))
                                 mySegmentsSyncTask.start();
                         }
                     }

package/cjs/trackers/impressionsTracker.js

@@ -9,7 +9,7 @@ var constants_2 = require("../utils/constants");
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  */
 function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === constants_2.CONSENT_DECLINED)
@@ -42,7 +42,7 @@ function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, str
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
-            if (settings.impressionListener || integrationsManager) {
+            if (impressionListener || integrationsManager) {
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
@@ -59,8 +59,8 @@ function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, str
                             if (integrationsManager)
                                 integrationsManager.handleImpression(impressionData);
                             try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (settings.impressionListener)
-                                    settings.impressionListener.logImpression(impressionData);
+                                if (impressionListener)
+                                    impressionListener.logImpression(impressionData);
                             }
                             catch (err) {
                                 log.error(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);

package/cjs/utils/env/isLocalStorageAvailable.js

@@ -1,16 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isLocalStorageAvailable = void 0;
-/* eslint-disable no-undef */
+exports.isWebStorage = exports.isValidStorageWrapper = exports.isLocalStorageAvailable = void 0;
 function isLocalStorageAvailable() {
+    try {
+        // eslint-disable-next-line no-undef
+        return isValidStorageWrapper(localStorage);
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.isLocalStorageAvailable = isLocalStorageAvailable;
+function isValidStorageWrapper(wrapper) {
     var mod = '__SPLITSOFTWARE__';
     try {
-        localStorage.setItem(mod, mod);
-        localStorage.removeItem(mod);
+        wrapper.setItem(mod, mod);
+        wrapper.getItem(mod);
+        wrapper.removeItem(mod);
         return true;
     }
     catch (e) {
         return false;
     }
 }
-exports.isLocalStorageAvailable = isLocalStorageAvailable;
+exports.isValidStorageWrapper = isValidStorageWrapper;
+function isWebStorage(wrapper) {
+    if (typeof wrapper.length === 'number') {
+        try {
+            wrapper.key(0);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    return false;
+}
+exports.isWebStorage = isWebStorage;

package/cjs/utils/settingsValidation/splitFilters.js

@@ -61,12 +61,6 @@ function validateSplitFilter(log, type, values, maxLength) {
 /**
  * Returns a string representing the URL encoded query component of /splitChanges URL.
  *
- * The possible formats of the query string are:
- *  - null: if all filters are empty
- *  - '&names=<comma-separated-values>': if only `byPrefix` filter is undefined
- *  - '&prefixes=<comma-separated-values>': if only `byName` filter is undefined
- *  - '&names=<comma-separated-values>&prefixes=<comma-separated-values>': if no one is undefined
- *
  * @param groupedFilters - object of filters. Each filter must be a list of valid, unique and ordered string values.
  * @returns null or string with the `split filter query` component of the URL.
  */

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -6,7 +6,7 @@ var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
     var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;

package/esm/logger/messages/error.js

@@ -13,7 +13,7 @@ export var codesError = [
     [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock feature flags data. No changes will be applied to the current cache. %s'],
     [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],
     [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],
-    [c.ERROR_HTTP, 'Response status is not OK. Status: %s. URL: %s. Message: %s'],
+    [c.ERROR_HTTP, 'HTTP request failed with %s. URL: %s. Message: %s'],
     // client status
     [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'],
     [c.ERROR_CLIENT_DESTROYED, '%s: Client has already been destroyed - no calls possible.'],

package/esm/sdkClient/sdkClient.js

@@ -35,7 +35,6 @@ export function sdkClientFactory(params, isSharedClient) {
     clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager), 
     // Sdk destroy
     {
-        __ctx: params,
         flush: function () {
             // @TODO define cooldown time
             return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);

package/esm/sdkFactory/index.js

@@ -84,7 +84,8 @@ export function sdkFactory(params) {
         initCallbacks.length = 0;
     }
     log.info(NEW_FACTORY);
-    var factory = objectAssign({
+    // @ts-ignore
+    return objectAssign({
         // Split evaluation and event tracking engine
         client: clientMethod,
         // Manager API to explore available information
@@ -98,14 +99,6 @@ export function sdkFactory(params) {
         destroy: function () {
             hasInit = false;
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
-        },
-        __ctx: ctx
+        }
     }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());
-    // append factory to global
-    if (typeof window === 'object') { // @ts-ignore
-        // eslint-disable-next-line no-undef
-        (window.__HARNESS_FME__ = window.__HARNESS_FME__ || []).push(factory);
-    }
-    // @ts-ignore
-    return factory;
 }

package/esm/services/splitHttpClient.js

@@ -66,7 +66,7 @@ export function splitHttpClientFactory(settings, _a) {
                 msg = error.message || 'Network Error';
             }
             if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else.
-                log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? resp.status : 'NO_STATUS', url, msg]);
+                log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? 'status code ' + resp.status : 'no status code', url, msg]);
             }
             var networkError = new Error(msg);
             // passes `undefined` as statusCode if not an HTTP error (resp === undefined)

package/esm/storages/AbstractMySegmentsCacheSync.js

@@ -20,37 +20,45 @@ var AbstractMySegmentsCacheSync = /** @class */ (function () {
      */
     AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
-        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
+        var isDiff = false;
         if (added && removed) {
-            var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff_1 = _this.addSegment(segment) || isDiff_1;
+                isDiff = _this.addSegment(segment) || isDiff;
             });
             removed.forEach(function (segment) {
-                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
+                isDiff = _this.removeSegment(segment) || isDiff;
             });
-            return isDiff_1;
-        }
-        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
-        var storedSegmentKeys = this.getRegisteredSegments().sort();
-        // Extreme fast => everything is empty
-        if (!names.length && !storedSegmentKeys.length)
-            return false;
-        var index = 0;
-        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
-            index++;
-        // Quick path => no changes
-        if (index === names.length && index === storedSegmentKeys.length)
-            return false;
-        // Slowest path => add and/or remove segments
-        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
-        for (var addIndex = index; addIndex < names.length; addIndex++) {
-            this.addSegment(names[addIndex]);
+        else {
+            var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+            var storedSegmentKeys = this.getRegisteredSegments().sort();
+            // Extreme fast => everything is empty
+            if (!names.length && !storedSegmentKeys.length) {
+                isDiff = false;
+            }
+            else {
+                var index = 0;
+                while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+                    index++;
+                // Quick path => no changes
+                if (index === names.length && index === storedSegmentKeys.length) {
+                    isDiff = false;
+                }
+                else {
+                    // Slowest path => add and/or remove segments
+                    for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+                        this.removeSegment(storedSegmentKeys[removeIndex]);
+                    }
+                    for (var addIndex = index; addIndex < names.length; addIndex++) {
+                        this.addSegment(names[addIndex]);
+                    }
+                    isDiff = true;
+                }
+            }
         }
-        return true;
+        this.setChangeNumber(segmentsData.cn);
+        return isDiff;
     };
     return AbstractMySegmentsCacheSync;
 }());

package/esm/storages/AbstractSplitsCacheSync.js

@@ -9,9 +9,10 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
     }
     AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        this.setChangeNumber(changeNumber);
         var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
+        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
+        this.setChangeNumber(changeNumber);
+        return updated;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;
@@ -65,3 +66,6 @@ export function usesSegments(ruleEntity) {
         return true;
     return false;
 }
+export function usesSegmentsSync(storage) {
+    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+}

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -4,19 +4,20 @@ import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
-    function MySegmentsCacheInLocal(log, keys) {
+    function MySegmentsCacheInLocal(log, keys, storage) {
         var _this = _super.call(this) || this;
         _this.log = log;
         _this.keys = keys;
+        _this.storage = storage;
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
     MySegmentsCacheInLocal.prototype.addSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) === DEFINED)
+            if (this.storage.getItem(segmentKey) === DEFINED)
                 return false;
-            localStorage.setItem(segmentKey, DEFINED);
+            this.storage.setItem(segmentKey, DEFINED);
             return true;
         }
         catch (e) {
@@ -27,9 +28,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) !== DEFINED)
+            if (this.storage.getItem(segmentKey) !== DEFINED)
                 return false;
-            localStorage.removeItem(segmentKey);
+            this.storage.removeItem(segmentKey);
             return true;
         }
         catch (e) {
@@ -38,17 +39,16 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
-        return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+        return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
     };
     MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
-        var _this = this;
-        // Scan current values from localStorage
-        return Object.keys(localStorage).reduce(function (accum, key) {
-            var segmentName = _this.keys.extractSegmentName(key);
+        var registeredSegments = [];
+        for (var i = 0; i < this.storage.length; i++) {
+            var segmentName = this.keys.extractSegmentName(this.storage.key(i));
             if (segmentName)
-                accum.push(segmentName);
-            return accum;
-        }, []);
+                registeredSegments.push(segmentName);
+        }
+        return registeredSegments;
     };
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
@@ -56,9 +56,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
             if (changeNumber)
-                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+                this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
             else
-                localStorage.removeItem(this.keys.buildTillKey());
+                this.storage.removeItem(this.keys.buildTillKey());
         }
         catch (e) {
             this.log.error(e);
@@ -66,7 +66,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     };
     MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = localStorage.getItem(this.keys.buildTillKey());
+        var value = this.storage.getItem(this.keys.buildTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return isNaNNumber(value) ? n : value;