@splitsoftware/splitio-commons 2.1.0 → 2.1.1-rc.1

package/esm/sdkClient/clientInputValidation.js

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational, validateEvaluationOptions } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
@@ -14,7 +14,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
     /**
      * Avoid repeating this validations code
      */
-    function validateEvaluationParams(maybeKey, maybeNameOrNames, maybeAttributes, methodName) {
+    function validateEvaluationParams(methodName, maybeKey, maybeNameOrNames, maybeAttributes, maybeOptions) {
         var key = validateKey(log, maybeKey, methodName);
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             validateFlagSets(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
@@ -23,40 +23,42 @@ export function clientInputValidationDecorator(settings, client, readinessManage
                 validateSplit(log, maybeNameOrNames, methodName);
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
+        var options = validateEvaluationOptions(log, maybeOptions, methodName);
         validateIfOperational(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
             key: key,
             nameOrNames: nameOrNames,
-            attributes: attributes
+            attributes: attributes,
+            options: options
         };
     }
     function wrapResult(value) {
         return isAsync ? Promise.resolve(value) : value;
     }
-    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT);
+    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatment(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult(CONTROL);
         }
     }
-    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT_WITH_CONFIG);
+    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
         }
     }
-    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS);
+    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatments(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             var res_1 = {};
@@ -65,10 +67,10 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return wrapResult(res_1);
         }
     }
-    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS_WITH_CONFIG);
+    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             var res_2 = {};
@@ -77,37 +79,37 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return wrapResult(res_2);
         }
     }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFlagSets, maybeAttributes, GET_TREATMENTS_BY_FLAG_SETS);
+    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult({});
         }
     }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFlagSets, maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
+    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult({});
         }
     }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, [maybeFlagSet], maybeAttributes, GET_TREATMENTS_BY_FLAG_SET);
+    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes);
+            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
         }
         else {
             return wrapResult({});
         }
     }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, [maybeFlagSet], maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
+    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes);
+            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
         }
         else {
             return wrapResult({});

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -6,6 +6,17 @@ import { objectAssign } from '../utils/lang/objectAssign';
 var AbstractSplitsCacheAsync = /** @class */ (function () {
     function AbstractSplitsCacheAsync() {
     }
+    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        return Promise.all([
+            this.setChangeNumber(changeNumber),
+            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
+            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
+        ]).then(function (_a) {
+            var added = _a[1], removed = _a[2];
+            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+        });
+    };
     // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
     // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
     AbstractSplitsCacheAsync.prototype.usesSegments = function () {
@@ -34,7 +45,7 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
                 newSplit.killed = true;
                 newSplit.defaultTreatment = defaultTreatment;
                 newSplit.changeNumber = changeNumber;
-                return _this.addSplit(name, newSplit);
+                return _this.addSplit(newSplit);
             }
             return false;
         }).catch(function () { return false; });

package/esm/storages/AbstractSplitsCacheSync.js

@@ -7,13 +7,11 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 var AbstractSplitsCacheSync = /** @class */ (function () {
     function AbstractSplitsCacheSync() {
     }
-    AbstractSplitsCacheSync.prototype.addSplits = function (entries) {
+    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        return entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); });
-    };
-    AbstractSplitsCacheSync.prototype.removeSplits = function (names) {
-        var _this = this;
-        return names.map(function (name) { return _this.removeSplit(name); });
+        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;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;
@@ -48,7 +46,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
             newSplit.killed = true;
             newSplit.defaultTreatment = defaultTreatment;
             newSplit.changeNumber = changeNumber;
-            return this.addSplit(name, newSplit);
+            return this.addSplit(newSplit);
         }
         return false;
     };

package/esm/storages/KeyBuilder.js

@@ -1,4 +1,3 @@
-import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 var everythingAtTheEnd = /[^.]+$/;
 var DEFAULT_PREFIX = 'SPLITIO';
@@ -22,30 +21,15 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildSplitsTillKey = function () {
         return this.prefix + ".splits.till";
     };
-    // NOT USED
-    // buildSplitsReady() {
-    //   return `${this.prefix}.splits.ready`;
-    // }
-    KeyBuilder.prototype.isSplitKey = function (key) {
-        return startsWith(key, this.prefix + ".split.");
-    };
     KeyBuilder.prototype.buildSplitKeyPrefix = function () {
         return this.prefix + ".split.";
     };
-    // Only used by InLocalStorage.
-    KeyBuilder.prototype.buildSplitsWithSegmentCountKey = function () {
-        return this.prefix + ".splits.usingSegments";
-    };
     KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {
         return this.prefix + ".segment." + segmentName;
     };
     KeyBuilder.prototype.buildSegmentTillKey = function (segmentName) {
         return this.prefix + ".segment." + segmentName + ".till";
     };
-    // NOT USED
-    // buildSegmentsReady() {
-    //   return `${this.prefix}.segments.ready`;
-    // }
     KeyBuilder.prototype.extractKey = function (builtKey) {
         var s = builtKey.match(everythingAtTheEnd);
         if (s && s.length) {

package/esm/storages/KeyBuilderCS.js

@@ -18,7 +18,7 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {
         var prefix = this.prefix + "." + this.matchingKey + ".segment.";
         if (startsWith(builtSegmentKeyName, prefix))
-            return builtSegmentKeyName.substr(prefix.length);
+            return builtSegmentKeyName.slice(prefix.length);
     };
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return this.prefix + ".splits.lastUpdated";
@@ -29,6 +29,12 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.buildTillKey = function () {
         return this.prefix + "." + this.matchingKey + ".segments.till";
     };
+    KeyBuilderCS.prototype.isSplitKey = function (key) {
+        return startsWith(key, this.prefix + ".split.");
+    };
+    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
+        return this.prefix + ".splits.usingSegments";
+    };
     return KeyBuilderCS;
 }(KeyBuilder));
 export { KeyBuilderCS };
@@ -40,7 +46,7 @@ export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
         extractSegmentName: function (builtSegmentKeyName) {
             var p = prefix + "." + matchingKey + ".largeSegment.";
             if (startsWith(builtSegmentKeyName, p))
-                return builtSegmentKeyName.substr(p.length);
+                return builtSegmentKeyName.slice(p.length);
         },
         buildTillKey: function () {
             return prefix + "." + matchingKey + ".largeSegments.till";

package/esm/storages/dataLoader.js

@@ -29,9 +29,8 @@ export function dataLoaderFactory(preloadedData) {
             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(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
+        storage.splits.update(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }), [], since);
         // add mySegments data
         var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -79,9 +79,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         });
         this.hasSync = false;
     };
-    SplitsCacheInLocal.prototype.addSplit = function (name, split) {
+    SplitsCacheInLocal.prototype.addSplit = function (split) {
         try {
-            var splitKey = this.keys.buildSplitKey(name);
+            var name_1 = split.name;
+            var splitKey = this.keys.buildSplitKey(name_1);
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
             localStorage.setItem(splitKey, JSON.stringify(split));
@@ -100,6 +101,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
         try {
             var split = this.getSplit(name);
+            if (!split)
+                return false;
             localStorage.removeItem(this.keys.buildSplitKey(name));
             this._decrementCounts(split);
             if (split)

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -22,7 +22,8 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.changeNumber = -1;
         this.segmentsCount = 0;
     };
-    SplitsCacheInMemory.prototype.addSplit = function (name, split) {
+    SplitsCacheInMemory.prototype.addSplit = function (split) {
+        var name = split.name;
         var previousSplit = this.getSplit(name);
         if (previousSplit) { // We had this Split already
             var previousTtName = previousSplit.trafficTypeName;
@@ -34,40 +35,32 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (usesSegments(previousSplit))
                 this.segmentsCount--;
         }
-        if (split) {
-            // Store the Split.
-            this.splitsCache[name] = split;
-            // Update TT cache
-            var ttName = split.trafficTypeName;
-            this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-            this.addToFlagSets(split);
-            // Add to segments count for the new version of the Split
-            if (usesSegments(split))
-                this.segmentsCount++;
-            return true;
-        }
-        else {
-            return false;
-        }
+        // Store the Split.
+        this.splitsCache[name] = split;
+        // Update TT cache
+        var ttName = split.trafficTypeName;
+        this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+        this.addToFlagSets(split);
+        // Add to segments count for the new version of the Split
+        if (usesSegments(split))
+            this.segmentsCount++;
+        return true;
     };
     SplitsCacheInMemory.prototype.removeSplit = function (name) {
         var split = this.getSplit(name);
-        if (split) {
-            // Delete the Split
-            delete this.splitsCache[name];
-            var ttName = split.trafficTypeName;
-            this.ttCache[ttName]--; // Update tt cache
-            if (!this.ttCache[ttName])
-                delete this.ttCache[ttName];
-            this.removeFromFlagSets(split.name, split.sets);
-            // Update the segments count.
-            if (usesSegments(split))
-                this.segmentsCount--;
-            return true;
-        }
-        else {
+        if (!split)
             return false;
-        }
+        // Delete the Split
+        delete this.splitsCache[name];
+        var ttName = split.trafficTypeName;
+        this.ttCache[ttName]--; // Update tt cache
+        if (!this.ttCache[ttName])
+            delete this.ttCache[ttName];
+        this.removeFromFlagSets(split.name, split.sets);
+        // Update the segments count.
+        if (usesSegments(split))
+            this.segmentsCount--;
+        return true;
     };
     SplitsCacheInMemory.prototype.getSplit = function (name) {
         return this.splitsCache[name] || null;

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -64,8 +64,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., redis operation fails)
      */
-    SplitsCacheInRedis.prototype.addSplit = function (name, split) {
+    SplitsCacheInRedis.prototype.addSplit = function (split) {
         var _this = this;
+        var name = split.name;
         var splitKey = this.keys.buildSplitKey(name);
         return this.redis.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
@@ -89,18 +90,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
         }).then(function () { return true; });
     };
-    /**
-     * Add a list of splits.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., redis operation fails)
-     */
-    SplitsCacheInRedis.prototype.addSplits = function (entries) {
-        var _this = this;
-        return Promise.all(entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); }));
-    };
     /**
      * Remove a given split.
-     * The returned promise is resolved when the operation success, with 1 or 0 indicating if the split existed or not.
+     * The returned promise is resolved when the operation success, with true or false indicating if the split existed (and was removed) or not.
      * or rejected if it fails (e.g., redis operation fails).
      */
     SplitsCacheInRedis.prototype.removeSplit = function (name) {
@@ -110,18 +102,9 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return _this._decrementCounts(split).then(function () { return _this._updateFlagSets(name, split.sets); });
             }
         }).then(function () {
-            return _this.redis.del(_this.keys.buildSplitKey(name));
+            return _this.redis.del(_this.keys.buildSplitKey(name)).then(function (status) { return status === 1; });
         });
     };
-    /**
-     * Remove a list of splits.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., redis operation fails).
-     */
-    SplitsCacheInRedis.prototype.removeSplits = function (names) {
-        var _this = this;
-        return Promise.all(names.map(function (name) { return _this.removeSplit(name); }));
-    };
     /**
      * Get split definition or null if it's not defined.
      * Returned promise is rejected if redis operation fails.

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -51,8 +51,9 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
      * The returned promise is resolved when the operation success
      * or rejected if it fails (e.g., wrapper operation fails)
      */
-    SplitsCachePluggable.prototype.addSplit = function (name, split) {
+    SplitsCachePluggable.prototype.addSplit = function (split) {
         var _this = this;
+        var name = split.name;
         var splitKey = this.keys.buildSplitKey(name);
         return this.wrapper.get(splitKey).then(function (splitFromStorage) {
             // handling parsing error
@@ -76,15 +77,6 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
             }).then(function () { return _this._updateFlagSets(name, parsedPreviousSplit && parsedPreviousSplit.sets, split.sets); });
         }).then(function () { return true; });
     };
-    /**
-     * Add a list of splits.
-     * The returned promise is resolved when the operation success
-     * or rejected if it fails (e.g., wrapper operation fails)
-     */
-    SplitsCachePluggable.prototype.addSplits = function (entries) {
-        var _this = this;
-        return Promise.all(entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); }));
-    };
     /**
      * Remove a given split.
      * The returned promise is resolved when the operation success, with a boolean indicating if the split existed or not.
@@ -100,15 +92,6 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
             return _this.wrapper.del(_this.keys.buildSplitKey(name));
         });
     };
-    /**
-     * Remove a list of splits.
-     * The returned promise is resolved when the operation success, with a boolean array indicating if the splits existed or not.
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SplitsCachePluggable.prototype.removeSplits = function (names) {
-        var _this = this;
-        return Promise.all(names.map(function (name) { return _this.removeSplit(name); }));
-    };
     /**
      * Get split.
      * The returned promise is resolved with the split definition or null if it's not defined,

package/esm/storages/utils.js

@@ -23,6 +23,7 @@ export function impressionsToJSON(impressions, metadata) {
                 c: impression.changeNumber,
                 m: impression.time,
                 pt: impression.pt,
+                properties: impression.properties
             }
         };
         return JSON.stringify(impressionWithMetadata);

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

@@ -23,22 +23,21 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
         if (!loadError && splitsMock) {
             log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
             forOwn(splitsMock, function (val, name) {
-                splits.push([
-                    name, {
-                        name: name,
-                        status: 'ACTIVE',
-                        killed: false,
-                        trafficAllocation: 100,
-                        defaultTreatment: CONTROL,
-                        conditions: val.conditions || [],
-                        configurations: val.configurations,
-                        trafficTypeName: val.trafficTypeName
-                    }
-                ]);
+                // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+                splits.push({
+                    name: name,
+                    status: 'ACTIVE',
+                    killed: false,
+                    trafficAllocation: 100,
+                    defaultTreatment: CONTROL,
+                    conditions: val.conditions || [],
+                    configurations: val.configurations,
+                    trafficTypeName: val.trafficTypeName
+                });
             });
             return Promise.all([
                 splitsCache.clear(),
-                splitsCache.addSplits(splits)
+                splitsCache.update(splits, [], Date.now())
             ]).then(function () {
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -5,5 +5,5 @@ import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }

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

@@ -1,6 +1,6 @@
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
-import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
+import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
@@ -58,13 +58,13 @@ export function computeSplitsMutation(entries, filters) {
     var segments = new Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
-            accum.added.push([split.name, split]);
+            accum.added.push(split);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
             });
         }
         else {
-            accum.removed.push(split.name);
+            accum.removed.push(split);
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
@@ -85,9 +85,10 @@ export function computeSplitsMutation(entries, filters) {
  * @param requestTimeoutBeforeReady -  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady -  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
+    var splits = storage.splits, segments = storage.segments;
     var startingUp = true;
     /** timeout decorator for `splitChangesFetcher` promise  */
     function _promiseDecorator(promise) {
@@ -95,17 +96,6 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
             promise = timeout(requestTimeoutBeforeReady, promise);
         return promise;
     }
-    /** Returns true if at least one split was updated */
-    function isThereUpdate(flagsChange) {
-        var added = flagsChange[1], removed = flagsChange[2];
-        // There is at least one added or modified feature flag
-        if (added && added.some(function (update) { return update; }))
-            return true;
-        // There is at least one removed feature flag
-        if (removed && removed.some(function (update) { return update; }))
-            return true;
-        return false;
-    }
     /**
      * SplitChanges updater returns a promise that resolves with a `false` boolean value if it fails to fetch splits or synchronize them with the storage.
      * Returned promise will not be rejected.
@@ -127,21 +117,17 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 .then(function (splitChanges) {
                 startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
-                log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
-                log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
-                log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);
+                log.debug(SYNC_SPLITS_UPDATE, [mutation.added.length, mutation.removed.length, mutation.segments.length]);
                 // Write into storage
                 // @TODO call `setChangeNumber` only if the other storage operations have succeeded, in order to keep storage consistency
                 return Promise.all([
-                    // calling first `setChangenumber` method, to perform cache flush if split filter queryString changed
-                    splits.setChangeNumber(splitChanges.till),
-                    splits.addSplits(mutation.added),
-                    splits.removeSplits(mutation.removed),
+                    splits.update(mutation.added, mutation.removed, splitChanges.till),
                     segments.registerSegments(mutation.segments)
-                ]).then(function (flagsChange) {
+                ]).then(function (_a) {
+                    var isThereUpdate = _a[0];
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
-                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate(flagsChange) && (isClientSide || checkAllSegmentsExist(segments))))
+                        return Promise.resolve(!splitsEventEmitter.splitsArrived || (since !== splitChanges.till && isThereUpdate && (isClientSide || checkAllSegmentsExist(segments))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
                             // emit SDK events

package/esm/sync/submitters/impressionsSubmitter.js

@@ -19,8 +19,9 @@ export function fromImpressionsCollector(sendLabels, data) {
                     m: entry.time,
                     c: entry.changeNumber,
                     r: sendLabels ? entry.label : undefined,
-                    b: entry.bucketingKey ? entry.bucketingKey : undefined,
-                    pt: entry.pt ? entry.pt : undefined // Previous time
+                    b: entry.bucketingKey,
+                    pt: entry.pt,
+                    properties: entry.properties // Properties
                 };
                 return keyImpression;
             })

package/esm/trackers/strategy/strategyOptimized.js

@@ -9,6 +9,9 @@ import { truncateTimeFrame } from '../../utils/time';
 export function strategyOptimizedFactory(impressionsObserver, impressionCounts) {
     return {
         process: function (impression) {
+            // DEBUG mode without previous time, for impressions with properties
+            if (impression.properties)
+                return true;
             impression.pt = impressionsObserver.testAndSet(impression);
             var now = Date.now();
             // Increments impression counter per featureName

package/esm/utils/inputValidation/eventProperties.js

@@ -57,3 +57,13 @@ export function validateEventProperties(log, maybeProperties, method) {
     }
     return output;
 }
+export function validateEvaluationOptions(log, maybeOptions, method) {
+    if (isObject(maybeOptions)) {
+        var properties = validateEventProperties(log, maybeOptions.properties, method).properties;
+        return properties && Object.keys(properties).length > 0 ? { properties: properties } : undefined;
+    }
+    else if (maybeOptions) {
+        log.error(ERROR_NOT_PLAIN_OBJECT, [method, 'evaluation options']);
+    }
+    return undefined;
+}

package/esm/utils/inputValidation/index.js

@@ -11,3 +11,4 @@ export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validatePreloadedData } from './preloadedData';
+export { validateEvaluationOptions } from './eventProperties';