@splitsoftware/splitio-commons 2.11.1-rc.2 → 3.0.0-rc.0

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/RBSegmentsCachePluggable.js

@@ -31,7 +31,7 @@ var RBSegmentsCachePluggable = /** @class */ (function () {
                 return _this.wrapper.set(key, stringifiedNewRBSegment).then(function () { return true; });
             })),
             Promise.all(toRemove.map(function (toRemove) {
-                var key = _this.keys.buildRBSegmentKey(toRemove.name);
+                var key = _this.keys.buildRBSegmentKey(toRemove);
                 return _this.wrapper.del(key);
             }))
         ]).then(function (_a) {

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,7 +22,7 @@ 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);

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/fetchers/splitChangesFetcher.js

@@ -1,22 +1,31 @@
 import { FLAG_SPEC_VERSION } from '../../../utils/constants';
 import { base } from '../../../utils/settingsValidation';
-import { LOG_PREFIX_SYNC_SPLITS } from '../../../logger/constants';
+import { LOG_PREFIX_SYNC } from '../../../logger/constants';
 import { checkIfServerSide } from '../../../utils/key';
 var PROXY_CHECK_INTERVAL_MILLIS_CS = 60 * 60 * 1000; // 1 hour in Client Side
 var PROXY_CHECK_INTERVAL_MILLIS_SS = 24 * PROXY_CHECK_INTERVAL_MILLIS_CS; // 24 hours in Server Side
 function sdkEndpointOverridden(settings) {
     return settings.urls.sdk !== base.urls.sdk;
 }
+function isSplitChangesLegacyResponse(data) {
+    return data.splits != null;
+}
+function partitionByStatus(items, till, since) {
+    var updated = [], removed = [];
+    items.forEach(function (item) { return item.status === 'ARCHIVED' ? removed.push(item.name) : updated.push(item); });
+    return { updated: updated, removed: removed, till: till, since: since };
+}
 /**
  * Factory of SplitChanges fetcher.
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
-export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage) {
+export function splitChangesFetcherFactory(params) {
+    var fetchSplitChanges = params.splitApi.fetchSplitChanges, settings = params.settings, storage = params.storage;
     var log = settings.log;
     var PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
     var lastProxyCheckTimestamp;
-    return function splitChangesFetcher(since, noCache, till, rbSince, 
+    function splitChangesFetcher(since, noCache, till, rbSince, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator) {
         // Recheck proxy
@@ -27,7 +36,7 @@ export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage)
             .catch(function (err) {
             // Handle proxy error with spec 1.3
             if ((!err.statusCode || err.statusCode === 400) && sdkEndpointOverridden(settings) && settings.sync.flagSpecVersion === FLAG_SPEC_VERSION) {
-                log.error(LOG_PREFIX_SYNC_SPLITS + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
+                log.error(LOG_PREFIX_SYNC + 'Proxy error detected. Retrying with spec 1.2. If you are using Split Proxy, please upgrade to latest version');
                 lastProxyCheckTimestamp = Date.now();
                 settings.sync.flagSpecVersion = '1.2'; // fallback to 1.2 spec
                 return fetchSplitChanges(since, noCache, till); // retry request without rbSince
@@ -40,18 +49,12 @@ export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage)
             .then(function (resp) { return resp.json(); })
             .then(function (data) {
             // Using flag spec version 1.2 or below
-            if (data.splits) {
-                return {
-                    ff: {
-                        d: data.splits,
-                        s: data.since,
-                        t: data.till
-                    }
-                };
+            if (isSplitChangesLegacyResponse(data)) {
+                return { d: partitionByStatus(data.splits || [], data.till, data.since) };
             }
             // Proxy recovery
             if (lastProxyCheckTimestamp) {
-                log.info(LOG_PREFIX_SYNC_SPLITS + 'Proxy error recovered');
+                log.info(LOG_PREFIX_SYNC + 'Proxy error recovered');
                 lastProxyCheckTimestamp = undefined;
                 return splitChangesFetcher(-1, undefined, undefined, -1)
                     .then(function (splitChangesResponse) {
@@ -59,7 +62,13 @@ export function splitChangesFetcherFactory(fetchSplitChanges, settings, storage)
                         .then(function () { return splitChangesResponse; });
                 });
             }
-            return data;
+            var ff = data.ff, rbs = data.rbs;
+            return {
+                d: (ff === null || ff === void 0 ? void 0 : ff.d) ? partitionByStatus(ff.d, ff.t, ff.s) : undefined,
+                rbs: (rbs === null || rbs === void 0 ? void 0 : rbs.d) ? partitionByStatus(rbs.d, rbs.t, rbs.s) : undefined,
+            };
         });
-    };
+    }
+    splitChangesFetcher.type = 'feature flags';
+    return splitChangesFetcher;
 }

package/esm/sync/polling/pollingManagerCS.js

@@ -1,6 +1,6 @@
 import { forOwn } from '../../utils/lang';
 import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
-import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
+import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
@@ -9,10 +9,10 @@ import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-export function pollingManagerCSFactory(params) {
+export function pollingManagerCSFactory(params, definitionChangesFetcher) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
+    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, true);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
     var matchingKey = getMatching(settings.core.key);
@@ -30,7 +30,7 @@ export function pollingManagerCSFactory(params) {
     }
     // smart pausing
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
-        if (!splitsSyncTask.isRunning())
+        if (!definitionsSyncTask.isRunning())
             return; // noop if not doing polling
         var usingSegments = usesSegmentsSync(storage);
         if (usingSegments !== mySegmentsSyncTask.isRunning()) {
@@ -58,27 +58,27 @@ export function pollingManagerCSFactory(params) {
         return mySegmentsSyncTask;
     }
     return {
-        splitsSyncTask: splitsSyncTask,
+        definitionsSyncTask: definitionsSyncTask,
         segmentsSyncTask: mySegmentsSyncTask,
         // Start periodic fetching (polling)
         start: function () {
             log.info(POLLING_START);
-            splitsSyncTask.start();
+            definitionsSyncTask.start();
             if (usesSegmentsSync(storage))
                 startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)
         stop: function () {
             log.info(POLLING_STOP);
-            if (splitsSyncTask.isRunning())
-                splitsSyncTask.stop();
+            if (definitionsSyncTask.isRunning())
+                definitionsSyncTask.stop();
             stopMySegmentsSyncTasks();
         },
         // Used by SyncManager to know if running in polling mode.
-        isRunning: splitsSyncTask.isRunning,
-        // fetch splits and segments
+        isRunning: definitionsSyncTask.isRunning,
+        // fetch definitions and segments
         syncAll: function () {
-            var promises = [splitsSyncTask.execute()];
+            var promises = [definitionsSyncTask.execute()];
             forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
                 promises.push(mySegmentsSyncTask.execute());
             });

package/esm/sync/polling/pollingManagerSS.js

@@ -1,26 +1,26 @@
-import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
+import { definitionsSyncTaskFactory } from './syncTasks/definitionsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-export function pollingManagerSSFactory(params) {
+export function pollingManagerSSFactory(params, definitionChangesFetcher) {
     var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
+    var definitionsSyncTask = definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings);
     var segmentsSyncTask = segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);
     return {
-        splitsSyncTask: splitsSyncTask,
+        definitionsSyncTask: definitionsSyncTask,
         segmentsSyncTask: segmentsSyncTask,
         // 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"));
-            var startingUp = splitsSyncTask.start();
+            log.debug(LOG_PREFIX_SYNC_POLLING + "".concat(definitionChangesFetcher.type, " 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 = definitionsSyncTask.start();
             if (startingUp) {
                 startingUp.then(function () {
-                    if (splitsSyncTask.isRunning())
+                    if (definitionsSyncTask.isRunning())
                         segmentsSyncTask.start();
                 });
             }
@@ -28,16 +28,16 @@ export function pollingManagerSSFactory(params) {
         // Stop periodic fetching (polling)
         stop: function () {
             log.info(POLLING_STOP);
-            if (splitsSyncTask.isRunning())
-                splitsSyncTask.stop();
+            if (definitionsSyncTask.isRunning())
+                definitionsSyncTask.stop();
             if (segmentsSyncTask.isRunning())
                 segmentsSyncTask.stop();
         },
         // Used by SyncManager to know if running in polling mode.
-        isRunning: splitsSyncTask.isRunning,
+        isRunning: definitionsSyncTask.isRunning,
         syncAll: function () {
-            // fetch splits and segments. There is no need to catch this promise (`SplitChangesUpdater` is always resolved with a boolean value)
-            return splitsSyncTask.execute().then(function () {
+            // fetch definitions and segments. There is no need to catch this promise (`DefinitionChangesUpdater` is always resolved with a boolean value)
+            return definitionsSyncTask.execute().then(function () {
                 return segmentsSyncTask.execute();
             });
         }

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

@@ -0,0 +1,8 @@
+import { syncTaskFactory } from '../../syncTask';
+import { definitionChangesUpdaterFactory } from '../updaters/definitionChangesUpdater';
+/**
+ * Creates a sync task that periodically executes a `definitionChangesUpdater` task
+ */
+export function definitionsSyncTaskFactory(definitionChangesFetcher, storage, readiness, settings, isClientSide) {
+    return syncTaskFactory(settings.log, definitionChangesUpdaterFactory(settings.log, definitionChangesFetcher, storage, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'definitionChangesUpdater');
+}