@splitsoftware/splitio-commons 1.17.1-rc.2 → 2.0.0-rc.0

package/cjs/utils/lang/sets.js

@@ -1,120 +1,13 @@
 "use strict";
-/**
- * Set implementation based on es6-set polyfill (https://github.com/medikoo/es6-set/blob/master/polyfill.js),
- * with the minimal features used by the SDK.
-
-Copyright (C) 2013 Mariusz Nowak (www.medikoo.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-**/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.returnDifference = exports.returnSetsUnion = exports._Set = exports.__getSetConstructor = exports.setToArray = exports.SetPoly = void 0;
-var SetPoly = /** @class */ (function () {
-    // unlike ES6 `Set`, it only accepts an array as first argument iterable
-    function SetPoly(values) {
-        var _this = this;
-        this.__setData__ = [];
-        if (Array.isArray(values))
-            values.forEach(function (value) { _this.add(value); });
-    }
-    SetPoly.prototype.clear = function () {
-        if (!this.__setData__.length)
-            return;
-        this.__setData__.length = 0;
-    };
-    SetPoly.prototype.add = function (value) {
-        if (this.has(value))
-            return this;
-        this.__setData__.push(value);
-        return this;
-    };
-    SetPoly.prototype.delete = function (value) {
-        var index = this.__setData__.indexOf(value);
-        if (index === -1)
-            return false;
-        this.__setData__.splice(index, 1);
-        return true;
-    };
-    SetPoly.prototype.has = function (value) {
-        return this.__setData__.indexOf(value) !== -1;
-    };
-    SetPoly.prototype.forEach = function (callbackfn, thisArg) {
-        if (typeof callbackfn !== 'function')
-            throw new TypeError(callbackfn + ' is not a function');
-        for (var i = 0; i < this.__setData__.length; i++) {
-            var value = this.__setData__[i];
-            callbackfn.call(thisArg, value, value, this);
-        }
-    };
-    Object.defineProperty(SetPoly.prototype, "size", {
-        get: function () {
-            return this.__setData__.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return SetPoly;
-}());
-exports.SetPoly = SetPoly;
-/**
- * return an array containing the items of the given set.
- * @param set Set or SetPoly instance
- */
-function setToArray(set) {
-    if (set instanceof SetPoly) {
-        return set.__setData__.slice();
-    }
-    // if not using SetPoly as set, it means Array.from is supported
-    // eslint-disable-next-line compat/compat
-    return Array.from(set);
-}
-exports.setToArray = setToArray;
-/**
- * return the Set constructor to use. If `Array.from` built-in or native Set is not available or it doesn't support the required features,
- * a ponyfill with minimal features is returned instead.
- *
- * Exported for testing purposes only.
- */
-function __getSetConstructor() {
-    // eslint-disable-next-line compat/compat
-    if (typeof Array.from === 'function' && typeof Set === 'function' && Set.prototype && Set.prototype.values) {
-        return Set;
-    }
-    return SetPoly;
-}
-exports.__getSetConstructor = __getSetConstructor;
-exports._Set = __getSetConstructor();
+exports.returnDifference = exports.returnSetsUnion = void 0;
 function returnSetsUnion(set, set2) {
-    var result = new exports._Set(setToArray(set));
-    set2.forEach(function (value) {
-        result.add(value);
-    });
-    return result;
+    return new Set(Array.from(set).concat(Array.from(set2)));
 }
 exports.returnSetsUnion = returnSetsUnion;
 function returnDifference(list, list2) {
     if (list === void 0) { list = []; }
     if (list2 === void 0) { list2 = []; }
-    var result = new exports._Set(list);
-    list2.forEach(function (item) {
-        result.delete(item);
-    });
-    return setToArray(result);
+    return list.filter(function (item) { return list2.indexOf(item) === -1; });
 }
 exports.returnDifference = returnDifference;

package/cjs/utils/settingsValidation/index.js

@@ -7,7 +7,6 @@ var splitFilters_1 = require("./splitFilters");
 var constants_1 = require("../constants");
 var impressionsMode_1 = require("./impressionsMode");
 var key_1 = require("../inputValidation/key");
-var trafficType_1 = require("../inputValidation/trafficType");
 var constants_2 = require("../../logger/constants");
 // Exported for telemetry
 exports.base = {
@@ -18,8 +17,6 @@ exports.base = {
         authorizationKey: undefined,
         // key used in your system (only required for browser version)
         key: undefined,
-        // traffic type for the given key (only used on browser version)
-        trafficType: undefined,
         // toggle impressions tracking of labels
         labelsEnabled: true,
         // toggle sendind (true) or not sending (false) IP and Host Name with impressions, events, and telemetries requests (only used on nodejs version)
@@ -148,12 +145,6 @@ function settingsValidation(config, validationParams) {
             // @ts-ignore, @TODO handle invalid keys as a non-recoverable error?
             withDefaults.core.key = (0, key_1.validateKey)(log, maybeKey, constants_2.LOG_PREFIX_CLIENT_INSTANTIATION);
         }
-        if (validationParams.acceptTT) {
-            var maybeTT = withDefaults.core.trafficType;
-            if (maybeTT !== undefined) { // @ts-ignore
-                withDefaults.core.trafficType = (0, trafficType_1.validateTrafficType)(log, maybeTT, constants_2.LOG_PREFIX_CLIENT_INSTANTIATION);
-            }
-        }
     }
     else {
         // On server-side, key is undefined and used to distinguish from client-side

package/cjs/utils/settingsValidation/logger/builtinLogger.js

@@ -5,9 +5,8 @@ var logger_1 = require("../../../logger");
 var isLocalStorageAvailable_1 = require("../../env/isLocalStorageAvailable");
 var isNode_1 = require("../../env/isNode");
 var debug_1 = require("../../../logger/messages/debug");
-var maps_1 = require("../../lang/maps");
 var commons_1 = require("./commons");
-var allCodes = new maps_1._Map(debug_1.codesDebug);
+var allCodes = new Map(debug_1.codesDebug);
 // @TODO set default debug setting instead of initialLogLevel when integrating in JS and Node packages
 var LS_KEY = 'splitio_debug';
 var ENV_VAR_KEY = 'SPLITIO_DEBUG';

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

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateStorageCS = void 0;
+exports.validateStorageCS = exports.__InLocalStorageMockFactory = void 0;
 var InMemoryStorageCS_1 = require("../../../storages/inMemory/InMemoryStorageCS");
 var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
+function __InLocalStorageMockFactory(params) {
+    var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
+    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    return result;
+}
+exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;
+__InLocalStorageMockFactory.type = constants_2.STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -20,6 +27,10 @@ function validateStorageCS(settings) {
         storage = InMemoryStorageCS_1.InMemoryStorageCSFactory;
         log.error(constants_1.ERROR_STORAGE_INVALID);
     }
+    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
+    if (mode === constants_2.LOCALHOST_MODE && storage.type === constants_2.STORAGE_LOCALSTORAGE) {
+        return __InLocalStorageMockFactory;
+    }
     if ([constants_2.LOCALHOST_MODE, constants_2.STANDALONE_MODE].indexOf(mode) === -1) {
         // Consumer modes require an async storage
         if (storage.type !== constants_2.STORAGE_PLUGGABLE)

package/esm/evaluator/index.js

@@ -2,7 +2,7 @@ import { Engine } from './Engine';
 import { thenable } from '../utils/promise/thenable';
 import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { setToArray, returnSetsUnion, _Set } from '../utils/lang/sets';
+import { returnSetsUnion } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 var treatmentException = {
     treatment: CONTROL,
@@ -54,7 +54,7 @@ export function evaluateFeatures(log, key, splitNames, attributes, storage) {
 export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
     var storedFlagNames;
     function evaluate(featureFlagsByFlagSets) {
-        var featureFlags = new _Set();
+        var featureFlags = new Set();
         for (var i = 0; i < flagSets.length; i++) {
             var featureFlagByFlagSet = featureFlagsByFlagSets[i];
             if (featureFlagByFlagSet.size) {
@@ -65,7 +65,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
+            evaluateFeatures(log, key, Array.from(featureFlags), attributes, storage) :
             {};
     }
     // get features by flag sets

package/esm/evaluator/matchers/semver_inlist.js

@@ -1,10 +1,9 @@
-import { _Set } from '../../utils/lang/sets';
 import { Semver } from '../../utils/Semver';
 export function inListSemverMatcherContext(ruleAttr) {
     // @TODO ruleAttr validation should be done at the `parser` or `matchersTransform` level to reuse for all matchers
     if (!ruleAttr || ruleAttr.length === 0)
         throw new Error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type');
-    var listOfSemvers = new _Set(ruleAttr.map(function (version) { return new Semver(version).version; }));
+    var listOfSemvers = new Set(ruleAttr.map(function (version) { return new Semver(version).version; }));
     return function inListSemverMatcher(runtimeAttr) {
         var runtimeSemver = new Semver(runtimeAttr).version;
         var isInList = listOfSemvers.has(runtimeSemver);

package/esm/evaluator/matchers/whitelist.js

@@ -1,6 +1,5 @@
-import { _Set } from '../../utils/lang/sets';
 export function whitelistMatcherContext(ruleAttr) {
-    var whitelistSet = new _Set(ruleAttr);
+    var whitelistSet = new Set(ruleAttr);
     return function whitelistMatcher(runtimeAttr) {
         var isInWhitelist = whitelistSet.has(runtimeAttr);
         return isInWhitelist;

package/esm/listeners/browser.js

@@ -97,7 +97,6 @@ var BrowserSignalListener = /** @class */ (function () {
      * Returns true if beacon API was used successfully, false otherwise.
      */
     BrowserSignalListener.prototype._sendBeacon = function (url, data, extraMetadata) {
-        // eslint-disable-next-line compat/compat
         if (typeof navigator !== 'undefined' && navigator.sendBeacon) {
             var json = {
                 entries: data,
@@ -110,7 +109,7 @@ var BrowserSignalListener = /** @class */ (function () {
             // Stringify the payload
             var payload = JSON.stringify(json);
             // https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch
-            try { // eslint-disable-next-line compat/compat
+            try {
                 return navigator.sendBeacon(url, payload);
             }
             catch (e) {

package/esm/logger/browser/DebugLogger.js

@@ -1,6 +1,5 @@
 import { Logger } from '../index';
 import { codesDebug } from '../messages/debug';
-import { _Map } from '../../utils/lang/maps';
 export function DebugLogger() {
-    return new Logger({ logLevel: 'DEBUG' }, new _Map(codesDebug));
+    return new Logger({ logLevel: 'DEBUG' }, new Map(codesDebug));
 }

package/esm/logger/browser/ErrorLogger.js

@@ -1,6 +1,5 @@
 import { Logger } from '../index';
 import { codesError } from '../messages/error';
-import { _Map } from '../../utils/lang/maps';
 export function ErrorLogger() {
-    return new Logger({ logLevel: 'ERROR' }, new _Map(codesError));
+    return new Logger({ logLevel: 'ERROR' }, new Map(codesError));
 }

package/esm/logger/browser/InfoLogger.js

@@ -1,6 +1,5 @@
 import { Logger } from '../index';
 import { codesInfo } from '../messages/info';
-import { _Map } from '../../utils/lang/maps';
 export function InfoLogger() {
-    return new Logger({ logLevel: 'INFO' }, new _Map(codesInfo));
+    return new Logger({ logLevel: 'INFO' }, new Map(codesInfo));
 }

package/esm/logger/browser/WarnLogger.js

@@ -1,6 +1,5 @@
 import { Logger } from '../index';
 import { codesWarn } from '../messages/warn';
-import { _Map } from '../../utils/lang/maps';
 export function WarnLogger() {
-    return new Logger({ logLevel: 'WARN' }, new _Map(codesWarn));
+    return new Logger({ logLevel: 'WARN' }, new Map(codesWarn));
 }

package/esm/logger/index.js

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { find, isObject } from '../utils/lang';
-import { _Map } from '../utils/lang/maps';
 export var LogLevels = {
     DEBUG: 'DEBUG',
     INFO: 'INFO',
@@ -42,7 +41,7 @@ var defaultOptions = {
 var Logger = /** @class */ (function () {
     function Logger(options, codes) {
         this.options = objectAssign({}, defaultOptions, options);
-        this.codes = codes || new _Map();
+        this.codes = codes || new Map();
         this.logLevel = LogLevelIndexes[this.options.logLevel];
     }
     Logger.prototype.setLogLevel = function (logLevel) {

package/esm/sdkClient/clientCS.js

@@ -1,16 +1,15 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { clientAttributesDecoration } from './clientAttributesDecoration';
 /**
- * Decorator that binds a key and (optionally) a traffic type to client methods
+ * Decorator that binds a key to client methods
  *
  * @param client sync client instance
  * @param key validated split key
- * @param trafficType validated traffic type
  */
-export function clientCSDecorator(log, client, key, trafficType) {
+export function clientCSDecorator(log, client, key) {
     var clientCS = clientAttributesDecoration(log, client);
     return objectAssign(clientCS, {
-        // In the client-side API, we bind a key to the client `getTreatment*` methods
+        // In the client-side API, we bind a key to the client `getTreatment*` and `track` methods
         getTreatment: clientCS.getTreatment.bind(clientCS, key),
         getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
         getTreatments: clientCS.getTreatments.bind(clientCS, key),
@@ -19,11 +18,9 @@ export function clientCSDecorator(log, client, key, trafficType) {
         getTreatmentsWithConfigByFlagSets: clientCS.getTreatmentsWithConfigByFlagSets.bind(clientCS, key),
         getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
         getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
-        // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-        track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
+        track: clientCS.track.bind(clientCS, key),
         // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
         isClientSide: true,
-        key: key,
-        trafficType: trafficType
+        key: key
     });
 }

package/esm/sdkClient/sdkClientMethodCS.js

@@ -22,7 +22,7 @@ export function sdkClientMethodCSFactory(params) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
             return mainClientInstance;
         }
-        // Validate the key value. The trafficType (2nd argument) is ignored
+        // Validate the key value
         var validKey = validateKey(log, key, LOG_PREFIX_CLIENT_INSTANTIATION);
         if (validKey === false) {
             throw new Error('Shared Client needs a valid key.');

package/esm/sdkFactory/index.js

@@ -5,7 +5,7 @@ import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -35,10 +35,8 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_ARRIVED);
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         },
-        onReadyFromCacheCb: function () {
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-        }
     });
+    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });

package/esm/services/decorateHeaders.js

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { _Set } from '../utils/lang/sets';
-var FORBIDDEN_HEADERS = new _Set([
+var FORBIDDEN_HEADERS = new Set([
     'splitsdkclientkey',
     'splitsdkversion',
     'splitsdkmachineip',

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -11,6 +11,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/esm/storages/AbstractSplitsCacheSync.js

@@ -27,6 +27,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.

package/esm/storages/KeyBuilderCS.js

@@ -20,12 +20,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
         if (startsWith(builtSegmentKeyName, prefix))
             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.extractOldSegmentKey = function (builtSegmentKeyName) {
-        var prefix = this.matchingKey + "." + this.prefix + ".segment.";
-        if (startsWith(builtSegmentKeyName, prefix))
-            return builtSegmentKeyName.substr(prefix.length);
-    };
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return this.prefix + ".splits.lastUpdated";
     };
@@ -48,9 +42,6 @@ export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
             if (startsWith(builtSegmentKeyName, p))
                 return builtSegmentKeyName.substr(p.length);
         },
-        extractOldSegmentKey: function () {
-            return undefined;
-        },
         buildTillKey: function () {
             return prefix + "." + matchingKey + ".largeSegments.till";
         }

package/esm/storages/dataLoader.js

@@ -1,79 +1,47 @@
-import { setToArray } from '../utils/lang/sets';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../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
  */
-export function loadData(preloadedData, storage, userKey) {
-    // 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) {
+export 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() - 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 (userKey) { // add mySegments data (client-side)
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
+        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 userKeys = segmentsData[segmentName];
-                return userKeys.indexOf(userKey) > -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 userKeys = segmentsData[segmentName];
-            storage.segments.addToSegment(segmentName, userKeys);
-        });
-    }
-}
-export function getSnapshot(storage, userKeys) {
-    return {
-        // lastUpdated: Date.now(),
-        // @ts-ignore accessing private prop
-        since: storage.splits.changeNumber,
-        splitsData: storage.splits.getAll(),
-        segmentsData: userKeys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        mySegmentsData: userKeys ?
-            userKeys.reduce(function (prev, userKey) {
-                // @ts-ignore accessing private prop
-                prev[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
     };
 }

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -45,28 +45,8 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         // Scan current values from localStorage
         return Object.keys(localStorage).reduce(function (accum, key) {
             var segmentName = _this.keys.extractSegmentName(key);
-            if (segmentName) {
+            if (segmentName)
                 accum.push(segmentName);
-            }
-            else {
-                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
-                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)) {
-                            localStorage.setItem(newSegmentKey, DEFINED);
-                            // we are migrating a segment, let's track it.
-                            accum.push(segmentName);
-                        }
-                        localStorage.removeItem(key); // we migrated the current key, let's delete it.
-                    }
-                    catch (e) {
-                        _this.log.error(e);
-                    }
-                }
-            }
             return accum;
         }, []);
     };