@splitsoftware/splitio 10.17.3-rc.1 → 10.17.3-rc.4

package/CHANGES.txt

@@ -1,3 +1,6 @@
+10.17.3 (XXX XX, 2022)
+ - Updated format for MySegments keys in LocalStorage, keeping backwards compatibility.
+
 10.17.2 (January 31, 2022)
  - Updated some dependencies for vulnerability fixes.
  - Bugfixing - Fixed internal handling of Fetch API promise rejection, to avoid unhandled exceptions on some Web browsers (issue https://github.com/splitio/javascript-client/issues/621)

package/es/client/attributesDecoration.js

@@ -0,0 +1,116 @@
+import ClientInputValidationLayer from './inputValidation';
+import AttributesCacheInMemory from '../storage/AttributesCache/InMemory';
+import { validateAttributesDeep } from '../utils/inputValidation/attributes';
+import logFactory from '../utils/logger';
+import objectAssign from 'object-assign';
+var log = logFactory('splitio-client');
+/**
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
+ */
+
+export default function ClientAttributesDecorationLayer(context, isKeyBinded, isTTBinded) {
+  var client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
+  var attributeStorage = new AttributesCacheInMemory(); // 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 (!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 (!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 objectAssign({}, storedAttributes, maybeAttributes);
+    }
+
+    return maybeAttributes;
+  }
+
+  return client;
+}

package/es/client/browser.js

@@ -0,0 +1,39 @@
+import { get } from '../utils/lang';
+import ClientAttributesDecorationLayer from './attributesDecoration';
+import { LOCALHOST_MODE } from '../utils/constants';
+import { validateKey, validateTrafficType } from '../utils/inputValidation';
+
+function BrowserClientFactory(context) {
+  var _client$track;
+
+  var settings = context.get(context.constants.SETTINGS);
+  var maybeKey = get(settings, 'core.key', undefined);
+  var maybeTT = get(settings, 'core.trafficType', undefined);
+
+  if (settings.mode === LOCALHOST_MODE && maybeKey === undefined) {
+    settings.core.key = 'localhost_key';
+  } else {
+    settings.core.key = validateKey(maybeKey, 'Client instantiation');
+  } // Key is also binded to the .track method. Same thing happens with trafficType but only if present on configs. (not required)
+
+
+  var trackBindings = [settings.core.key];
+
+  if (maybeTT !== undefined) {
+    var tt = validateTrafficType(maybeTT, 'Client instantiation');
+    settings.core.trafficType = tt;
+    trackBindings.push(tt);
+  }
+
+  var client = ClientAttributesDecorationLayer(context, true, trackBindings.length > 1);
+  client.isBrowserClient = true; // In the browser land, we can bind the key and the traffic type (if provided)
+
+  client.getTreatment = client.getTreatment.bind(client, settings.core.key);
+  client.getTreatmentWithConfig = client.getTreatmentWithConfig.bind(client, settings.core.key);
+  client.getTreatments = client.getTreatments.bind(client, settings.core.key);
+  client.getTreatmentsWithConfig = client.getTreatmentsWithConfig.bind(client, settings.core.key);
+  client.track = (_client$track = client.track).bind.apply(_client$track, [client].concat(trackBindings));
+  return client;
+}
+
+export default BrowserClientFactory;

package/es/client/client.js

@@ -0,0 +1,155 @@
+import logFactory from '../utils/logger';
+var log = logFactory('splitio-client');
+import { evaluateFeature, evaluateFeatures } from '../engine/evaluator';
+import ImpressionsTracker from '../trackers/impressions';
+import EventTracker from '../trackers/event';
+import tracker from '../utils/timeTracker';
+import thenable from '../utils/promise/thenable';
+import { matching, bucketing } from '../utils/key/factory';
+/* asynchronous validations that live on the client. */
+
+import { validateSplitExistance, validateTrafficTypeExistance } from '../utils/inputValidation';
+import { SDK_NOT_READY } from '../utils/labels';
+import { CONTROL } from '../utils/constants';
+
+function ClientFactory(context) {
+  var storage = context.get(context.constants.STORAGE);
+  var metricCollectors = context.get(context.constants.COLLECTORS);
+  var impressionsTracker = ImpressionsTracker(context);
+  var eventTracker = EventTracker(context);
+
+  function getTreatment(key, splitName, attributes, withConfig) {
+    if (withConfig === void 0) {
+      withConfig = false;
+    }
+
+    var taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENT_WITH_CONFIG' : 'SDK_GET_TREATMENT'];
+    var stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
+    var evaluation = evaluateFeature(key, splitName, attributes, storage);
+
+    var wrapUp = function wrapUp(evaluationResult) {
+      var treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, "getTreatment" + (withConfig ? 'withConfig' : ''));
+      impressionsTracker.track();
+      stopLatencyTracker();
+      return treatment;
+    };
+
+    return thenable(evaluation) ? evaluation.then(function (res) {
+      return wrapUp(res);
+    }) : wrapUp(evaluation);
+  }
+
+  function getTreatmentWithConfig(key, splitName, attributes) {
+    return getTreatment(key, splitName, attributes, true);
+  }
+
+  function getTreatments(key, splitNames, attributes, withConfig) {
+    if (withConfig === void 0) {
+      withConfig = false;
+    }
+
+    var taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENTS_WITH_CONFIG' : 'SDK_GET_TREATMENTS'];
+    var stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
+
+    var wrapUp = function wrapUp(evaluationResults) {
+      var results = {};
+      Object.keys(evaluationResults).forEach(function (splitName) {
+        results[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, "getTreatments" + (withConfig ? 'withConfig' : ''));
+      });
+      impressionsTracker.track();
+      stopLatencyTracker();
+      return results;
+    };
+
+    var evaluations = evaluateFeatures(key, splitNames, attributes, storage);
+    return thenable(evaluations) ? evaluations.then(function (res) {
+      return wrapUp(res);
+    }) : wrapUp(evaluations);
+  }
+
+  function getTreatmentsWithConfig(key, splitNames, attributes) {
+    return getTreatments(key, splitNames, attributes, true);
+  } // Internal function
+
+
+  function processEvaluation(evaluation, splitName, key, attributes, withConfig, invokingMethodName) {
+    var isSdkReady = context.get(context.constants.READY, true) || context.get(context.constants.READY_FROM_CACHE, true);
+    var matchingKey = matching(key);
+    var bucketingKey = bucketing(key); // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
+
+    if (!isSdkReady) {
+      evaluation = {
+        treatment: CONTROL,
+        label: SDK_NOT_READY
+      };
+    }
+
+    var _evaluation = evaluation,
+        treatment = _evaluation.treatment,
+        label = _evaluation.label,
+        changeNumber = _evaluation.changeNumber,
+        _evaluation$config = _evaluation.config,
+        config = _evaluation$config === void 0 ? null : _evaluation$config;
+    log.info("Split: " + splitName + ". Key: " + matchingKey + ". Evaluation: " + treatment + ". Label: " + label);
+
+    if (validateSplitExistance(context, splitName, label, invokingMethodName)) {
+      log.info('Queueing corresponding impression.');
+      impressionsTracker.queue({
+        feature: splitName,
+        keyName: matchingKey,
+        treatment: treatment,
+        time: Date.now(),
+        bucketingKey: bucketingKey,
+        label: label,
+        changeNumber: changeNumber
+      }, attributes);
+    }
+
+    if (withConfig) {
+      return {
+        treatment: treatment,
+        config: config
+      };
+    }
+
+    return treatment;
+  }
+
+  function track(key, trafficTypeName, eventTypeId, value, properties, size) {
+    if (value === void 0) {
+      value = null;
+    }
+
+    if (properties === void 0) {
+      properties = null;
+    }
+
+    if (size === void 0) {
+      size = 1024;
+    }
+
+    var matchingKey = matching(key);
+    var timestamp = Date.now();
+    var eventData = {
+      eventTypeId: eventTypeId,
+      trafficTypeName: trafficTypeName,
+      value: value,
+      timestamp: timestamp,
+      key: matchingKey,
+      properties: properties
+    }; // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
+
+    validateTrafficTypeExistance(trafficTypeName, context, 'track');
+    return eventTracker.track(eventData, size);
+  }
+
+  return {
+    getTreatment: getTreatment,
+    getTreatmentWithConfig: getTreatmentWithConfig,
+    getTreatments: getTreatments,
+    getTreatmentsWithConfig: getTreatmentsWithConfig,
+    track: track
+  };
+}
+
+export default ClientFactory;

package/es/client/inputValidation.js

@@ -0,0 +1,117 @@
+import objectAssign from 'object-assign';
+import ClientFactory from './client';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfDestroyed, validateIfReady } from '../utils/inputValidation';
+import { startsWith } from '../utils/lang';
+import { STORAGE_REDIS, CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
+/**
+ * We will validate the input before actually executing the client methods. We should "guard" the client here,
+ * while not polluting the "real" implementation of those methods.
+ */
+
+function ClientInputValidationLayer(context, isKeyBinded, isTTBinded) {
+  var settings = context.get(context.constants.SETTINGS);
+  var isStorageSync = settings.storage.type !== STORAGE_REDIS; // instantiate the client
+
+  var client = ClientFactory(context); // Keep a reference to the original methods
+
+  var clientGetTreatment = client.getTreatment;
+  var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
+  var clientGetTreatments = client.getTreatments;
+  var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
+  var clientTrack = client.track;
+  /**
+   * Avoid repeating this validations code
+   */
+
+  function validateEvaluationParams(maybeKey, maybeSplitOrSplits, maybeAttributes, methodName) {
+    var multi = startsWith(methodName, 'getTreatments');
+    var key = isKeyBinded ? maybeKey : validateKey(maybeKey, methodName);
+    var splitOrSplits = multi ? validateSplits(maybeSplitOrSplits, methodName) : validateSplit(maybeSplitOrSplits, methodName);
+    var attributes = validateAttributes(maybeAttributes, methodName);
+    var isOperational = validateIfDestroyed(context);
+    validateIfReady(context, methodName);
+    var valid = isOperational && key && splitOrSplits && attributes !== false;
+    return {
+      valid: valid,
+      key: key,
+      splitOrSplits: splitOrSplits,
+      attributes: attributes
+    };
+  }
+
+  client.getTreatment = function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
+    var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
+
+    if (params.valid) {
+      return clientGetTreatment(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      if (isStorageSync) return CONTROL;
+      return Promise.resolve(CONTROL);
+    }
+  };
+
+  client.getTreatmentWithConfig = function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
+    var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
+
+    if (params.valid) {
+      return clientGetTreatmentWithConfig(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      if (isStorageSync) return objectAssign({}, CONTROL_WITH_CONFIG);
+      return Promise.resolve(objectAssign({}, CONTROL_WITH_CONFIG));
+    }
+  };
+
+  client.getTreatments = function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
+    var params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
+
+    if (params.valid) {
+      return clientGetTreatments(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      var res = {};
+      if (params.splitOrSplits) params.splitOrSplits.forEach(function (split) {
+        return res[split] = CONTROL;
+      });
+      if (isStorageSync) return res;
+      return Promise.resolve(res);
+    }
+  };
+
+  client.getTreatmentsWithConfig = function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
+    var params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
+
+    if (params.valid) {
+      return clientGetTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);
+    } else {
+      var res = {};
+      if (params.splitOrSplits) params.splitOrSplits.forEach(function (split) {
+        return res[split] = objectAssign({}, CONTROL_WITH_CONFIG);
+      });
+      if (isStorageSync) return res;
+      return Promise.resolve(res);
+    }
+  };
+
+  client.track = function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
+    var key = isKeyBinded ? maybeKey : validateKey(maybeKey, 'track');
+    var tt = isTTBinded ? maybeTT : validateTrafficType(maybeTT, 'track');
+    var event = validateEvent(maybeEvent, 'track');
+    var eventValue = validateEventValue(maybeEventValue, 'track');
+
+    var _validateEventPropert = validateEventProperties(maybeProperties, 'track'),
+        properties = _validateEventPropert.properties,
+        size = _validateEventPropert.size;
+
+    var isOperational = validateIfDestroyed(context);
+
+    if (isOperational && key && tt && event && eventValue !== false && properties !== false) {
+      return clientTrack(key, tt, event, eventValue, properties, size);
+    } else {
+      if (isStorageSync) return false;
+      return Promise.resolve(false);
+    }
+  };
+
+  return client;
+}
+
+export default ClientInputValidationLayer;

package/es/client/node.js

@@ -0,0 +1,6 @@
+import ClientWithInputValidationLayer from './inputValidation';
+export default function NodeClientFactory(context) {
+  var client = ClientWithInputValidationLayer(context);
+  client.isBrowserClient = false;
+  return client;
+}

package/es/engine/combiners/and.js

@@ -0,0 +1,54 @@
+/**
+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 { findIndex } from '../../utils/lang';
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:combiner');
+import thenable from '../../utils/promise/thenable';
+
+function andResults(results) {
+  var i = 0;
+  var len = results.length;
+  var hasMatchedAll; // loop through all the matchers an stop at the first one returning false.
+
+  for (; i < len && results[i]; i++) {// logic is run inside the condition of evaluates next step.
+  }
+
+  hasMatchedAll = i === len;
+  log.debug("[andCombiner] evaluates to " + hasMatchedAll);
+  return hasMatchedAll;
+}
+
+function andCombinerContext(matchers) {
+  function andCombiner() {
+    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
+      params[_key] = arguments[_key];
+    }
+
+    var matcherResults = matchers.map(function (matcher) {
+      return matcher.apply(void 0, params);
+    }); // If any matching result is a thenable we should use Promise.all
+
+    if (findIndex(matcherResults, thenable) !== -1) {
+      return Promise.all(matcherResults).then(andResults);
+    } else {
+      return andResults(matcherResults);
+    }
+  }
+
+  return andCombiner;
+}
+
+export default andCombinerContext;

package/es/engine/combiners/ifelseif.js

@@ -0,0 +1,73 @@
+/**
+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 { findIndex } from '../../utils/lang';
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:combiner');
+import thenable from '../../utils/promise/thenable';
+import * as LabelsConstants from '../../utils/labels';
+import { CONTROL } from '../../utils/constants';
+
+function unexpectedInputHandler() {
+  log.error('Invalid Split provided, no valid conditions found');
+  return {
+    treatment: CONTROL,
+    label: LabelsConstants.EXCEPTION
+  };
+}
+
+function computeTreatment(predicateResults) {
+  var len = predicateResults.length;
+
+  for (var i = 0; i < len; i++) {
+    var evaluation = predicateResults[i];
+
+    if (evaluation !== undefined) {
+      log.debug("Treatment found: " + evaluation.treatment);
+      return evaluation;
+    }
+  }
+
+  log.debug('All predicates evaluated, no treatment found.');
+  return undefined;
+}
+
+function ifElseIfCombinerContext(predicates) {
+  function ifElseIfCombiner(key, seed, trafficAllocation, trafficAllocationSeed, attributes, algo, splitEvaluator) {
+    // In Async environments we are going to have async predicates. There is none way to know
+    // before hand so we need to evaluate all the predicates, verify for thenables, and finally,
+    // define how to return the treatment (wrap result into a Promise or not).
+    var predicateResults = predicates.map(function (evaluator) {
+      return evaluator(key, seed, trafficAllocation, trafficAllocationSeed, splitEvaluator, attributes, algo);
+    }); // if we find a thenable
+
+    if (findIndex(predicateResults, thenable) !== -1) {
+      return Promise.all(predicateResults).then(function (results) {
+        return computeTreatment(results);
+      });
+    }
+
+    return computeTreatment(predicateResults);
+  } // if there is none predicates, then there was an error in parsing phase
+
+
+  if (!Array.isArray(predicates) || Array.isArray(predicates) && predicates.length === 0) {
+    return unexpectedInputHandler;
+  } else {
+    return ifElseIfCombiner;
+  }
+}
+
+export default ifElseIfCombinerContext;

package/es/engine/condition/index.js

@@ -0,0 +1,62 @@
+/**
+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 engine from '../engine';
+import thenable from '../../utils/promise/thenable';
+import * as LabelsConstants from '../../utils/labels'; // Build Evaluation object if and only if matchingResult is true
+
+function match(matchingResult, bucketingKey, seed, treatments, label, algo) {
+  if (matchingResult) {
+    var treatment = engine.getTreatment(bucketingKey, seed, treatments, algo);
+    return {
+      treatment: treatment,
+      label: label
+    };
+  } // else we should notify the engine to continue evaluating
+
+
+  return undefined;
+} // Condition factory
+
+
+function conditionContext(matcherEvaluator, treatments, label, conditionType) {
+  function conditionEvaluator(key, seed, trafficAllocation, trafficAllocationSeed, splitEvaluator, attributes, algo) {
+    // Whitelisting has more priority than traffic allocation, so we don't apply this filtering to those conditions.
+    if (conditionType === 'ROLLOUT' && !engine.shouldApplyRollout(trafficAllocation, key.bucketingKey, trafficAllocationSeed, algo)) {
+      return {
+        treatment: undefined,
+        label: LabelsConstants.NOT_IN_SPLIT
+      };
+    } // matcherEvaluator could be Async, this relays on matchers return value, so we need
+    // to verify for thenable before play with the result.
+    // Also, we pass splitEvaluator function in case we have a matcher that needs to evaluate another split,
+    // as well as the entire key object for the same reason.
+
+
+    var matches = matcherEvaluator(key, attributes, splitEvaluator);
+
+    if (thenable(matches)) {
+      return matches.then(function (result) {
+        return match(result, key.bucketingKey, seed, treatments, label, algo);
+      });
+    }
+
+    return match(matches, key.bucketingKey, seed, treatments, label, algo);
+  }
+
+  return conditionEvaluator;
+}
+
+export default conditionContext;

package/es/engine/convertions/index.js

@@ -0,0 +1,29 @@
+/**
+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 function zeroSinceHH(millisSinceEpoch
+/*: number */
+)
+/*: number */
+{
+  return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
+}
+export function zeroSinceSS(millisSinceEpoch
+/*: number */
+)
+/*: number */
+{
+  return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
+}