@splitsoftware/splitio-commons 2.12.0 → 2.12.2

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -12,7 +12,7 @@ var ImpressionCountsCacheInMemory = /** @class */ (function () {
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
     */
     ImpressionCountsCacheInMemory.prototype._makeKey = function (featureName, timeFrame) {
-        return featureName + "::" + truncateTimeFrame(timeFrame);
+        return "".concat(featureName, "::").concat(truncateTimeFrame(timeFrame));
     };
     /**
     * Increments the quantity of impressions with the passed featureName and timeFrame.

package/esm/storages/inRedis/EventsCacheInRedis.js

@@ -16,7 +16,7 @@ var EventsCacheInRedis = /** @class */ (function () {
             // We use boolean values to signal successful queueing
             .then(function () { return true; })
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error adding event to queue: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error adding event to queue: ").concat(err, "."));
             return false;
         });
     };

package/esm/storages/inRedis/ImpressionCountsCacheInRedis.js

@@ -32,7 +32,7 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
             }
         })
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in impression counts pipeline: ").concat(err, "."));
             return false;
         });
     };
@@ -55,17 +55,17 @@ var ImpressionCountsCacheInRedis = /** @class */ (function (_super) {
             forOwn(counts, function (count, key) {
                 var nameAndTime = key.split('::');
                 if (nameAndTime.length !== 2) {
-                    _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                    _this.log.error("".concat(LOG_PREFIX, "Error spliting key ").concat(key));
                     return;
                 }
                 var timeFrame = parseInt(nameAndTime[1]);
                 if (isNaN(timeFrame)) {
-                    _this.log.error(LOG_PREFIX + "Error parsing time frame " + nameAndTime[1]);
+                    _this.log.error("".concat(LOG_PREFIX, "Error parsing time frame ").concat(nameAndTime[1]));
                     return;
                 }
                 var rawCount = parseInt(count);
                 if (isNaN(rawCount)) {
-                    _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                    _this.log.error("".concat(LOG_PREFIX, "Error parsing raw count ").concat(count));
                     return;
                 }
                 pf.push({

package/esm/storages/inRedis/RedisAdapter.js

@@ -58,9 +58,9 @@ var RedisAdapter = /** @class */ (function () {
         var _this = this;
         this.client.once('ready', function () {
             var commandsCount = _this._notReadyCommandsQueue ? _this._notReadyCommandsQueue.length : 0;
-            _this.log.info(LOG_PREFIX + ("Redis connection established. Queued commands: " + commandsCount + "."));
+            _this.log.info(LOG_PREFIX + "Redis connection established. Queued commands: ".concat(commandsCount, "."));
             _this._notReadyCommandsQueue && _this._notReadyCommandsQueue.forEach(function (queued) {
-                _this.log.info(LOG_PREFIX + ("Executing queued " + queued.name + " command."));
+                _this.log.info(LOG_PREFIX + "Executing queued ".concat(queued.name, " command."));
                 queued.command().then(queued.resolve).catch(queued.reject);
             });
             // After the SDK is ready for the first time we'll stop queueing commands. This is just so we can keep handling BUR for them.
@@ -82,7 +82,7 @@ var RedisAdapter = /** @class */ (function () {
                     params[_i] = arguments[_i];
                 }
                 function commandWrapper() {
-                    instance.log.debug(LOG_PREFIX + "Executing " + methodName + ".");
+                    instance.log.debug("".concat(LOG_PREFIX, "Executing ").concat(methodName, "."));
                     var result = originalMethod.apply(bindTarget, params);
                     if (thenable(result)) {
                         // For handling pending commands on disconnect, add to the set and remove once finished.
@@ -94,7 +94,7 @@ var RedisAdapter = /** @class */ (function () {
                         // Both success and error remove from queue.
                         result.then(cleanUpRunningCommandsCb, cleanUpRunningCommandsCb);
                         return timeout(instance._options.operationTimeout, result).catch(function (err) {
-                            instance.log.error("" + LOG_PREFIX + methodName + " operation threw an error or exceeded configured timeout of " + instance._options.operationTimeout + "ms. Message: " + err);
+                            instance.log.error("".concat(LOG_PREFIX).concat(methodName, " operation threw an error or exceeded configured timeout of ").concat(instance._options.operationTimeout, "ms. Message: ").concat(err));
                             // Handling is not the adapter responsibility.
                             throw err;
                         });
@@ -132,7 +132,7 @@ var RedisAdapter = /** @class */ (function () {
                 }
                 var res = originalFn.apply(instance.client, args);
                 var originalExec = res.exec;
-                res.exec = wrapCommand(originalExec, methodName + ".exec", res);
+                res.exec = wrapCommand(originalExec, "".concat(methodName, ".exec"), res);
                 return res;
             };
         });
@@ -147,14 +147,14 @@ var RedisAdapter = /** @class */ (function () {
             }
             setTimeout(function deferredDisconnect() {
                 if (instance._runningCommands.size > 0) {
-                    instance.log.info(LOG_PREFIX + ("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish."));
+                    instance.log.info(LOG_PREFIX + "Attempting to disconnect but there are ".concat(instance._runningCommands.size, " commands still waiting for resolution. Defering disconnection until those finish."));
                     Promise.all(setToArray(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
                         originalMethod.apply(instance.client, params);
                     })
                         .catch(function (e) {
-                        instance.log.warn(LOG_PREFIX + ("Pending commands finished with error: " + e + ". Proceeding with disconnection."));
+                        instance.log.warn(LOG_PREFIX + "Pending commands finished with error: ".concat(e, ". Proceeding with disconnection."));
                         originalMethod.apply(instance.client, params);
                     });
                 }

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -176,7 +176,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             var e = _a[0], value = _a[1];
             if (e === null)
                 return value;
-            _this.log.error(LOG_PREFIX + ("Could not read result from get members of flag set " + flagSets[index] + " due to an error: " + e));
+            _this.log.error(LOG_PREFIX + "Could not read result from get members of flag set ".concat(flagSets[index], " due to an error: ").concat(e));
         }) : []; })
             .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
@@ -195,13 +195,13 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return false; // if entry doesn't exist, means that TT doesn't exist
             ttCount = parseInt(ttCount, 10);
             if (!isFiniteNumber(ttCount) || ttCount < 0) {
-                _this.log.info(LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to data corruption of some sorts."));
+                _this.log.info(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to data corruption of some sorts."));
                 return false;
             }
             return ttCount > 0;
         })
             .catch(function (e) {
-            _this.log.error(LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to an error: " + e + "."));
+            _this.log.error(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to an error: ").concat(e, "."));
             // If there is an error, bypass the validation so the event can get tracked.
             return true;
         });
@@ -231,7 +231,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
             return Promise.resolve(splits);
         })
             .catch(function (e) {
-            _this.log.error(LOG_PREFIX + ("Could not grab feature flags due to an error: " + e + "."));
+            _this.log.error(LOG_PREFIX + "Could not grab feature flags due to an error: ".concat(e, "."));
             return Promise.reject(e);
         });
     };

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -42,17 +42,17 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(latencies).forEach(function (field) {
                 var parsedField = parseLatencyField(field);
                 if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid latency field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var count = parseInt(latencies[field]);
                 if (isNaNNumber(count)) {
-                    _this.log.error("Ignoring latency with invalid count: " + latencies[field]);
+                    _this.log.error("Ignoring latency with invalid count: ".concat(latencies[field]));
                     return;
                 }
                 var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
                 if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-                    _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                    _this.log.error("Ignoring latency with invalid bucket: ".concat(bucket));
                     return;
                 }
                 var methodLatencies = result.get(metadata) || {};
@@ -74,12 +74,12 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(exceptions).forEach(function (field) {
                 var parsedField = parseExceptionField(field);
                 if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid exception field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var count = parseInt(exceptions[field]);
                 if (isNaNNumber(count)) {
-                    _this.log.error("Ignoring exception with invalid count: " + exceptions[field]);
+                    _this.log.error("Ignoring exception with invalid count: ".concat(exceptions[field]));
                     return;
                 }
                 var metadata = parsedField[0], method = parsedField[1];
@@ -101,7 +101,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
             Object.keys(configs).forEach(function (field) {
                 var parsedField = parseMetadata(field);
                 if (isString(parsedField)) {
-                    _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                    _this.log.error("Ignoring invalid config field: ".concat(field, ": ").concat(parsedField));
                     return;
                 }
                 var metadata = parsedField[0];
@@ -110,7 +110,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
                     result.set(metadata, config);
                 }
                 catch (e) {
-                    _this.log.error("Ignoring invalid config: " + configs[field]);
+                    _this.log.error("Ignoring invalid config: ".concat(configs[field]));
                 }
             });
             return _this.redis.del(_this.keys.initPrefix).then(function () { return result; });

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -38,7 +38,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
             }
         })
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in uniqueKeys pipeline: ").concat(err, "."));
             return false;
         });
     };

package/esm/storages/pluggable/EventsCachePluggable.js

@@ -18,7 +18,7 @@ var EventsCachePluggable = /** @class */ (function () {
             // We use boolean values to signal successful queueing
             .then(function () { return true; })
             .catch(function (e) {
-            _this.log.error(LOG_PREFIX + "Error adding event to queue: " + e + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error adding event to queue: ").concat(e, "."));
             return false;
         });
     };

package/esm/storages/pluggable/ImpressionCountsCachePluggable.js

@@ -21,10 +21,10 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
         if (!keys.length)
             return Promise.resolve(false);
         var pipeline = keys.reduce(function (pipeline, key) {
-            return pipeline.then(function () { return _this.wrapper.incr(_this.key + "::" + key, counts[key]); });
+            return pipeline.then(function () { return _this.wrapper.incr("".concat(_this.key, "::").concat(key), counts[key]); });
         }, Promise.resolve());
         return pipeline.catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in impression counts pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in impression counts pipeline: ").concat(err, "."));
             return false;
         });
     };
@@ -49,18 +49,18 @@ var ImpressionCountsCachePluggable = /** @class */ (function (_super) {
                     var count = counts[i];
                     var keyFeatureNameAndTime = key.split('::');
                     if (keyFeatureNameAndTime.length !== 3) {
-                        _this.log.error(LOG_PREFIX + "Error spliting key " + key);
+                        _this.log.error("".concat(LOG_PREFIX, "Error spliting key ").concat(key));
                         continue;
                     }
                     var timeFrame = parseInt(keyFeatureNameAndTime[2]);
                     if (isNaN(timeFrame)) {
-                        _this.log.error(LOG_PREFIX + "Error parsing time frame " + keyFeatureNameAndTime[2]);
+                        _this.log.error("".concat(LOG_PREFIX, "Error parsing time frame ").concat(keyFeatureNameAndTime[2]));
                         continue;
                     }
                     // @ts-ignore
                     var rawCount = parseInt(count);
                     if (isNaN(rawCount)) {
-                        _this.log.error(LOG_PREFIX + "Error parsing raw count " + count);
+                        _this.log.error("".concat(LOG_PREFIX, "Error parsing raw count ").concat(count));
                         continue;
                     }
                     pf.push({

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -167,12 +167,12 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
                 return false; // if entry doesn't exist, means that TT doesn't exist
             ttCount = parseInt(ttCount, 10);
             if (!isFiniteNumber(ttCount) || ttCount < 0) {
-                _this.log.info(LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to data corruption of some sorts."));
+                _this.log.info(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to data corruption of some sorts."));
                 return false;
             }
             return ttCount > 0;
         }).catch(function (e) {
-            _this.log.error(LOG_PREFIX + ("Could not validate traffic type existence of " + trafficType + " due to an error: " + e + "."));
+            _this.log.error(LOG_PREFIX + "Could not validate traffic type existence of ".concat(trafficType, " due to an error: ").concat(e, "."));
             // If there is an error, bypass the validation so the event can get tracked.
             return true;
         });

package/esm/storages/pluggable/TelemetryCachePluggable.js

@@ -42,18 +42,18 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = latencyKeys[i].split('::')[1];
                         var parsedField = parseLatencyField(field);
                         if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid latency field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid latency field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         // @ts-ignore
                         var count = parseInt(latencies[i]);
                         if (isNaNNumber(count)) {
-                            _this.log.error("Ignoring latency with invalid count: " + latencies[i]);
+                            _this.log.error("Ignoring latency with invalid count: ".concat(latencies[i]));
                             continue;
                         }
                         var metadata = parsedField[0], method = parsedField[1], bucket = parsedField[2];
                         if (bucket >= MAX_LATENCY_BUCKET_COUNT) {
-                            _this.log.error("Ignoring latency with invalid bucket: " + bucket);
+                            _this.log.error("Ignoring latency with invalid bucket: ".concat(bucket));
                             continue;
                         }
                         var methodLatencies = result.get(metadata) || {};
@@ -81,13 +81,13 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = exceptionKeys[i].split('::')[1];
                         var parsedField = parseExceptionField(field);
                         if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid exception field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid exception field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         // @ts-ignore
                         var count = parseInt(exceptions[i]);
                         if (isNaNNumber(count)) {
-                            _this.log.error("Ignoring exception with invalid count: " + exceptions[i]);
+                            _this.log.error("Ignoring exception with invalid count: ".concat(exceptions[i]));
                             continue;
                         }
                         var metadata = parsedField[0], method = parsedField[1];
@@ -115,7 +115,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                         var field = configKeys[i].split('::')[1];
                         var parsedField = parseMetadata(field);
                         if (isString(parsedField)) {
-                            _this.log.error("Ignoring invalid config field: " + field + ": " + parsedField);
+                            _this.log.error("Ignoring invalid config field: ".concat(field, ": ").concat(parsedField));
                             continue;
                         }
                         var metadata = parsedField[0];
@@ -124,7 +124,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                             result.set(metadata, config);
                         }
                         catch (e) {
-                            _this.log.error("Ignoring invalid config: " + configs[i]);
+                            _this.log.error("Ignoring invalid config: ".concat(configs[i]));
                         }
                     }
                     return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -32,7 +32,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         this.clear();
         return this.wrapper.pushItems(this.key, uniqueKeysArray)
             .catch(function (err) {
-            _this.log.error(LOG_PREFIX + "Error in uniqueKeys pipeline: " + err + ".");
+            _this.log.error("".concat(LOG_PREFIX, "Error in uniqueKeys pipeline: ").concat(err, "."));
             return false;
         });
     };

package/esm/storages/pluggable/index.js

@@ -35,7 +35,7 @@ function validatePluggableStorageOptions(options) {
     var wrapper = options.wrapper;
     var missingMethods = METHODS_TO_PROMISE_WRAP.filter(function (method) { return typeof wrapper[method] !== 'function'; });
     if (missingMethods.length)
-        throw new Error(NO_VALID_WRAPPER_INTERFACE + " The following methods are missing or invalid: " + missingMethods);
+        throw new Error("".concat(NO_VALID_WRAPPER_INTERFACE, " The following methods are missing or invalid: ").concat(missingMethods));
 }
 // Async return type in `client.track` method on consumer partial mode
 // No need to promisify impressions cache
@@ -79,7 +79,7 @@ export function PluggableStorage(options) {
                     var currentHash = getStorageHash(settings);
                     if (hash !== currentHash) {
                         log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                        return wrapper.getKeysByPrefix("".concat(keys.prefix, ".")).then(function (storageKeys) {
                             return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
                         }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
                     }

package/esm/storages/pluggable/wrapperAdapter.js

@@ -31,7 +31,7 @@ export function wrapperAdapter(log, wrapper) {
     METHODS_TO_PROMISE_WRAP.forEach(function (method) {
         // Logs error and wraps it into a rejected promise.
         function handleError(e) {
-            log.error(LOG_PREFIX + " Wrapper '" + method + "' operation threw an error. Message: " + e);
+            log.error("".concat(LOG_PREFIX, " Wrapper '").concat(method, "' operation threw an error. Message: ").concat(e));
             return Promise.reject(e);
         }
         wrapperAdapter[method] = function () {

package/esm/storages/setRolloutPlan.js

@@ -22,14 +22,14 @@ export function validateRolloutPlan(log, settings) {
 export function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
     var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
     var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
-    log.debug("storage: set feature flags and segments" + (matchingKey ? " for key " + matchingKey : ''));
+    log.debug("storage: set feature flags and segments".concat(matchingKey ? " for key ".concat(matchingKey) : ''));
     if (splits && ff) {
         splits.clear();
-        splits.update(ff.d, [], ff.t);
+        splits.update(ff.d || [], [], ff.t);
     }
     if (rbSegments && rbs) {
         rbSegments.clear();
-        rbSegments.update(rbs.d, [], rbs.t);
+        rbSegments.update(rbs.d || [], [], rbs.t);
     }
     var segmentChanges = rolloutPlan.segmentChanges;
     if (matchingKey) { // add memberships data (client-side)

package/esm/storages/utils.js

@@ -37,30 +37,30 @@ var REVERSE_METHOD_NAMES = Object.keys(METHOD_NAMES).reduce(function (acc, key)
 export function parseMetadata(field) {
     var parts = field.split('/');
     if (parts.length !== 3)
-        return "invalid subsection count. Expected 3, got: " + parts.length;
+        return "invalid subsection count. Expected 3, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */;
     return [JSON.stringify({ s: s, n: n, i: i })];
 }
 export function parseExceptionField(field) {
     var parts = field.split('/');
     if (parts.length !== 4)
-        return "invalid subsection count. Expected 4, got: " + parts.length;
+        return "invalid subsection count. Expected 4, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3];
     var method = REVERSE_METHOD_NAMES[m];
     if (!method)
-        return "unknown method '" + m + "'";
+        return "unknown method '".concat(m, "'");
     return [JSON.stringify({ s: s, n: n, i: i }), method];
 }
 export function parseLatencyField(field) {
     var parts = field.split('/');
     if (parts.length !== 5)
-        return "invalid subsection count. Expected 5, got: " + parts.length;
+        return "invalid subsection count. Expected 5, got: ".concat(parts.length);
     var s = parts[0] /* metadata.s */, n = parts[1] /* metadata.n */, i = parts[2] /* metadata.i */, m = parts[3], b = parts[4];
     var method = REVERSE_METHOD_NAMES[m];
     if (!method)
-        return "unknown method '" + m + "'";
+        return "unknown method '".concat(m, "'");
     var bucket = parseInt(b);
     if (isNaN(bucket) || bucket >= MAX_LATENCY_BUCKET_COUNT)
-        return "invalid bucket. Expected a number between 0 and " + (MAX_LATENCY_BUCKET_COUNT - 1) + ", got: " + b;
+        return "invalid bucket. Expected a number between 0 and ".concat(MAX_LATENCY_BUCKET_COUNT - 1, ", got: ").concat(b);
     return [JSON.stringify({ s: s, n: n, i: i }), method, bucket];
 }

package/esm/sync/offline/splitsParser/parseCondition.js

@@ -23,7 +23,7 @@ export function parseCondition(data) {
                     size: 100
                 }
             ],
-            label: "whitelisted " + treatment
+            label: "whitelisted ".concat(treatment)
         };
     }
     else {

package/esm/sync/polling/pollingManagerSS.js

@@ -15,8 +15,8 @@ export function pollingManagerSSFactory(params) {
         // Start periodic fetching (polling)
         start: function () {
             log.info(POLLING_START);
-            log.debug(LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
-            log.debug(LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
+            log.debug(LOG_PREFIX_SYNC_POLLING + "Splits will be refreshed each ".concat(settings.scheduler.featuresRefreshRate, " millis"));
+            log.debug(LOG_PREFIX_SYNC_POLLING + "Segments will be refreshed each ".concat(settings.scheduler.segmentsRefreshRate, " millis"));
             var startingUp = splitsSyncTask.start();
             if (startingUp) {
                 startingUp.then(function () {

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

@@ -20,7 +20,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         return promise;
     }
     function updateSegment(segmentName, noCache, till, fetchOnlyNew, retries) {
-        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
+        log.debug("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Processing segment ").concat(segmentName));
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
@@ -28,14 +28,14 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 false :
                 segmentChangesFetcher(since || -1, segmentName, noCache, till, _promiseDecorator).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
-                        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+                        log.debug("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Processing ").concat(segmentName, " with till = ").concat(x.till, ". Added: ").concat(x.added.length, ". Removed: ").concat(x.removed.length));
                         return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });
                 }).catch(function (error) {
                     if (retries) {
-                        log.warn(LOG_PREFIX_SYNC_SEGMENTS + "Retrying fetch of segment " + segmentName + " (attempt #" + retries + "). Reason: " + error);
+                        log.warn("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Retrying fetch of segment ").concat(segmentName, " (attempt #").concat(retries, "). Reason: ").concat(error));
                         return updateSegment(segmentName, noCache, till, fetchOnlyNew, retries - 1);
                     }
                     throw error;
@@ -54,7 +54,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
      * @param till - till target for the provided segmentName, for CDN bypass.
      */
     return function segmentChangesUpdater(fetchOnlyNew, segmentName, noCache, till) {
-        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Started segments update");
+        log.debug("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Started segments update"));
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
@@ -81,10 +81,10 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 // @TODO although factory status is destroyed, synchronization is not stopped
                 if (readiness)
                     readiness.setDestroyed();
-                log.error(LOG_PREFIX_INSTANTIATION + ": you passed a client-side type authorizationKey, please grab an SDK Key from the Split user interface that is of type server-side.");
+                log.error("".concat(LOG_PREFIX_INSTANTIATION, ": you passed a client-side type authorizationKey, please grab an SDK Key from Harness FME UI that is of type server-side."));
             }
             else {
-                log.warn(LOG_PREFIX_SYNC_SEGMENTS + "Error while doing fetch of segments. " + error);
+                log.warn("".concat(LOG_PREFIX_SYNC_SEGMENTS, "Error while doing fetch of segments. ").concat(error));
             }
             return false;
         });

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

@@ -21,7 +21,7 @@ function checkAllSegmentsExist(segments) {
  */
 export function parseSegments(ruleEntity, matcherType) {
     if (matcherType === void 0) { matcherType = IN_SEGMENT; }
-    var _a = ruleEntity, _b = _a.conditions, conditions = _b === void 0 ? [] : _b, excluded = _a.excluded;
+    var _a = ruleEntity, conditions = _a.conditions, excluded = _a.excluded;
     var segments = new Set();
     if (excluded && excluded.segments) {
         excluded.segments.forEach(function (_a) {
@@ -31,12 +31,14 @@ export function parseSegments(ruleEntity, matcherType) {
             }
         });
     }
-    for (var i = 0; i < conditions.length; i++) {
-        var matchers = conditions[i].matcherGroup.matchers;
-        matchers.forEach(function (matcher) {
-            if (matcher.matcherType === matcherType)
-                segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
-        });
+    if (conditions) {
+        for (var i = 0; i < conditions.length; i++) {
+            var matchers = conditions[i].matcherGroup.matchers;
+            matchers.forEach(function (matcher) {
+                if (matcher.matcherType === matcherType)
+                    segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+            });
+        }
     }
     return segments;
 }
@@ -66,7 +68,7 @@ function matchFilters(featureFlag, filters) {
  */
 export function computeMutation(rules, segments, filters) {
     return rules.reduce(function (accum, ruleEntity) {
-        if (ruleEntity.status === 'ACTIVE' && (!filters || matchFilters(ruleEntity, filters))) {
+        if (ruleEntity.status !== 'ARCHIVED' && (!filters || matchFilters(ruleEntity, filters))) {
             accum.added.push(ruleEntity);
             parseSegments(ruleEntity).forEach(function (segmentName) {
                 segments.add(segmentName);
@@ -135,14 +137,14 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                 var updatedFlags = [];
                 var ffUpdate = false;
                 if (splitChanges.ff) {
-                    var _a = computeMutation(splitChanges.ff.d, usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
+                    var _a = computeMutation(splitChanges.ff.d || [], usedSegments, splitFiltersValidation), added = _a.added, removed = _a.removed, names = _a.names;
                     updatedFlags = names;
                     log.debug(SYNC_SPLITS_UPDATE, [added.length, removed.length]);
                     ffUpdate = splits.update(added, removed, splitChanges.ff.t);
                 }
                 var rbsUpdate = false;
                 if (splitChanges.rbs) {
-                    var _b = computeMutation(splitChanges.rbs.d, usedSegments), added = _b.added, removed = _b.removed;
+                    var _b = computeMutation(splitChanges.rbs.d || [], usedSegments), added = _b.added, removed = _b.removed;
                     log.debug(SYNC_RBS_UPDATE, [added.length, removed.length]);
                     rbsUpdate = rbSegments.update(added, removed, splitChanges.rbs.t);
                 }

package/esm/sync/streaming/SSEClient/index.js

@@ -57,11 +57,11 @@ var SSEClient = /** @class */ (function () {
             var params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
             return encodeURIComponent(params + channel);
         }).join(',');
-        var url = this.settings.urls.streaming + "/sse?channels=" + channelsQueryParam + "&accessToken=" + authToken.token + "&v=" + ABLY_API_VERSION + "&heartbeats=true"; // same results using `&heartbeats=false`
+        var url = "".concat(this.settings.urls.streaming, "/sse?channels=").concat(channelsQueryParam, "&accessToken=").concat(authToken.token, "&v=").concat(ABLY_API_VERSION, "&heartbeats=true"); // same results using `&heartbeats=false`
         var isServerSide = checkIfServerSide(this.settings);
         this.connection = new this.eventSource(
         // For client-side SDKs, metadata is passed as query param to avoid CORS issues and because native EventSource implementations in browsers do not support headers
-        isServerSide ? url : url + ("&SplitSDKVersion=" + this.headers.SplitSDKVersion + "&SplitSDKClientKey=" + this.headers.SplitSDKClientKey), 
+        isServerSide ? url : url + "&SplitSDKVersion=".concat(this.headers.SplitSDKVersion, "&SplitSDKClientKey=").concat(this.headers.SplitSDKClientKey), 
         // For server-side SDKs, metadata is passed via headers
         objectAssign(isServerSide ?
             { headers: decorateHeaders(this.settings, this.headers) } :

package/esm/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -48,7 +48,7 @@ export function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemet
                             telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
                         var attempts = backoff.attempts + 1;
                         if (maxChangeNumber <= currentChangeNumber) {
-                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            log.debug("Refresh completed".concat(cdnBypass ? ' bypassing the CDN' : '', " in ").concat(attempts, " attempts."));
                             isHandlingEvent = false;
                             return;
                         }
@@ -57,7 +57,7 @@ export function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemet
                             return;
                         }
                         if (cdnBypass) {
-                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            log.debug("No changes fetched after ".concat(attempts, " attempts with CDN bypassed."));
                             isHandlingEvent = false;
                         }
                         else {

package/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -25,7 +25,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
                     else {
                         var attempts = backoff.attempts + 1;
                         if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
-                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            log.debug("Refresh completed".concat(cdnBypass ? ' bypassing the CDN' : '', " in ").concat(attempts, " attempts."));
                             isHandlingEvent = false;
                             return;
                         }
@@ -34,7 +34,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
                             return;
                         }
                         if (cdnBypass) {
-                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            log.debug("No changes fetched after ".concat(attempts, " attempts with CDN bypassed."));
                             isHandlingEvent = false;
                         }
                         else {