@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/utils/settings/language/browser.js

@@ -0,0 +1,16 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+export default 'javascript';

package/es/utils/settings/language/node.js

@@ -0,0 +1,16 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+export default 'nodejs';

package/es/utils/settings/language/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/es/utils/settings/mode.js

@@ -0,0 +1,10 @@
+import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE } from '../constants';
+
+function mode(key, mode) {
+  // Leaving the comparison as is, in case we change the mode name but not the setting.
+  if (key === 'localhost') return LOCALHOST_MODE;
+  if ([STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE].indexOf(mode) === -1) throw Error('Invalid mode provided');
+  return mode;
+}
+
+export default mode;

package/es/utils/settings/runtime/browser.js

@@ -0,0 +1,21 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+export default function generateRuntimeSettings() {
+  return {
+    ip: false,
+    hostname: false
+  };
+}

package/es/{settings → utils/settings}/runtime/node.js

@@ -1,5 +1,5 @@
 /**
-Copyright 2022 Split Software
+Copyright 2016 Split Software
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -15,11 +15,9 @@ limitations under the License.
 **/
 import osFunction from 'os';
 import ipFunction from 'ip';
-import { UNKNOWN, NA, CONSUMER_MODE } from '@splitsoftware/splitio-commons/esm/utils/constants';
-export function validateRuntime(settings) {
-  var isIPAddressesEnabled = settings.core.IPAddressesEnabled === true;
-  var isConsumerMode = settings.mode === CONSUMER_MODE; // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
-
+import { UNKNOWN, NA } from '../../constants';
+export default function generateRuntimeSettings(isIPAddressesEnabled, isConsumerMode) {
+  // If the values are not available, default to false (for standalone) or "unknown" (for consumer mode, to be used on Redis keys)
   var ip = ipFunction.address() || (isConsumerMode ? UNKNOWN : false);
   var hostname = osFunction.hostname() || (isConsumerMode ? UNKNOWN : false);
 

package/es/utils/settings/runtime/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/es/{settings → utils/settings}/storage/browser.js

@@ -1,5 +1,5 @@
 /**
-Copyright 2022 Split Software
+Copyright 2016 Split Software
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -13,17 +13,16 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 **/
-import { isLocalStorageAvailable } from '@splitsoftware/splitio-commons/esm/utils/env/isLocalStorageAvailable';
-import { LOCALHOST_MODE, STORAGE_MEMORY } from '@splitsoftware/splitio-commons/esm/utils/constants';
-var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
-export function validateStorage(settings) {
-  var log = settings.log,
-      mode = settings.mode,
-      _settings$storage = settings.storage;
-  _settings$storage = _settings$storage === void 0 ? {
-    type: STORAGE_MEMORY
-  } : _settings$storage;
-  var type = _settings$storage.type,
+import logFactory from '../../../utils/logger';
+var log = logFactory('splitio-settings');
+import isLocalStorageAvailable from '../../../utils/localstorage/isAvailable';
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_LOCALSTORAGE } from '../../../utils/constants';
+
+var ParseStorageSettings = function ParseStorageSettings(settings) {
+  var mode = settings.mode,
+      _settings$storage = settings.storage,
+      _settings$storage$typ = _settings$storage.type,
+      type = _settings$storage$typ === void 0 ? STORAGE_MEMORY : _settings$storage$typ,
       _settings$storage$opt = _settings$storage.options,
       options = _settings$storage$opt === void 0 ? {} : _settings$storage$opt,
       prefix = _settings$storage.prefix;
@@ -39,8 +38,8 @@ export function validateStorage(settings) {
   var fallbackToMemory = function fallbackToMemory() {
     __originalType = type;
     type = STORAGE_MEMORY;
-  }; // In localhost mode, fallback to Memory storage and track original type to emit SDK_READY_FROM_CACHE if corresponds.
-  // ATM, other mode settings (e.g., 'consumer') are ignored in client-side API, and so treated as standalone.
+  }; // In localhost mode, fallback to Memory storage and track original
+  // type to emit SDK_READY_FROM_CACHE if corresponds
 
 
   if (mode === LOCALHOST_MODE && type === STORAGE_LOCALSTORAGE) {
@@ -51,7 +50,7 @@ export function validateStorage(settings) {
 
   if (type !== STORAGE_MEMORY && type !== STORAGE_LOCALSTORAGE || type === STORAGE_LOCALSTORAGE && !isLocalStorageAvailable()) {
     fallbackToMemory();
-    log.error('Invalid or unavailable storage. Fallbacking into MEMORY storage');
+    log.warn('Invalid or unavailable storage. Fallbacking into MEMORY storage');
   }
 
   return {
@@ -60,4 +59,6 @@ export function validateStorage(settings) {
     prefix: prefix,
     __originalType: __originalType
   };
-}
+};
+
+export default ParseStorageSettings;

package/es/{settings → utils/settings}/storage/node.js

@@ -1,5 +1,5 @@
 /**
-Copyright 2022 Split Software
+Copyright 2016 Split Software
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -13,15 +13,12 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 **/
-import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS, CONSUMER_MODE, STANDALONE_MODE } from '@splitsoftware/splitio-commons/esm/utils/constants';
-export function validateStorage(settings) {
-  var log = settings.log,
-      mode = settings.mode,
-      _settings$storage = settings.storage;
-  _settings$storage = _settings$storage === void 0 ? {
-    type: STORAGE_MEMORY
-  } : _settings$storage;
-  var type = _settings$storage.type,
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS } from '../../constants';
+
+var ParseStorageSettings = function ParseStorageSettings(settings) {
+  var mode = settings.mode,
+      _settings$storage = settings.storage,
+      type = _settings$storage.type,
       _settings$storage$opt = _settings$storage.options,
       options = _settings$storage$opt === void 0 ? {} : _settings$storage$opt,
       prefix = _settings$storage.prefix;
@@ -30,21 +27,17 @@ export function validateStorage(settings) {
     prefix += '.SPLITIO';
   } else {
     prefix = 'SPLITIO';
-  } // We can have MEMORY, REDIS or an invalid storage type
+  } // In localhost mode we should force the user to use the MEMORY storage
+
 
+  if (mode === LOCALHOST_MODE) return {
+    type: STORAGE_MEMORY,
+    prefix: prefix
+  }; // In other cases we can have MEMORY or REDIS
 
   switch (type) {
     case STORAGE_REDIS:
       {
-        // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
-        if (mode === STANDALONE_MODE || mode === LOCALHOST_MODE) {
-          log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallbacking into default MEMORY storage.');
-          return {
-            type: STORAGE_MEMORY,
-            prefix: prefix
-          };
-        }
-
         var host = options.host,
             port = options.port,
             db = options.db,
@@ -82,14 +75,12 @@ export function validateStorage(settings) {
     case STORAGE_MEMORY:
     default:
       {
-        // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
-        if (mode === CONSUMER_MODE) throw new Error('A REDIS storage is required on consumer mode'); // If passing an invalid storage type, log an error
-
-        if (type !== STORAGE_MEMORY) log.error("The provided '" + type + "' storage type is invalid. Fallbacking into default MEMORY storage.");
         return {
           type: STORAGE_MEMORY,
           prefix: prefix
         };
       }
   }
-}
+};
+
+export default ParseStorageSettings;

package/es/utils/settings/storage/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./node.js",
+  "browser": "./browser.js"
+}

package/es/utils/splits/usesSegments.js

@@ -0,0 +1,21 @@
+/**
+ * Given a list of conditions, it returns a boolean flagging if those conditions 
+ * use segments matchers (rules & whitelists)
+ */
+function usesSegments(conditions) {
+  if (conditions === void 0) {
+    conditions = [];
+  }
+
+  for (var i = 0; i < conditions.length; i++) {
+    var matchers = conditions[i].matcherGroup.matchers;
+
+    for (var j = 0; j < matchers.length; j++) {
+      if (matchers[j].matcherType === 'IN_SEGMENT') return true;
+    }
+  }
+
+  return false;
+}
+
+export default usesSegments;

package/es/utils/time/index.js

@@ -0,0 +1,8 @@
+var DEDUP_WINDOW_SIZE_MS = 3600 * 1000;
+/**
+* Truncates de time frame received with the time window.
+*/
+
+export function truncateTimeFrame(timestampInMs) {
+  return timestampInMs - timestampInMs % DEDUP_WINDOW_SIZE_MS;
+}

package/es/utils/timeTracker/index.js

@@ -0,0 +1,216 @@
+var _CALLBACKS;
+
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import { uniqueId } from '../lang';
+import { Logger } from '../logger/LoggerFactory';
+import timer from './timer';
+import thenable from '../promise/thenable'; // logger to be used on this module
+
+var logger = new Logger('[TIME TRACKER]', {
+  showLevel: false
+}); // Map we will use for storing timers data
+
+var timers = {}; // Tasks constants
+
+var CONSTANTS = {
+  SDK_READY: 'Getting ready - Split SDK',
+  SDK_GET_TREATMENT: 'SDK - Get Treatment',
+  SDK_GET_TREATMENTS: 'SDK - Get Treatments',
+  SDK_GET_TREATMENT_WITH_CONFIG: 'SDK - Get Treatment with config',
+  SDK_GET_TREATMENTS_WITH_CONFIG: 'SDK - Get Treatments with config',
+  SPLITS_READY: 'Getting ready - Splits',
+  SEGMENTS_READY: 'Getting ready - Segments',
+  METRICS_PUSH: 'Pushing - Metrics',
+  IMPRESSIONS_PUSH: 'Pushing - Impressions',
+  EVENTS_PUSH: 'Pushing - Events',
+  MY_SEGMENTS_FETCH: 'Fetching - My Segments',
+  SEGMENTS_FETCH: 'Fetching - Segments',
+  SPLITS_FETCH: 'Fetching - Splits'
+}; // Tasks callbacks, if any
+
+var CALLBACKS = (_CALLBACKS = {}, _CALLBACKS[CONSTANTS.SDK_READY] = {
+  collector: 'client',
+  method: 'ready'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENT] = {
+  collector: 'client',
+  method: 'getTreatment'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENTS] = {
+  collector: 'client',
+  method: 'getTreatments'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENT_WITH_CONFIG] = {
+  collector: 'client',
+  method: 'getTreatmentWithConfig'
+}, _CALLBACKS[CONSTANTS.SDK_GET_TREATMENTS_WITH_CONFIG] = {
+  collector: 'client',
+  method: 'getTreatmentsWithConfig'
+}, _CALLBACKS[CONSTANTS.MY_SEGMENTS_FETCH] = {
+  collector: 'mySegments',
+  method: 'latency'
+}, _CALLBACKS[CONSTANTS.SEGMENTS_FETCH] = {
+  collector: 'segmentChanges',
+  method: 'latency'
+}, _CALLBACKS[CONSTANTS.SPLITS_FETCH] = {
+  collector: 'splitChanges',
+  method: 'latency'
+}, _CALLBACKS);
+/**
+ * Generates the timer keys using the task name and a modifier, if any.
+ * @param {string} task - The task name
+ * @param {string} modifier - (optional) The modifier, if any.
+ * @return {string} The generated timer key
+ */
+
+var generateTimerKey = function generateTimerKey(task, modifier) {
+  return typeof modifier === 'string' ? task + modifier : task;
+};
+/**
+ * Given the collectors map, it returns the specific collector for a given task.
+ *
+ * @param {string} task - The task name
+ * @param {Object} collectors - The collectors map
+ */
+
+
+var getCollectorForTask = function getCollectorForTask(task, collectors) {
+  var callbackData = CALLBACKS[task];
+  if (callbackData && collectors) return collectors[callbackData.collector];
+  return false;
+};
+/**
+ * Given a collector and a task, returns the callback function that should be called when we stop the timer.
+ *
+ * @param {string} task - The task name
+ * @param {Object} collector - The collector object for the task
+ */
+
+
+var getCallbackForTask = function getCallbackForTask(task, collector) {
+  var callbackData = CALLBACKS[task];
+  if (callbackData && collector) return collector[callbackData.method];
+  return false;
+};
+
+var TrackerAPI = {
+  /**
+   * "Private" method, used to attach count/countException and stop callbacks to a promise.
+   *
+   * @param {Promise} promise - The promise we want to attach the callbacks.
+   * @param {string} task - The name of the task.
+   * @param {string} modifier - (optional) The modifier for the task, if any.
+   */
+  __attachToPromise: function __attachToPromise(promise, task, collector, modifier) {
+    var _this = this;
+
+    return promise.then(function (resp) {
+      _this.stop(task, modifier);
+
+      if (collector && collector.count) collector.count(resp.status);
+      return resp;
+    }).catch(function (err) {
+      _this.stop(task, modifier);
+
+      if (collector && collector.countException) collector.countException();
+      throw err;
+    });
+  },
+
+  /**
+   * Starts tracking the time for a given task. All tasks tracked are considered "unique" because
+   * there may be multiple SDK instances tracking a "generic" task, making any task non-generic.
+   *
+   * @param {string} task - The task we are starting.
+   * @param {Object} collectors - The collectors map.
+   * @param {Promise} promise - (optional) The promise we are tracking.
+   * @return {Function | Promise} The stop function for this specific task or the promise received with the callbacks registered.
+   */
+  start: function start(task, collectors, promise) {
+    var taskUniqueId = uniqueId();
+    var taskCollector = getCollectorForTask(task, collectors);
+    var result; // If we are registering a promise with this task, we should count the status and the exceptions as well
+    // as stopping the task when the promise resolves. Then return the promise
+
+    if (thenable(promise)) {
+      result = this.__attachToPromise(promise, task, taskCollector, taskUniqueId);
+    } else {
+      // If not, we return the stop function, as it will be stopped manually.
+      result = this.stop.bind(this, task, taskUniqueId);
+
+      if (CALLBACKS[task] && !taskCollector) {
+        // and provide a way for a defered setup of the collector, if needed.
+        result.setCollectorForTask = this.setCollectorForTask.bind(this, task, taskUniqueId);
+      }
+    } // We start the timer, with an uniqueId attached to it's name, and save tracking info for this task.
+
+
+    var trackingKey = generateTimerKey(task, taskUniqueId);
+    var cb = getCallbackForTask(task, taskCollector);
+    timers[trackingKey] = {
+      cb: cb,
+      timer: timer()
+    };
+    return result;
+  },
+
+  /**
+   * Setup the collector for a task that reports metrics.
+   *
+   * @param {string} task - The task name
+   * @param {string} taskUniqueId - The unique identifier for this task
+   * @param {Object} collectors - The collectors map.
+   */
+  setCollectorForTask: function setCollectorForTask(task, taskUniqueId, collectors) {
+    var taskCollector = getCollectorForTask(task, collectors);
+
+    if (taskCollector) {
+      var trackingKey = generateTimerKey(task, taskUniqueId);
+      timers[trackingKey].cb = getCallbackForTask(task, taskCollector);
+    }
+  },
+
+  /**
+   * Stops the tracking of a given task.
+   *
+   * @param {string} task - The task we are starting.
+   * @param {string} modifier - (optional) The modifier for that specific task.
+   */
+  stop: function stop(task, modifier) {
+    var timerName = generateTimerKey(task, modifier);
+    var timerData = timers[timerName];
+
+    if (timerData) {
+      // Stop the timer and round result for readability.
+      var et = timerData.timer();
+      logger.debug("[" + task + "] took " + et + "ms to finish."); // Check if we have a tracker callback.
+
+      if (timerData.cb) {
+        // If we have a callback, we call it with the elapsed time of the task and then delete the reference.
+        timerData.cb(et);
+      } // Remove the task tracking reference.
+
+
+      delete timers[timerName];
+      return et;
+    }
+  },
+
+  /**
+   * The constants shortcut for the task names.
+   */
+  TaskNames: CONSTANTS
+}; // Our "time tracker" API
+
+export default TrackerAPI;

package/es/utils/timeTracker/timer.js

@@ -0,0 +1,25 @@
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+import now from '../now';
+
+function start() {
+  var st = now();
+  return function stop() {
+    return Math.round(now() - st);
+  };
+}
+
+export default start;

package/lib/client/attributesDecoration.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = ClientAttributesDecorationLayer;
+
+var _inputValidation = _interopRequireDefault(require("./inputValidation"));
+
+var _InMemory = _interopRequireDefault(require("../storage/AttributesCache/InMemory"));
+
+var _attributes = require("../utils/inputValidation/attributes");
+
+var _logger = _interopRequireDefault(require("../utils/logger"));
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var log = (0, _logger.default)('splitio-client');
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
+ */
+
+function ClientAttributesDecorationLayer(context, isKeyBinded, isTTBinded) {
+  var client = (0, _inputValidation.default)(context, isKeyBinded, isTTBinded);
+  var attributeStorage = new _InMemory.default(); // Keep a reference to the original methods
+
+  var clientGetTreatment = client.getTreatment;
+  var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  var clientGetTreatments = client.getTreatments;
+  var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  /**
+   * Add an attribute to client's in memory attributes storage
+   * 
+   * @param {string} attributeName Attrinute name
+   * @param {string, number, boolean, list} attributeValue Attribute value
+   * @returns {boolean} true if the attribute was stored and false otherways
+   */
+
+  client.setAttribute = function (attributeName, attributeValue) {
+    var attribute = {};
+    attribute[attributeName] = attributeValue;
+    if (!(0, _attributes.validateAttributesDeep)(attribute)) return false;
+    log.debug("stored " + attributeValue + " for attribute " + attributeName);
+    return attributeStorage.setAttribute(attributeName, attributeValue);
+  };
+  /**
+   * Returns the attribute with the given key
+   * 
+   * @param {string} attributeName Attribute name
+   * @returns {Object} Attribute with the given key
+   */
+
+
+  client.getAttribute = function (attributeName) {
+    log.debug("retrieved attribute " + attributeName);
+    return attributeStorage.getAttribute(attributeName + '');
+  };
+  /**
+   * Add to client's in memory attributes storage the attributes in 'attributes'
+   * 
+   * @param {Object} attributes Object with attributes to store
+   * @returns true if attributes were stored an false otherways
+   */
+
+
+  client.setAttributes = function (attributes) {
+    if (!(0, _attributes.validateAttributesDeep)(attributes)) return false;
+    return attributeStorage.setAttributes(attributes);
+  };
+  /**
+   * Return all the attributes stored in client's in memory attributes storage
+   * 
+   * @returns {Object} returns all the stored attributes
+   */
+
+
+  client.getAttributes = function () {
+    return attributeStorage.getAll();
+  };
+  /**
+   * Removes from client's in memory attributes storage the attribute with the given key
+   * 
+   * @param {string} attributeName 
+   * @returns {boolean} true if attribute was removed and false otherways
+   */
+
+
+  client.removeAttribute = function (attributeName) {
+    log.debug("removed attribute " + attributeName);
+    return attributeStorage.removeAttribute(attributeName + '');
+  };
+  /**
+   * Remove all the stored attributes in the client's in memory attribute storage
+   */
+
+
+  client.clearAttributes = function () {
+    return attributeStorage.clear();
+  };
+
+  client.getTreatment = function (maybeKey, maybeSplit, maybeAttributes) {
+    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatmentWithConfig = function (maybeKey, maybeSplit, maybeAttributes) {
+    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatments = function (maybeKey, maybeSplits, maybeAttributes) {
+    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  };
+
+  client.getTreatmentsWithConfig = function (maybeKey, maybeSplits, maybeAttributes) {
+    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
+  };
+
+  function combineAttributes(maybeAttributes) {
+    var storedAttributes = attributeStorage.getAll();
+
+    if (Object.keys(storedAttributes).length > 0) {
+      return (0, _objectAssign.default)({}, storedAttributes, maybeAttributes);
+    }
+
+    return maybeAttributes;
+  }
+
+  return client;
+}