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

package/es/utils/lang/Sets.js

@@ -0,0 +1,114 @@
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+
+/**
+ * Set implementation based on es6-set polyfill (https://github.com/medikoo/es6-set/blob/master/polyfill.js),
+ * with the minimal features used by the SDK.
+
+Copyright (C) 2013 Mariusz Nowak (www.medikoo.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+**/
+export var SetPoly = /*#__PURE__*/function () {
+  // unlike ES6 `Set`, it only accepts an array as first argument iterable
+  function SetPoly()
+  /*arrayIterable*/
+  {
+    var _this = this;
+
+    this.__setData__ = [];
+    var arrayIterable = arguments[0];
+    if (Array.isArray(arrayIterable)) arrayIterable.forEach(function (value) {
+      _this.add(value);
+    });
+  }
+
+  var _proto = SetPoly.prototype;
+
+  _proto.clear = function clear() {
+    if (!this.__setData__.length) return;
+    this.__setData__.length = 0;
+  };
+
+  _proto.add = function add(value) {
+    if (this.has(value)) return this;
+
+    this.__setData__.push(value);
+
+    return this;
+  };
+
+  _proto.delete = function _delete(value) {
+    var index = this.__setData__.indexOf(value);
+
+    if (index === -1) return false;
+
+    this.__setData__.splice(index, 1);
+
+    return true;
+  };
+
+  _proto.has = function has(value) {
+    return this.__setData__.indexOf(value) !== -1;
+  };
+
+  _proto.forEach = function forEach(cb
+  /*, thisArg*/
+  ) {
+    var thisArg = arguments[1];
+    if (typeof cb !== 'function') throw new TypeError(cb + ' is not a function');
+
+    for (var i = 0; i < this.__setData__.length; i++) {
+      var value = this.__setData__[i];
+      cb.call(thisArg, value, value, this);
+    }
+  };
+
+  _createClass(SetPoly, [{
+    key: "size",
+    get: function get() {
+      return this.__setData__.length;
+    }
+  }]);
+
+  return SetPoly;
+}();
+export function setToArray(set) {
+  if (set instanceof SetPoly) {
+    return set.__setData__.slice();
+  } // if not using SetPoly as set, it means Array.from is supported
+  // eslint-disable-next-line compat/compat
+
+
+  return Array.from(set);
+}
+/**
+ * return the Set constructor to use. If `Array.from` built-in or native Set is not available or it doesn't support the required features,
+ * a ponyfill with minimal features is returned instead.
+ */
+
+function getSetConstructor() {
+  // eslint-disable-next-line compat/compat
+  if (typeof Array.from === 'function' && typeof Set === 'function' && Set.prototype && Set.prototype.values) {
+    return Set;
+  }
+
+  return SetPoly;
+}
+
+export var _Set = getSetConstructor();

package/es/utils/lang/index.js

@@ -0,0 +1,305 @@
+/**
+ * Checks if the target string starts with the sub string.
+ */
+export function startsWith(target, sub) {
+  if (!(isString(target) && isString(sub))) {
+    return false;
+  }
+
+  return target.slice(0, sub.length) === sub;
+}
+/**
+ * Checks if the target string ends with the sub string.
+ */
+
+export function endsWith(target, sub, caseInsensitive) {
+  if (caseInsensitive === void 0) {
+    caseInsensitive = false;
+  }
+
+  if (!(isString(target) && isString(sub))) {
+    return false;
+  }
+
+  if (caseInsensitive) {
+    target = target.toLowerCase();
+    sub = sub.toLowerCase();
+  }
+
+  return target.slice(target.length - sub.length) === sub;
+}
+/**
+ * Safely retrieve the specified prop from obj. If we can't retrieve
+ * that property value, we return the default value.
+ */
+
+export function get(obj, prop, val) {
+  var res = val;
+
+  try {
+    // No risks nor lots of checks.
+    var pathPieces = prop.split('.');
+    var partial = obj;
+    pathPieces.forEach(function (pathPiece) {
+      return partial = partial[pathPiece];
+    });
+    if (typeof partial !== 'undefined') res = partial;
+  } catch (e) {// noop
+  }
+
+  return res;
+}
+/**
+ * Evaluates iteratee for each element of the source array. Returns the index of the first element
+ * for which iteratee returns truthy. If no element is found or there's an issue with the params it returns -1.
+ */
+
+export function findIndex(source, iteratee) {
+  if (Array.isArray(source) && typeof iteratee === 'function') {
+    for (var i = 0; i < source.length; i++) {
+      if (iteratee(source[i], i, source) === true) {
+        return i;
+      }
+    }
+  }
+
+  return -1;
+}
+/**
+ * Loops through a source collection (an object or an array) running iteratee
+ * against each element. It returns the first element for which iteratee returned
+ * a truthy value and stops the loop.
+ * Iteratee receives three arguments (element, key/index, collection)
+ */
+
+export function find(source, iteratee) {
+  var res;
+
+  if (isObject(source)) {
+    var keys = Object.keys(source);
+
+    for (var i = 0; i < keys.length && !res; i++) {
+      var key = keys[i];
+      var iterateeResult = iteratee(source[key], key, source);
+      if (iterateeResult) res = source[key];
+    }
+  } else if (Array.isArray(source)) {
+    for (var _i = 0; _i < source.length && !res; _i++) {
+      var _iterateeResult = iteratee(source[_i], _i, source);
+
+      if (_iterateeResult) res = source[_i];
+    }
+  }
+
+  return res;
+}
+/**
+ * Checks if a given value is a string.
+ */
+
+export function isString(val) {
+  return typeof val === 'string' || val instanceof String;
+}
+/**
+ * Checks if a given value is a finite value of number type or Number object.
+ * Unlike `Number.isFinite`, it also tests Number object instances.
+ * Unlike global `isFinite`, it returns false if the value is not a number or Number object instance.
+ * @TODO remove `isFinite` once `Number.isFinite` is fully supported by targets
+ */
+
+export function numberIsFinite(val) {
+  if (val instanceof Number) val = val.valueOf(); // eslint-disable-next-line compat/compat
+
+  if (typeof val === 'number') return Number.isFinite ? Number.isFinite(val) : isFinite(val);
+  return false;
+}
+/**
+ * Checks if a given value is a NaN value of number type or Number object.
+ * Unlike `Number.isNaN`, it also tests Number object instances.
+ * Unlike global `isNan`, it returns false if the value is not a number or Number object instance.
+ */
+
+export function numberIsNaN(val) {
+  if (val instanceof Number) val = val.valueOf(); // @TODO replace with `Number.isNaN` once it is fully supported by targets
+  // eslint-disable-next-line eqeqeq
+
+  return val !== val;
+}
+/**
+ * Checks if a given value is an integer value of number type or Number object.
+ * Unlike `Number.isInteger`, it also tests Number object instances.
+ * @TODO remove shim once `Number.isInteger` is fully supported by targets
+ */
+
+export function numberIsInteger(val) {
+  if (val instanceof Number) val = val.valueOf(); // eslint-disable-next-line compat/compat
+
+  if (typeof val === 'number') return Number.isInteger ? Number.isInteger(val) : isFinite(val) && Math.floor(val) === val;
+  return false;
+}
+var uniqueIdCounter = -1;
+/**
+ * Returns a number to be used as ID, which will be unique.
+ */
+
+export function uniqueId() {
+  return uniqueIdCounter++;
+}
+/**
+ * Validates if a value is an object.
+ */
+
+export function isObject(obj) {
+  return obj && typeof obj === 'object' && obj.constructor === Object;
+}
+/**
+ * There are some assumptions here. It's for internal use and we don't need verbose errors
+ * or to ensure the data types or whatever. Parameters should always be correct (at least have a target and a source, of type object).
+ */
+
+export function merge(target, source) {
+  var res = target;
+  isObject(source) && Object.keys(source).forEach(function (key) {
+    var val = source[key];
+
+    if (isObject(val)) {
+      if (res[key] && isObject(res[key])) {
+        // If both are objects, merge into a new one.
+        val = merge({}, res[key], val);
+      } else {
+        // else make a copy.
+        val = merge({}, val);
+      }
+    } // We skip undefined values.
+
+
+    if (val !== undefined) res[key] = val;
+  });
+
+  for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    rest[_key - 2] = arguments[_key];
+  }
+
+  if (rest && rest.length) {
+    var nextSource = rest.splice(0, 1)[0];
+    res = merge.apply(void 0, [res, nextSource].concat(rest));
+  }
+
+  return res;
+}
+/**
+ * Removes duplicate items on an array of strings.
+ */
+
+export function uniq(arr) {
+  var seen = {};
+  return arr.filter(function (item) {
+    return Object.prototype.hasOwnProperty.call(seen, item) ? false : seen[item] = true;
+  });
+}
+/**
+ * Removes duplicate items on an array of objects using an optional `stringify` function as equality criteria.
+ * It uses JSON.stringify as default criteria.
+ */
+
+export function unicAsStrings(arr, stringify) {
+  if (stringify === void 0) {
+    stringify = JSON.stringify;
+  }
+
+  var seen = {};
+  return arr.filter(function (item) {
+    var itemString = stringify(item);
+    return Object.prototype.hasOwnProperty.call(seen, itemString) ? false : seen[itemString] = true;
+  });
+}
+/**
+ * Transforms a value into it's string representation.
+ */
+
+export function toString(val) {
+  if (val == null) return '';
+  if (typeof val === 'string') return val;
+  if (Array.isArray(val)) return val.map(function (val) {
+    return isString(val) ? val : '';
+  }) + '';
+  var result = val + '';
+  return result === '0' && 1 / val === Number.NEGATIVE_INFINITY ? '-0' : result;
+}
+/**
+ * Transforms a value into a number.
+ * Note: We're not expecting anything fancy here. If we are at some point, add more type checks.
+ */
+
+export function toNumber(val) {
+  if (typeof val === 'number') return val;
+
+  if (isObject(val) && typeof val.valueOf === 'function') {
+    var valOf = val.valueOf();
+    val = isObject(valOf) ? valOf + '' : valOf;
+  }
+
+  if (typeof val !== 'string') {
+    return val === 0 ? val : +val;
+  } // Remove trailing whitespaces.
+
+
+  val = val.replace(/^\s+|\s+$/g, '');
+  return +val;
+}
+/**
+ * Executes iteratee for given obj own props.
+ */
+
+export function forOwn(obj, iteratee) {
+  var keys = Object.keys(obj);
+  keys.forEach(function (key) {
+    return iteratee(obj[key], key, obj);
+  });
+  return obj;
+}
+/**
+ * Parses an array into a map of different arrays, grouping by the specified prop value.
+ */
+
+export function groupBy(source, prop) {
+  var map = {};
+
+  if (Array.isArray(source) && isString(prop)) {
+    for (var i = 0; i < source.length; i++) {
+      var key = source[i][prop]; // Skip the element if the key is not a string.
+
+      if (isString(key)) {
+        if (!map[key]) map[key] = [];
+        map[key].push(source[i]);
+      }
+    }
+  }
+
+  return map;
+}
+/**
+ * Returns the name of a given function.
+ */
+
+export function getFnName(fn) {
+  if (fn.name) return fn.name;
+  return (fn.toString().match(/function (.+?)\(/) || ['', ''])[1];
+}
+/**
+ * Shallow clone an object
+ */
+
+export function shallowClone(obj) {
+  var keys = Object.keys(obj);
+  var output = {};
+
+  for (var i = 0; i < keys.length; i++) {
+    output[keys[i]] = obj[keys[i]];
+  }
+
+  return output;
+}
+export function isBoolean(val) {
+  return val === true || val === false;
+}

package/es/utils/localstorage/isAvailable.js

@@ -0,0 +1,26 @@
+/**
+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 isLocalStorageAvailable() {
+  var mod = '__SPLITSOFTWARE__';
+
+  try {
+    localStorage.setItem(mod, mod);
+    localStorage.removeItem(mod);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}

package/es/utils/logger/LoggerFactory.js

@@ -0,0 +1,86 @@
+/* eslint-disable no-console */
+'use strict';
+
+import objectAssign from 'object-assign';
+export var LogLevels = {
+  'DEBUG': 'DEBUG',
+  'INFO': 'INFO',
+  'WARN': 'WARN',
+  'ERROR': 'ERROR',
+  'NONE': 'NONE'
+};
+var LogLevelIndexes = {
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  NONE: 5
+}; // DEBUG is the default. The log level is not specific to an SDK instance.
+
+var GlobalLogLevel = LogLevelIndexes.DEBUG;
+/**
+ * @param {'DEBUG'|'INFO'|'WARN'|'ERROR'|'NONE'} level
+ */
+
+export var setLogLevel = function setLogLevel(level) {
+  GlobalLogLevel = LogLevelIndexes[level];
+};
+var defaultOptions = {
+  showLevel: true,
+  displayAllErrors: false
+};
+export var Logger = /*#__PURE__*/function () {
+  function Logger(category, options) {
+    this.category = category;
+    this.options = objectAssign({}, defaultOptions, options);
+  }
+
+  var _proto = Logger.prototype;
+
+  _proto.debug = function debug(msg) {
+    if (this._shouldLog(LogLevelIndexes.DEBUG)) this._log(LogLevels.DEBUG, msg);
+  };
+
+  _proto.info = function info(msg) {
+    if (this._shouldLog(LogLevelIndexes.INFO)) this._log(LogLevels.INFO, msg);
+  };
+
+  _proto.warn = function warn(msg) {
+    if (this._shouldLog(LogLevelIndexes.WARN)) this._log(LogLevels.WARN, msg);
+  };
+
+  _proto.error = function error(msg) {
+    if (this.options.displayAllErrors || this._shouldLog(LogLevelIndexes.ERROR)) this._log(LogLevels.ERROR, msg);
+  };
+
+  _proto._log = function _log(level, text) {
+    var formattedText = this._generateLogMessage(level, text);
+
+    console.log(formattedText);
+  };
+
+  _proto._generateLogMessage = function _generateLogMessage(level, text) {
+    var textPre = ' => ';
+    var result = '';
+
+    if (this.options.showLevel) {
+      result += '[' + level + ']' + (level === LogLevels.INFO || level === LogLevels.WARN ? ' ' : '') + ' ';
+    }
+
+    if (this.category) {
+      result += this.category + textPre;
+    }
+
+    return result += text;
+  }
+  /**
+   * @param {number} level
+   */
+  ;
+
+  _proto._shouldLog = function _shouldLog(level) {
+    return level >= GlobalLogLevel;
+  };
+
+  return Logger;
+}();

package/es/utils/logger/index.js

@@ -0,0 +1,97 @@
+/**
+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 { Logger, LogLevels, setLogLevel as _setLogLevel } from './LoggerFactory';
+import isLocalStorageAvailable from '../localstorage/isAvailable';
+import { find, merge } from '../lang';
+
+var isLogLevelString = function isLogLevelString(str) {
+  return !!find(LogLevels, function (lvl) {
+    return str === lvl;
+  });
+};
+
+var defaultOptions = {
+  showLevel: true,
+  displayAllErrors: false
+};
+var LS_KEY = 'splitio_debug';
+var ENV_VAR_KEY = 'SPLITIO_DEBUG';
+var isNode = false; // We check for version truthiness since most shims will have that as empty string.
+
+if (typeof process !== 'undefined' && typeof process.version !== 'undefined' && !!process.version) {
+  isNode = true;
+}
+
+var initialState = String(isNode ? process.env[ENV_VAR_KEY] : isLocalStorageAvailable() ? localStorage.getItem(LS_KEY) : '');
+
+var createLog = function createLog(namespace, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  return new Logger(namespace, merge(options, defaultOptions));
+};
+
+var ownLog = createLog('splitio-utils:logger');
+/**
+ * The public Logger utility API.
+ */
+
+export var API = {
+  /**
+   * Enables all the logs.
+   */
+  enable: function enable() {
+    _setLogLevel(LogLevels.DEBUG);
+  },
+
+  /**
+   * Sets a custom log Level for the SDK.
+   * @param {string} logLevel - Custom LogLevel value.
+   */
+  setLogLevel: function setLogLevel(logLevel) {
+    if (isLogLevelString(logLevel)) {
+      _setLogLevel(logLevel);
+    } else {
+      ownLog.error('Invalid Log Level - No changes to the logs will be applied.');
+    }
+  },
+
+  /**
+   * Disables all the log levels.
+   */
+  disable: function disable() {
+    // Disabling is equal logLevel none
+    _setLogLevel(LogLevels.NONE);
+  },
+
+  /**
+   * Exposed for usage with setLogLevel
+   */
+  LogLevel: LogLevels
+}; // "enable", "enabled" and "on", are synonims with 'DEBUG' loglevel
+
+if (/^(enabled?|on)/i.test(initialState)) {
+  API.enable(LogLevels.DEBUG);
+} else if (isLogLevelString(initialState)) {
+  API.setLogLevel(initialState);
+} else {
+  // By default it starts disabled.
+  API.disable();
+} // By default we expose logger instance creator wrapper.
+
+
+export default createLog;