@splitsoftware/splitio 10.17.1 → 10.17.3-rc.1

package/lib/utils/timeTracker/timer.js

@@ -1,33 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _now = _interopRequireDefault(require("../now"));
-
-/**
-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.
-**/
-function start() {
-  var st = (0, _now.default)();
-  return function stop() {
-    return Math.round((0, _now.default)() - st);
-  };
-}
-
-var _default = start;
-exports.default = _default;

package/src/client/attributesDecoration.js

@@ -1,112 +0,0 @@
-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';
-const 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) {
-
-  const client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
-
-  const attributeStorage = new AttributesCacheInMemory();
-
-  // Keep a reference to the original methods
-  const clientGetTreatment = client.getTreatment;
-  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  const clientGetTreatments = client.getTreatments;
-  const 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 = (attributeName, attributeValue) => {
-    const 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 = (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 = (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 = () => {
-    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 = (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 = () => {
-    return attributeStorage.clear();
-  };
-
-  client.getTreatment = (maybeKey, maybeSplit, maybeAttributes) => {
-    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentWithConfig = (maybeKey, maybeSplit, maybeAttributes) => {
-    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatments = (maybeKey, maybeSplits, maybeAttributes) => {
-    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentsWithConfig = (maybeKey, maybeSplits, maybeAttributes) => {
-    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  function combineAttributes(maybeAttributes) {
-    const storedAttributes = attributeStorage.getAll();
-    if (Object.keys(storedAttributes).length > 0) {
-      return objectAssign({}, storedAttributes, maybeAttributes);
-    }
-    return maybeAttributes;
-  }
-
-  return client;
-}

package/src/client/browser.js

@@ -1,41 +0,0 @@
-import { get } from '../utils/lang';
-import ClientAttributesDecorationLayer from './attributesDecoration';
-import { LOCALHOST_MODE } from '../utils/constants';
-import {
-  validateKey,
-  validateTrafficType,
-} from '../utils/inputValidation';
-
-function BrowserClientFactory(context) {
-  const settings = context.get(context.constants.SETTINGS);
-  const maybeKey = get(settings, 'core.key', undefined);
-  const 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)
-  const trackBindings = [settings.core.key];
-  if (maybeTT !== undefined) {
-    const tt = validateTrafficType(maybeTT, 'Client instantiation');
-    settings.core.trafficType = tt;
-    trackBindings.push(tt);
-  }
-
-  const 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.bind(client, ...trackBindings);
-
-  return client;
-}
-
-export default BrowserClientFactory;

package/src/client/client.js

@@ -1,131 +0,0 @@
-import logFactory from '../utils/logger';
-const 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) {
-  const storage = context.get(context.constants.STORAGE);
-  const metricCollectors = context.get(context.constants.COLLECTORS);
-  const impressionsTracker = ImpressionsTracker(context);
-  const eventTracker = EventTracker(context);
-
-  function getTreatment(key, splitName, attributes, withConfig = false) {
-    const taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENT_WITH_CONFIG' : 'SDK_GET_TREATMENT'];
-    const stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
-    const evaluation = evaluateFeature(key, splitName, attributes, storage);
-
-    const wrapUp = (evaluationResult) => {
-      const treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, `getTreatment${withConfig ? 'withConfig' : ''}`);
-      impressionsTracker.track();
-      stopLatencyTracker();
-      return treatment;
-    };
-
-    return thenable(evaluation) ? evaluation.then((res) => wrapUp(res)) : wrapUp(evaluation);
-  }
-
-  function getTreatmentWithConfig(key, splitName, attributes) {
-    return getTreatment(key, splitName, attributes, true);
-  }
-
-  function getTreatments(key, splitNames, attributes, withConfig = false) {
-    const taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENTS_WITH_CONFIG' : 'SDK_GET_TREATMENTS'];
-    const stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
-
-    const wrapUp = (evaluationResults) => {
-      const results = {};
-      Object.keys(evaluationResults).forEach(splitName => {
-        results[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, `getTreatments${withConfig ? 'withConfig' : ''}`);
-      });
-      impressionsTracker.track();
-      stopLatencyTracker();
-      return results;
-    };
-
-    const evaluations = evaluateFeatures(key, splitNames, attributes, storage);
-
-    return thenable(evaluations) ? evaluations.then((res) => 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
-  ) {
-    const isSdkReady = context.get(context.constants.READY, true) || context.get(context.constants.READY_FROM_CACHE, true);
-    const matchingKey = matching(key);
-    const 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 };
-    }
-
-    const { treatment, label, changeNumber, config = null } = evaluation;
-    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,
-        time: Date.now(),
-        bucketingKey,
-        label,
-        changeNumber
-      }, attributes);
-    }
-
-    if (withConfig) {
-      return {
-        treatment,
-        config
-      };
-    }
-
-    return treatment;
-  }
-
-  function track(key, trafficTypeName, eventTypeId, value = null, properties = null, size = 1024) {
-    const matchingKey = matching(key);
-    const timestamp = Date.now();
-    const eventData = {
-      eventTypeId,
-      trafficTypeName,
-      value,
-      timestamp,
-      key: matchingKey,
-      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, getTreatmentWithConfig,
-    getTreatments, getTreatmentsWithConfig,
-    track
-  };
-}
-
-export default ClientFactory;

package/src/client/inputValidation.js

@@ -1,130 +0,0 @@
-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) {
-  const settings = context.get(context.constants.SETTINGS);
-  const isStorageSync = settings.storage.type !== STORAGE_REDIS;
-  // instantiate the client
-  const client = ClientFactory(context);
-  // Keep a reference to the original methods
-  const clientGetTreatment = client.getTreatment;
-  const clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  const clientGetTreatments = client.getTreatments;
-  const clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-  const clientTrack = client.track;
-
-  /**
-   * Avoid repeating this validations code
-   */
-  function validateEvaluationParams(maybeKey, maybeSplitOrSplits, maybeAttributes, methodName) {
-    const multi = startsWith(methodName, 'getTreatments');
-    const key = isKeyBinded ? maybeKey : validateKey(maybeKey, methodName);
-    const splitOrSplits = multi ? validateSplits(maybeSplitOrSplits, methodName) : validateSplit(maybeSplitOrSplits, methodName);
-    const attributes = validateAttributes(maybeAttributes, methodName);
-    const isOperational = validateIfDestroyed(context);
-
-    validateIfReady(context, methodName);
-
-    const valid = isOperational && key && splitOrSplits && attributes !== false;
-
-    return {
-      valid,
-      key,
-      splitOrSplits,
-      attributes
-    };
-  }
-
-  client.getTreatment = function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
-    const 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) {
-    const 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) {
-    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
-
-    if (params.valid) {
-      return clientGetTreatments(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      const res = {};
-      if (params.splitOrSplits) params.splitOrSplits.forEach(split => res[split] = CONTROL);
-
-      if (isStorageSync) return res;
-
-      return Promise.resolve(res);
-    }
-  };
-
-  client.getTreatmentsWithConfig = function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
-    const params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
-
-    if (params.valid) {
-      return clientGetTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      const res = {};
-      if (params.splitOrSplits) params.splitOrSplits.forEach(split => res[split] = objectAssign({}, CONTROL_WITH_CONFIG));
-
-      if (isStorageSync) return res;
-
-      return Promise.resolve(res);
-    }
-  };
-
-  client.track = function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-    const key = isKeyBinded ? maybeKey : validateKey(maybeKey, 'track');
-    const tt = isTTBinded ? maybeTT : validateTrafficType(maybeTT, 'track');
-    const event = validateEvent(maybeEvent, 'track');
-    const eventValue = validateEventValue(maybeEventValue, 'track');
-    const { properties, size } = validateEventProperties(maybeProperties, 'track');
-    const 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/src/client/node.js

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

package/src/client/package.json

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

package/src/engine/combiners/and.js

@@ -1,55 +0,0 @@
-/**
-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';
-const log = logFactory('splitio-engine:combiner');
-import thenable from '../../utils/promise/thenable';
-
-function andResults(results) {
-  let i = 0;
-  let len = results.length;
-  let 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(...params) {
-    const matcherResults = matchers.map(matcher => matcher(...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/src/engine/combiners/ifelseif.js

@@ -1,74 +0,0 @@
-/**
-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';
-const 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) {
-  const len = predicateResults.length;
-
-  for (let i = 0; i < len; i++) {
-    const 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).
-    const predicateResults = predicates.map(evaluator => evaluator(key, seed, trafficAllocation, trafficAllocationSeed, splitEvaluator, attributes, algo));
-
-    // if we find a thenable
-    if (findIndex(predicateResults, thenable) !== -1) {
-      return Promise.all(predicateResults).then(results => 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/src/engine/condition/index.js

@@ -1,65 +0,0 @@
-/**
-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) {
-    const treatment = engine.getTreatment(bucketingKey, seed, treatments, algo);
-
-    return {
-      treatment,
-      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.
-    const matches = matcherEvaluator(key, attributes, splitEvaluator);
-
-    if (thenable(matches)) {
-      return matches.then(result => match(result, key.bucketingKey, seed, treatments, label, algo));
-    }
-
-    return match(matches, key.bucketingKey, seed, treatments, label, algo);
-  }
-
-  return conditionEvaluator;
-}
-
-export default conditionContext;

package/src/engine/convertions/index.js

@@ -1,22 +0,0 @@
-/**
-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);
-}