@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.5

package/cjs/sdkFactory/index.js

@@ -19,20 +19,13 @@ var constants_3 = require("../utils/constants");
  * Modular SDK factory
  */
 function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, isPure = params.isPure;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory;
     var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // initialization
-    var isInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (isInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
-    var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(platform.EventEmitter, settings);
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
+    var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
         settings: settings,
@@ -45,11 +38,8 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
-        onReadyFromCacheCb: function () {
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
-        }
     });
-    var clients = {};
+    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
@@ -65,11 +55,11 @@ function sdkFactory(params) {
         default:
             strategy = (0, strategyDebug_1.strategyDebugFactory)(observer);
     }
-    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = (0, impressionsTracker_1.impressionsTrackerFactory)(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+    var eventTracker = (0, eventTracker_1.eventTrackerFactory)(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, whenInit: whenInit };
+    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -77,22 +67,8 @@ function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    function init() {
-        if (isInit)
-            return;
-        isInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
-        readiness.init();
-        storage.init && storage.init();
-        uniqueKeysTracker && uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
-    }
-    if (!isPure)
-        init();
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
     log.info(constants_1.NEW_FACTORY);
     // @ts-ignore
     return (0, objectAssign_1.objectAssign)({
@@ -106,9 +82,6 @@ function sdkFactory(params) {
         // Logger wrapper API
         Logger: (0, sdkLogger_1.createLoggerAPI)(log),
         settings: settings,
-        destroy: function () {
-            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
-        }
-    }, extraProps && extraProps(ctx), isPure && { init: init });
+    }, extraProps && extraProps(ctx));
 }
 exports.sdkFactory = sdkFactory;

package/cjs/services/decorateHeaders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decorateHeaders = void 0;
+exports.removeNonISO88591 = exports.decorateHeaders = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var sets_1 = require("../utils/lang/sets");
 var FORBIDDEN_HEADERS = new sets_1._Set([
@@ -34,3 +34,8 @@ function decorateHeaders(settings, headers) {
     return headers;
 }
 exports.decorateHeaders = decorateHeaders;
+function removeNonISO88591(input) {
+    // eslint-disable-next-line no-control-regex
+    return input.replace(/[^\x00-\xFF]/g, '');
+}
+exports.removeNonISO88591 = removeNonISO88591;

package/cjs/services/splitApi.js

@@ -54,15 +54,15 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SEGMENT));
         },
-        fetchMemberships: function (userMatchingKey, noCache, till) {
+        fetchMySegments: function (userMatchingKey, noCache) {
             /**
              * URI encoding of user keys in order to:
-             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-             *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
+             *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
+             *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MEMBERSHIPS));
+            var url = urls.sdk + "/mySegments/" + encodeURIComponent(userMatchingKey);
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MY_SEGMENT));
         },
         /**
          * Post events.

package/cjs/services/splitHttpClient.js

@@ -4,6 +4,8 @@ exports.splitHttpClientFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../logger/constants");
 var decorateHeaders_1 = require("./decorateHeaders");
+var timeout_1 = require("../utils/promise/timeout");
+var PENDING_FETCH_ERROR_TIMEOUT = 100;
 var messageNoFetch = 'Global fetch API is not available.';
 /**
  * Factory of Split HTTP clients, which are HTTP clients with predefined headers for Split endpoints.
@@ -28,7 +30,7 @@ function splitHttpClientFactory(settings, _a) {
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
-        commonHeaders['SplitSDKMachineName'] = hostname;
+        commonHeaders['SplitSDKMachineName'] = (0, decorateHeaders_1.removeNonISO88591)(hostname);
     return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
@@ -43,7 +45,8 @@ function splitHttpClientFactory(settings, _a) {
             // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
             .then(function (response) {
             if (!response.ok) {
-                return response.text().then(function (message) { return Promise.reject({ response: response, message: message }); });
+                // `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
+                return (0, timeout_1.timeout)(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(function (message) { return Promise.reject({ response: response, message: message }); }, function () { return Promise.reject({ response: response }); });
             }
             latencyTracker();
             return response;

package/cjs/storages/AbstractSegmentsCacheSync.js

@@ -8,55 +8,26 @@ exports.AbstractSegmentsCacheSync = void 0;
 var AbstractSegmentsCacheSync = /** @class */ (function () {
     function AbstractSegmentsCacheSync() {
     }
-    /**
-     * clear the cache.
-     */
-    AbstractSegmentsCacheSync.prototype.clear = function () {
-        this.resetSegments({});
-    };
     /**
      * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
      * For client-side synchronizer: the method is not used.
      */
     AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
+    /**
+     * For server-side synchronizer: set the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.setChangeNumber = function (name, changeNumber) { return true; };
+    /**
+     * For server-side synchronizer: get the change number of `name` segment.
+     * For client-side synchronizer: the method is not used.
+     */
+    AbstractSegmentsCacheSync.prototype.getChangeNumber = function (name) { return -1; };
     /**
      * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: it resets or updates the cache.
+     * For client-side synchronizer: reset the cache with the given list of segments.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
-        var _this = this;
-        this.setChangeNumber(undefined, segmentsData.cn);
-        var _a = segmentsData, added = _a.added, removed = _a.removed;
-        if (added && removed) {
-            var isDiff_1 = false;
-            added.forEach(function (segment) {
-                isDiff_1 = _this.addToSegment(segment) || isDiff_1;
-            });
-            removed.forEach(function (segment) {
-                isDiff_1 = _this.removeFromSegment(segment) || isDiff_1;
-            });
-            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.removeFromSegment(storedSegmentKeys[removeIndex]);
-        }
-        for (var addIndex = index; addIndex < names.length; addIndex++) {
-            this.addToSegment(names[addIndex]);
-        }
-        return true;
-    };
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (names) { return true; };
     return AbstractSegmentsCacheSync;
 }());
 exports.AbstractSegmentsCacheSync = AbstractSegmentsCacheSync;

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -14,6 +14,13 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.usesSegments = function () {
         return Promise.resolve(true);
     };
+    /**
+     * Check if the splits information is already stored in cache.
+     * Noop, just keeping the interface. This is used by client-side implementations only.
+     */
+    AbstractSplitsCacheAsync.prototype.checkCache = function () {
+        return Promise.resolve(false);
+    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -30,6 +30,13 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
         var _this = this;
         return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
     };
+    /**
+     * Check if the splits information is already stored in cache. This data can be preloaded.
+     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+     */
+    AbstractSplitsCacheSync.prototype.checkCache = function () {
+        return false;
+    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.
@@ -63,8 +70,7 @@ function usesSegments(split) {
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         for (var j = 0; j < matchers.length; j++) {
-            var matcher = matchers[j].matcherType;
-            if (matcher === constants_1.IN_SEGMENT || matcher === constants_1.IN_LARGE_SEGMENT)
+            if (matchers[j].matcherType === constants_1.IN_SEGMENT)
                 return true;
         }
     }

package/cjs/storages/KeyBuilderCS.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.myLargeSegmentsKeyBuilder = exports.KeyBuilderCS = void 0;
+exports.KeyBuilderCS = void 0;
 var tslib_1 = require("tslib");
 var lang_1 = require("../utils/lang");
 var KeyBuilder_1 = require("./KeyBuilder");
@@ -24,6 +24,10 @@ var KeyBuilderCS = /** @class */ (function (_super) {
             return builtSegmentKeyName.substr(prefix.length);
     };
     // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
+    KeyBuilderCS.prototype.buildOldSegmentNameKey = function (segmentName) {
+        return this.matchingKey + "." + this.prefix + ".segment." + segmentName;
+    };
+    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
     KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
         var prefix = this.matchingKey + "." + this.prefix + ".segment.";
         if ((0, lang_1.startsWith)(builtSegmentKeyName, prefix))
@@ -35,28 +39,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
         return this.regexSplitsCacheKey.test(key);
     };
-    KeyBuilderCS.prototype.buildTillKey = function () {
-        return this.prefix + "." + this.matchingKey + ".segments.till";
-    };
     return KeyBuilderCS;
 }(KeyBuilder_1.KeyBuilder));
 exports.KeyBuilderCS = KeyBuilderCS;
-function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
-    return {
-        buildSegmentNameKey: function (segmentName) {
-            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
-        },
-        extractSegmentName: function (builtSegmentKeyName) {
-            var p = prefix + "." + matchingKey + ".largeSegment.";
-            if ((0, lang_1.startsWith)(builtSegmentKeyName, p))
-                return builtSegmentKeyName.substr(p.length);
-        },
-        extractOldSegmentKey: function () {
-            return undefined;
-        },
-        buildTillKey: function () {
-            return prefix + "." + matchingKey + ".largeSegments.till";
-        }
-    };
-}
-exports.myLargeSegmentsKeyBuilder = myLargeSegmentsKeyBuilder;

package/cjs/storages/dataLoader.js

@@ -1,83 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSnapshot = exports.loadData = void 0;
-var sets_1 = require("../utils/lang/sets");
-var key_1 = require("../utils/key");
+exports.dataLoaderFactory = void 0;
+var browser_1 = require("../utils/constants/browser");
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side storage loader
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
- * @param storage object containing `splits` and `segments` cache (client-side variant)
- * @param userKey user key (matching key) of the provided MySegmentsCache
- *
- * @TODO extend to load largeSegments
- * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
- * @TODO add logs, and input validation in this module, in favor of size reduction.
- * @TODO unit tests
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
+ * and extended with a `mySegmentsData` property.
+ * @returns function to preload the storage
  */
-function loadData(preloadedData, storage, matchingKey) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0)
-        return;
-    var _a = preloadedData.segmentsData, segmentsData = _a === void 0 ? {} : _a, _b = preloadedData.since, since = _b === void 0 ? -1 : _b, _c = preloadedData.splitsData, splitsData = _c === void 0 ? [] : _c;
-    if (storage.splits) {
+function dataLoaderFactory(preloadedData) {
+    /**
+     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+     *
+     * @param storage object containing `splits` and `segments` cache (client-side variant)
+     * @param userId user key string of the provided MySegmentsCache
+     *
+     * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
+     * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+     */
+    return function loadData(storage, userId) {
+        // Do not load data if current preloadedData is empty
+        if (Object.keys(preloadedData).length === 0)
+            return;
+        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
         var storedSince = storage.splits.getChangeNumber();
-        // Do not load data if current data is more recent
-        if (storedSince > since)
+        var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
+        // Do not load data if current localStorage data is more recent,
+        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+        if (storedSince > since || lastUpdated < expirationTimestamp)
             return;
         // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
         storage.splits.clear();
         storage.splits.setChangeNumber(since);
         // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
-    }
-    if (matchingKey) { // add mySegments data (client-side)
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
+        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
+        // add mySegments data
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {
             // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
             mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var matchingKeys = segmentsData[segmentName];
-                return matchingKeys.indexOf(matchingKey) > -1;
+                var userIds = JSON.parse(segmentsData[segmentName]).added;
+                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
-    }
-    else { // add segments data (server-side)
-        Object.keys(segmentsData).filter(function (segmentName) {
-            var matchingKeys = segmentsData[segmentName];
-            storage.segments.addToSegment(segmentName, matchingKeys);
-        });
-    }
-}
-exports.loadData = loadData;
-function getSnapshot(storage, userKeys) {
-    return {
-        // lastUpdated: Date.now(),
-        since: storage.splits.getChangeNumber(),
-        splitsData: storage.splits.getAll(),
-        segmentsData: userKeys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = (0, sets_1.setToArray)(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        mySegmentsData: userKeys ?
-            userKeys.reduce(function (prev, userKey) {
-                prev[(0, key_1.getMatching)(userKey)] = storage.shared ?
-                    // Client-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.shared(userKey).segments.segmentCache) :
-                    // Server-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
-                        return storage.segments.segmentCache[segmentName].has(userKey) ?
-                            prev.concat(segmentName) :
-                            prev;
-                    }, []);
-                return prev;
-            }, {}) :
-            undefined
+        storage.segments.resetSegments(mySegmentsData);
     };
 }
-exports.getSnapshot = getSnapshot;
+exports.dataLoaderFactory = dataLoaderFactory;

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsCacheInLocal = void 0;
 var tslib_1 = require("tslib");
-var lang_1 = require("../../utils/lang");
 var AbstractSegmentsCacheSync_1 = require("../AbstractSegmentsCacheSync");
 var constants_1 = require("./constants");
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
@@ -14,11 +13,19 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
+    /**
+     * Removes list of segments from localStorage
+     * @NOTE this method is not being used at the moment.
+     */
+    MySegmentsCacheInLocal.prototype.clear = function () {
+        this.log.info(constants_1.LOG_PREFIX + 'Flushing MySegments data from localStorage');
+        // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
+        // We could optimize next sentence, since it implies iterating over all localStorage items
+        this.resetSegments([]);
+    };
     MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) === constants_1.DEFINED)
-                return false;
             localStorage.setItem(segmentKey, constants_1.DEFINED);
             return true;
         }
@@ -30,8 +37,6 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (localStorage.getItem(segmentKey) !== constants_1.DEFINED)
-                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -43,22 +48,30 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === constants_1.DEFINED;
     };
-    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     *
+     * @param {string[]} segmentNames list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInLocal.prototype.resetSegments = function (names) {
         var _this = this;
+        var isDiff = false;
+        var index;
         // Scan current values from localStorage
-        return Object.keys(localStorage).reduce(function (accum, key) {
+        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
             var segmentName = _this.keys.extractSegmentName(key);
             if (segmentName) {
                 accum.push(segmentName);
             }
             else {
-                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
+                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
                 segmentName = _this.keys.extractOldSegmentKey(key);
                 if (segmentName) { // this was an old segment key, let's clean up.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
                     try {
                         // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey)) {
+                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
                             localStorage.setItem(newSegmentKey, constants_1.DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -72,29 +85,39 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             }
             return accum;
         }, []);
-    };
-    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
-        return 1;
-    };
-    MySegmentsCacheInLocal.prototype.setChangeNumber = function (name, changeNumber) {
-        try {
-            if (changeNumber)
-                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            else
-                localStorage.removeItem(this.keys.buildTillKey());
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentNames.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentNames.length !== names.length) {
+            isDiff = true;
+            storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
+            names.forEach(function (name) { return _this.addToSegment(name); });
         }
-        catch (e) {
-            this.log.error(e);
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
+                names.forEach(function (name) { return _this.addToSegment(name); });
+            }
         }
+        return isDiff;
     };
-    MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
-        var n = -1;
-        var value = localStorage.getItem(this.keys.buildTillKey());
-        if (value !== null) {
-            value = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(value) ? n : value;
-        }
-        return n;
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
+        var _this = this;
+        return Object.keys(localStorage).reduce(function (accum, key) {
+            var segmentName = _this.keys.extractSegmentName(key);
+            if (segmentName)
+                accum.push(segmentName);
+            return accum;
+        }, []);
+    };
+    MySegmentsCacheInLocal.prototype.getKeysCount = function () {
+        return 1;
     };
     return MySegmentsCacheInLocal;
 }(AbstractSegmentsCacheSync_1.AbstractSegmentsCacheSync));

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -186,6 +186,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         }
     };
+    /**
+     * Check if the splits information is already stored in browser LocalStorage.
+     * In this function we could add more code to check if the data is valid.
+     * @override
+     */
+    SplitsCacheInLocal.prototype.checkCache = function () {
+        return this.getChangeNumber() > -1;
+    };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *
@@ -208,7 +216,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
                 // if there is cache, clear it
-                if (this.getChangeNumber() > -1)
+                if (this.checkCache())
                     this.clear();
             }
             catch (e) {