@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/utils/lang/index.ts

@@ -1,279 +0,0 @@
-/**
- * Checks if the target string ends with the sub string.
- */
-export function endsWith(target: any, sub: any, caseInsensitive = false): boolean {
-  if (!(isString(target) && isString(sub))) {
-    return false;
-  }
-  if (caseInsensitive) {
-    target = target.toLowerCase();
-    sub = sub.toLowerCase();
-  }
-  return target.slice(target.length - sub.length) === sub;
-}
-
-/**
- * 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<T extends any[] | Record<string, any>, V = T extends any[] ? T[0] : T[keyof T], K = T extends any[] ? number : keyof T & string>(source: T | null | undefined, iteratee: (value: V, key: K, source: T) => boolean): V | undefined {
-  let res;
-
-  if (isObject(source)) {
-    const keys = Object.keys(source as T);
-    for (let i = 0; i < keys.length && !res; i++) {
-      const key = keys[i];
-      const iterateeResult = iteratee((source as Record<string, any>)[key], key as unknown as K, source as T);
-
-      if (iterateeResult) res = (source as Record<string, V>)[key];
-    }
-  } else if (Array.isArray(source)) {
-    for (let i = 0; i < (source as V[]).length && !res; i++) {
-      const iterateeResult = iteratee(source[i], i as unknown as K, source);
-
-      if (iterateeResult) res = source[i];
-    }
-  }
-
-  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<T>(source: T[], iteratee: (value: T, index: number, source: T[]) => boolean): number {
-  if (Array.isArray(source) && typeof iteratee === 'function') {
-    for (let i = 0; i < source.length; i++) {
-      if (iteratee(source[i], i, source) === true) {
-        return i;
-      }
-    }
-  }
-
-  return -1;
-}
-
-/**
- * Executes iteratee for given obj own props.
- */
-export function forOwn<T>(obj: { [key: string]: T }, iteratee: (value: T, key: string, obj: { [key: string]: T }) => any): { [key: string]: T } {
-  const keys = Object.keys(obj);
-
-  keys.forEach(key => iteratee(obj[key], key, obj));
-
-  return obj;
-}
-
-/**
- * Safely retrieve the specified prop from obj. If we can't retrieve
- * that property value, we return the default value.
- */
-export function get(obj: any, prop: any, val?: any): any {
-  let res = val;
-
-  try { // No risks nor lots of checks.
-    const pathPieces: string[] = prop.split('.');
-    let partial: { [key: string]: any } = obj;
-    pathPieces.forEach(pathPiece => partial = partial[pathPiece]);
-
-    if (typeof partial !== 'undefined') res = partial;
-  } catch (e) {
-    // noop
-  }
-  return res;
-}
-
-/**
- * Parses an array into a map of different arrays, grouping by the specified prop value.
- */
-export function groupBy<T extends Record<string, any>>(source: T[], prop: string): Record<string, T[]> {
-  const map: Record<string, any[]> = {};
-
-  if (Array.isArray(source) && isString(prop)) {
-    for (let i = 0; i < source.length; i++) {
-      const 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;
-}
-
-/**
- * Checks if a given value is a boolean.
- */
-export function isBoolean(val: any): val is boolean {
-  return val === true || val === false;
-}
-
-/**
- * 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.
- */
-export function isFiniteNumber(val: any): val is number {
-  if (val instanceof Number) val = val.valueOf();
-  return typeof val === 'number' ?
-    Number.isFinite ? Number.isFinite(val) : isFinite(val) :
-    false;
-}
-
-/**
- * Checks if a given value is an integer value of number type or Number object.
- * Unlike `Number.isInteger`, it also tests Number object instances.
- */
-export function isIntegerNumber(val: any): boolean {
-  if (val instanceof Number) val = val.valueOf();
-  return typeof val === 'number' ?
-    Number.isInteger ? Number.isInteger(val) : isFinite(val) && Math.floor(val) === val :
-    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 isNaNNumber(val: any): boolean {
-  if (val instanceof Number) val = val.valueOf();
-  // @TODO replace with `Number.isNaN` once it is fully supported by targets
-  return val !== val;
-}
-
-/**
- * Validates if a value is an object created by the Object constructor (plain object).
- * It checks `constructor.name` to avoid false negatives when validating values on a separate VM context, which has its own global built-ins.
- */
-export function isObject(obj: any) {
-  return obj !== null && typeof obj === 'object' && (
-    obj.constructor === Object ||
-    (obj.constructor != null && obj.constructor.name === 'Object')
-  );
-}
-
-/**
- * Checks if a given value is a string.
- */
-export function isString(val: any): val is string {
-  return typeof val === 'string' || val instanceof String;
-}
-
-/**
- * String sanitizer. Returns the provided value converted to uppercase if it is a string.
- */
-export function stringToUpperCase(val: any) {
-  return isString(val) ? val.toUpperCase() : val;
-}
-
-/**
- * Deep copy version of Object.assign using recursion.
- * 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: { [key: string]: any }, source: { [key: string]: any }, ...rest: any[]): object {
-  let res = target;
-
-  isObject(source) && Object.keys(source).forEach(key => {
-    let 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;
-  });
-
-  if (rest && rest.length) {
-    const nextSource = rest.splice(0, 1)[0];
-    res = merge(res, nextSource, ...rest);
-  }
-
-  return res;
-}
-
-/**
- * Checks if the target string starts with the sub string.
- */
-export function startsWith(target: any, sub: any): boolean {
-  if (!(isString(target) && isString(sub))) {
-    return false;
-  }
-  return target.slice(0, sub.length) === sub;
-}
-
-/**
- * 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: any): number {
-  if (typeof val === 'number') return val;
-
-  if (isObject(val) && typeof val.valueOf === 'function') {
-    const 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;
-}
-
-/**
- * Transforms a value into it's string representation.
- */
-export function toString(val: any): string {
-  if (val == null) return '';
-  if (typeof val === 'string') return val;
-  if (Array.isArray(val)) return val.map(val => isString(val) ? val : '') + '';
-
-  let result = val + '';
-  return (result === '0' && (1 / val) === Number.NEGATIVE_INFINITY) ? '-0' : result;
-}
-/**
- * Removes duplicate items on an array of strings.
- */
-export function uniq(arr: string[]): string[] {
-  const seen: Record<string, boolean> = {};
-  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 uniqAsStrings<T>(arr: T[], stringify: (value: T) => string = JSON.stringify): T[] {
-  const seen: Record<string, boolean> = {};
-  return arr.filter(function (item) {
-    const itemString = stringify(item);
-    return Object.prototype.hasOwnProperty.call(seen, itemString) ? false : seen[itemString] = true;
-  });
-}
-
-let uniqueIdCounter = -1;
-
-/**
- * Returns a number to be used as ID, which will be unique.
- */
-export function uniqueId(): number {
-  return uniqueIdCounter++;
-}

package/src/utils/lang/objectAssign.ts

@@ -1,25 +0,0 @@
-/**
- * A tiny polyfill for Object.assign
- */
-
-// https://www.npmjs.com/package/@types/object-assign
-type ObjectAssign = (<T, U>(target: T, source: U) => T & U) &
-  (<T, U, V>(target: T, source1: U, source2: V) => T & U & V) &
-  (<T, U, V, W>(target: T, source1: U, source2: V, source3: W) => T & U & V & W) &
-  (<T, U, V, W, Q>(target: T, source1: U, source2: V, source3: W, source4: Q) => T & U & V & W & Q) &
-  (<T, U, V, W, Q, R>(target: T, source1: U, source2: V, source3: W, source4: Q, source5: R) => T & U & V & W & Q & R) &
-  ((target: any, ...sources: any[]) => any);
-export const objectAssign: ObjectAssign = Object.assign || function (target: any) {
-  if (target === null || target === undefined) throw new TypeError('Object.assign cannot be called with null or undefined');
-  target = Object(target);
-
-  for (let i = 1; i < arguments.length; i++) {
-    const source = Object(arguments[i]); // eslint-disable-next-line no-restricted-syntax
-    for (const key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
-        target[key] = source[key];
-      }
-    }
-  }
-  return target;
-};

package/src/utils/lang/sets.ts

@@ -1,17 +0,0 @@
-export function setToArray<T>(set: Set<T>): T[] {
-  if (Array.from) return Array.from(set);
-
-  const array: T[] = [];
-  set.forEach((value: T) => {
-    array.push(value);
-  });
-  return array;
-}
-
-export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
-  return new Set(setToArray(set).concat(setToArray(set2)));
-}
-
-export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {
-  return list.filter(item => list2.indexOf(item) === -1);
-}

package/src/utils/murmur3/common.ts

@@ -1,54 +0,0 @@
-import { stringSource, stringDestination, encodeUTF16toUTF8 } from './utfx';
-
-export function UTF16ToUTF8(key: string) {
-  let sd;
-
-  encodeUTF16toUTF8(
-    stringSource(key),
-    sd = stringDestination()
-  );
-
-  return sd();
-}
-
-/*!
- * +----------------------------------------------------------------------------------+
- * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
- * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
- * |----------------------------------------------------------------------------------|
- * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
- * +----------------------------------------------------------------------------------+
- */
-
-export function x86Multiply(m: number, n: number) {
-  //
-  // Given two 32bit ints, returns the two multiplied together as a
-  // 32bit int.
-  //
-
-  return ((m & 0xffff) * n) + ((((m >>> 16) * n) & 0xffff) << 16);
-}
-
-
-export function x86Rotl(m: number, n: number) {
-  //
-  // Given a 32bit int and an int representing a number of bit positions,
-  // returns the 32bit int rotated left by that number of positions.
-  //
-
-  return (m << n) | (m >>> (32 - n));
-}
-
-export function x86Fmix(h: number) {
-  //
-  // Given a block, returns murmurHash3's final x86 mix of that block.
-  //
-
-  h ^= h >>> 16;
-  h = x86Multiply(h, 0x85ebca6b);
-  h ^= h >>> 13;
-  h = x86Multiply(h, 0xc2b2ae35);
-  h ^= h >>> 16;
-
-  return h;
-}

package/src/utils/murmur3/legacy.ts

@@ -1,48 +0,0 @@
-// Deprecated hashing function, used for split bucketing. Replaced by murmur3
-
-//
-// JAVA reference implementation for the hashing function.
-//
-// int h = 0;
-// for (int i = 0; i < key.length(); i++) {
-//     h = 31 * h + key.charAt(i);
-// }
-// return h ^ seed; // XOR the hash and seed
-//
-
-function ToInteger(x: number) {
-  x = Number(x);
-  return x < 0 ? Math.ceil(x) : Math.floor(x);
-}
-
-function modulo(a: number, b: number) {
-  return a - Math.floor(a / b) * b;
-}
-
-function ToUint32(x: number) {
-  return modulo(ToInteger(x), Math.pow(2, 32));
-}
-
-function ToInt32(x: number) {
-  let uint32 = ToUint32(x);
-
-  if (uint32 >= Math.pow(2, 31)) {
-    return uint32 - Math.pow(2, 32);
-  } else {
-    return uint32;
-  }
-}
-
-export function hash(str: string, seed: number): number {
-  let h = 0;
-
-  for (let i = 0; i < str.length; i++) {
-    h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
-  }
-
-  return ToInt32(h ^ seed);
-}
-
-export function bucket(str: string, seed: number): number {
-  return Math.abs(hash(str, seed) % 100) + 1;
-}

package/src/utils/murmur3/murmur3.ts

@@ -1,74 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './common';
-
-/*
- * +----------------------------------------------------------------------------------+
- * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
- * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
- * |----------------------------------------------------------------------------------|
- * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
- * +----------------------------------------------------------------------------------+
- */
-
-// PUBLIC FUNCTIONS
-// ----------------
-function hash32(key?: string, seed?: number) {
-  //
-  // Given a string and an optional seed as an int, returns a 32 bit hash
-  // using the x86 flavor of MurmurHash3, as an unsigned int.
-  //
-
-  key = key || '';
-  seed = seed || 0;
-
-  var remainder = key.length % 4;
-  var bytes = key.length - remainder;
-
-  var h1 = seed;
-
-  var k1 = 0;
-
-  var c1 = 0xcc9e2d51;
-  var c2 = 0x1b873593;
-
-  for (var i = 0; i < bytes; i = i + 4) {
-    k1 = ((key.charCodeAt(i) & 0xff)) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
-
-    k1 = x86Multiply(k1, c1);
-    k1 = x86Rotl(k1, 15);
-    k1 = x86Multiply(k1, c2);
-
-    h1 ^= k1;
-    h1 = x86Rotl(h1, 13);
-    h1 = x86Multiply(h1, 5) + 0xe6546b64;
-  }
-
-  k1 = 0;
-
-  switch (remainder) {
-    case 3:
-      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
-    case 2:
-      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
-
-    case 1:
-      k1 ^= (key.charCodeAt(i) & 0xff);
-      k1 = x86Multiply(k1, c1);
-      k1 = x86Rotl(k1, 15);
-      k1 = x86Multiply(k1, c2);
-      h1 ^= k1;
-  }
-
-  h1 ^= key.length;
-  h1 = x86Fmix(h1);
-
-  return h1 >>> 0;
-}
-
-export function hash(str: string, seed?: number): number {
-  return hash32(UTF16ToUTF8(str), seed as number >>> 0);
-}
-
-export function bucket(str: string, seed?: number): number {
-  return Math.abs(hash(str, seed) % 100) + 1;
-}