@s3p-js-deep-purple/utils 0.0.1-security → 1.1.99

package/dist/s3p-js-deep-purple-utils.cjs.prod.js

@@ -0,0 +1,310 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var get = require('lodash/get');
+var isEmpty = require('lodash/isEmpty');
+var isBoolean = require('lodash/isBoolean');
+var isNumber = require('lodash/isNumber');
+var isPlainObject = require('lodash/isPlainObject');
+var transform = require('lodash/transform');
+var set = require('lodash/set');
+var isObjectLike = require('lodash/isObjectLike');
+var camelCase = require('lodash/camelCase');
+var snakeCase = require('lodash/snakeCase');
+var isObject = require('lodash/isObject');
+var isArray = require('lodash/isArray');
+var isNil = require('lodash/isNil');
+var reduce = require('lodash/reduce');
+var qs = require('qs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var get__default = /*#__PURE__*/_interopDefault(get);
+var isEmpty__default = /*#__PURE__*/_interopDefault(isEmpty);
+var isBoolean__default = /*#__PURE__*/_interopDefault(isBoolean);
+var isNumber__default = /*#__PURE__*/_interopDefault(isNumber);
+var isPlainObject__default = /*#__PURE__*/_interopDefault(isPlainObject);
+var transform__default = /*#__PURE__*/_interopDefault(transform);
+var set__default = /*#__PURE__*/_interopDefault(set);
+var isObjectLike__default = /*#__PURE__*/_interopDefault(isObjectLike);
+var camelCase__default = /*#__PURE__*/_interopDefault(camelCase);
+var snakeCase__default = /*#__PURE__*/_interopDefault(snakeCase);
+var isObject__default = /*#__PURE__*/_interopDefault(isObject);
+var isArray__default = /*#__PURE__*/_interopDefault(isArray);
+var isNil__default = /*#__PURE__*/_interopDefault(isNil);
+var reduce__default = /*#__PURE__*/_interopDefault(reduce);
+var qs__default = /*#__PURE__*/_interopDefault(qs);
+
+const toPath = path => Array.isArray(path) ? path.filter(Boolean).join('.') : path || '';
+
+const unique = array => Array.from(new Set(array));
+const pluck = (array, field) => array.map(obj => get__default["default"](obj || {}, field));
+const pluckUnique = function () {
+  return unique(pluck(...arguments));
+};
+const flatMap = (array, field) => array.reduce((newArray, obj) => {
+  newArray.push(...(obj || {})[field]);
+  return newArray;
+}, []);
+const indexByKeyValue = (items, propKey, propValue) => (items || []).reduce((object, item) => {
+  const key = item[propKey];
+
+  if (key) {
+    object[key] = propValue ? item[propValue] : item;
+  }
+
+  return object;
+}, {});
+const lowestValue = (array, field) => Math.min(...array.map(object => object[field]));
+
+const isEmptyValue = value => value === undefined || typeof value === 'number' && Number.isNaN(value) || typeof value === 'string' && value.trim().length === 0 || Array.isArray(value) && value.length === 0 || value === null;
+const hasValue = value => !isEmptyValue(value);
+
+/**
+ * Abbreviate a sentence.
+ * John Doe becomes J.D.
+ * @param sentence
+ * @return {string}
+ */
+
+const abbreviate = sentence => sentence.trim().split(' ').map(word => word.length ? `${word[0].toUpperCase()}.` : '').join('');
+/**
+ * Remove spaces from a string
+ * @param value
+ * @returns {string}
+ */
+
+const removeSpaces = value => typeof value === 'string' ? value.replace(/\s/g, '') : value;
+/**
+ * trim spaces on both ends from a string
+ * @param value
+ * @returns {string}
+ */
+
+const trimSpaces = value => typeof value === 'string' ? value.trim() : value;
+/**
+ * A value is 'blank' if it's null, undefined, an empty array [], empty object {}, empty set or empty map.
+ * The difference with lodash's isEmpty, is that it evaluates numbers and booleans as truthy.
+ * @example
+ *
+ * isBlank(null)
+ * // => true
+ *
+ * isBlank({})
+ * // => true
+ *
+ * isBlank([])
+ * // => true
+ *
+ * isBlank(new Map())
+ * // => true
+ *
+ * isBlank(false)
+ * // => false
+ *
+ * isBlank(1);
+ * // => false
+ *
+ * isBlank([1, 2, 3])
+ * // => false
+ *
+ * isBlank({ 'a': 1 })
+ * // => false
+ *
+ * @param value
+ * @returns {boolean}
+ */
+
+const isBlank = value => Boolean(isEmpty__default["default"](value) && !isBoolean__default["default"](value) && !isNumber__default["default"](value));
+const parseJWT = token => {
+  const base64Url = token.split('.')[1];
+  const base64 = base64Url.replace('-', '+').replace('_', '/');
+  return JSON.parse(window.atob(base64));
+};
+const convertUnicode = value => value.replace(/\\u(\w\w\w\w)/g, (_, match) => String.fromCharCode(parseInt(match, 16)));
+
+const toHash = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '/';
+  return value.replace(/[/.]/g, '|');
+};
+
+/**
+ * Handle floating point precision. 0.2 + 0.1 = 0.30000000000000004
+ * @param {Number|String} value
+ * @return {Number}
+ */
+const toNumeric = value => Number(parseFloat(value).toPrecision(12));
+/**
+ * Cap a value between a min and max value, so it stays within bounds
+ * @param {Number} value
+ * @param {Number} minValue
+ * @param {Number} maxValue
+ * @return {Number}
+ */
+
+const clamp = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  let minValue = arguments.length > 1 ? arguments[1] : undefined;
+  let maxValue = arguments.length > 2 ? arguments[2] : undefined;
+  return Math.min(Math.max(toNumeric(value), minValue), maxValue);
+};
+/**
+ * Check if the value is a number according to React number input validation
+ * @param value
+ * @return {Boolean}
+ */
+
+const isReactNumeric = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return String(value).match(/^-?(\d+|\d+\.\d+|\.\d+)([eE][-+]?\d+)?$/) !== null;
+};
+/**
+ * Check if the value can become a number according to React number input validation
+ * @param value
+ * @return {Boolean}
+ */
+
+const isReactNumericIncomplete = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return String(value).match(/(?!^-?\d+$)^-?(\d+\.?)([eE][-+]?)?$/) !== null;
+};
+/**
+ * Transforms a scientific number (1e7) to a string (0.000001)
+ * @param value
+ * @return {string}
+ */
+
+const toFixed = value => Number(value).toFixed(20).replace(/\.?0+$/, '');
+
+// eslint-disable-next-line no-warning-comments
+// todo: this does not belong in a generic utils lib, move this to implementation
+const s3ApiKeyMap = [['_u_i_c_station_code', 'UICStationCode'], ['origin_uic', 'originUIC'], ['destination_uic', 'destinationUIC']];
+const camelCaseInflectorMap = new Map(s3ApiKeyMap);
+const snakeCaseInflectorMap = s3ApiKeyMap.reduce((map, inflection) => {
+  return map.set(inflection[1], inflection[0]);
+}, new Map());
+
+const convertWithInflectorCreator = (inflector, keyConverter) => key => inflector.has(key) ? inflector.get(key) : keyConverter(key);
+
+const deepConvertKeys = function (keyConverter) {
+  let whiteListChildren = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  const convertKeys = (node, parentKey) => {
+    if (Array.isArray(node)) return node.map(convertKeys);
+
+    if (isPlainObject__default["default"](node)) {
+      return transform__default["default"](node, (result, value, key) => {
+        const _key = whiteListChildren.includes(parentKey) ? key : keyConverter(key);
+
+        return set__default["default"](result, _key, isObjectLike__default["default"](value) ? convertKeys(value, _key) : value);
+      });
+    }
+
+    return node;
+  };
+
+  return convertKeys;
+};
+const deepConvertValues = valueConvertor => {
+  let originalNode;
+
+  const convertValues = node => {
+    originalNode = originalNode || node;
+    if (Array.isArray(node)) return node.map(convertValues);
+
+    if (isPlainObject__default["default"](node)) {
+      return transform__default["default"](node, (result, value, key) => {
+        const _value = isObjectLike__default["default"](value) ? convertValues(value) : valueConvertor(key, value, originalNode);
+
+        return set__default["default"](result, key, _value);
+      });
+    }
+
+    return node;
+  };
+
+  return convertValues;
+};
+const deepCamelCaseKeys = deepConvertKeys(convertWithInflectorCreator(camelCaseInflectorMap, camelCase__default["default"]));
+const deepSnakeCaseKeys = deepConvertKeys(convertWithInflectorCreator(snakeCaseInflectorMap, snakeCase__default["default"]));
+
+const omitByPredicateDeep = (obj, predicate) => {
+  return reduce__default["default"](obj, (result, value, key) => {
+    if (isObject__default["default"](value) || isArray__default["default"](value)) {
+      if (isArray__default["default"](result)) {
+        result.push(omitByPredicateDeep(value, predicate));
+      } else {
+        result[key] = omitByPredicateDeep(value, predicate);
+      }
+    } else if (!predicate(value)) {
+      if (isArray__default["default"](result)) {
+        result.push(value);
+      } else {
+        result[key] = value;
+      }
+    }
+
+    return result;
+  }, isArray__default["default"](obj) ? [] : {});
+};
+/**
+ * Recursively remove all nil values deeply nested properties of objects and arrays
+ *
+ * note: do not use for cyclical object or Date properties
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+
+const omitNilDeep = obj => omitByPredicateDeep(obj, value => isNil__default["default"](value));
+
+const stringifyQueryEncode = query => qs__default["default"].stringify(query, {
+  encode: true,
+  skipNulls: true
+});
+const parseQueryString = queryString => qs__default["default"].parse(queryString, {
+  ignoreQueryPrefix: true,
+  decoder: (value, decoder) => {
+    const keywords = {
+      true: true,
+      false: false,
+      null: null,
+      undefined
+    };
+
+    if (value in keywords) {
+      return keywords[value];
+    }
+
+    return decoder(value);
+  }
+});
+
+exports.abbreviate = abbreviate;
+exports.clamp = clamp;
+exports.convertUnicode = convertUnicode;
+exports.deepCamelCaseKeys = deepCamelCaseKeys;
+exports.deepConvertKeys = deepConvertKeys;
+exports.deepConvertValues = deepConvertValues;
+exports.deepSnakeCaseKeys = deepSnakeCaseKeys;
+exports.flatMap = flatMap;
+exports.hasValue = hasValue;
+exports.indexByKeyValue = indexByKeyValue;
+exports.isBlank = isBlank;
+exports.isEmptyValue = isEmptyValue;
+exports.isReactNumeric = isReactNumeric;
+exports.isReactNumericIncomplete = isReactNumericIncomplete;
+exports.lowestValue = lowestValue;
+exports.omitByPredicateDeep = omitByPredicateDeep;
+exports.omitNilDeep = omitNilDeep;
+exports.parseJWT = parseJWT;
+exports.parseQueryString = parseQueryString;
+exports.pluck = pluck;
+exports.pluckUnique = pluckUnique;
+exports.removeSpaces = removeSpaces;
+exports.stringifyQueryEncode = stringifyQueryEncode;
+exports.toFixed = toFixed;
+exports.toHash = toHash;
+exports.toNumeric = toNumeric;
+exports.toPath = toPath;
+exports.trimSpaces = trimSpaces;
+exports.unique = unique;

package/dist/s3p-js-deep-purple-utils.esm.js

@@ -0,0 +1,260 @@
+import get from 'lodash/get';
+import isEmpty from 'lodash/isEmpty';
+import isBoolean from 'lodash/isBoolean';
+import isNumber from 'lodash/isNumber';
+import isPlainObject from 'lodash/isPlainObject';
+import transform from 'lodash/transform';
+import set from 'lodash/set';
+import isObjectLike from 'lodash/isObjectLike';
+import camelCase from 'lodash/camelCase';
+import snakeCase from 'lodash/snakeCase';
+import isObject from 'lodash/isObject';
+import isArray from 'lodash/isArray';
+import isNil from 'lodash/isNil';
+import reduce from 'lodash/reduce';
+import qs from 'qs';
+
+const toPath = path => Array.isArray(path) ? path.filter(Boolean).join('.') : path || '';
+
+const unique = array => Array.from(new Set(array));
+const pluck = (array, field) => array.map(obj => get(obj || {}, field));
+const pluckUnique = function () {
+  return unique(pluck(...arguments));
+};
+const flatMap = (array, field) => array.reduce((newArray, obj) => {
+  newArray.push(...(obj || {})[field]);
+  return newArray;
+}, []);
+const indexByKeyValue = (items, propKey, propValue) => (items || []).reduce((object, item) => {
+  const key = item[propKey];
+
+  if (key) {
+    object[key] = propValue ? item[propValue] : item;
+  }
+
+  return object;
+}, {});
+const lowestValue = (array, field) => Math.min(...array.map(object => object[field]));
+
+const isEmptyValue = value => value === undefined || typeof value === 'number' && Number.isNaN(value) || typeof value === 'string' && value.trim().length === 0 || Array.isArray(value) && value.length === 0 || value === null;
+const hasValue = value => !isEmptyValue(value);
+
+/**
+ * Abbreviate a sentence.
+ * John Doe becomes J.D.
+ * @param sentence
+ * @return {string}
+ */
+
+const abbreviate = sentence => sentence.trim().split(' ').map(word => word.length ? `${word[0].toUpperCase()}.` : '').join('');
+/**
+ * Remove spaces from a string
+ * @param value
+ * @returns {string}
+ */
+
+const removeSpaces = value => typeof value === 'string' ? value.replace(/\s/g, '') : value;
+/**
+ * trim spaces on both ends from a string
+ * @param value
+ * @returns {string}
+ */
+
+const trimSpaces = value => typeof value === 'string' ? value.trim() : value;
+/**
+ * A value is 'blank' if it's null, undefined, an empty array [], empty object {}, empty set or empty map.
+ * The difference with lodash's isEmpty, is that it evaluates numbers and booleans as truthy.
+ * @example
+ *
+ * isBlank(null)
+ * // => true
+ *
+ * isBlank({})
+ * // => true
+ *
+ * isBlank([])
+ * // => true
+ *
+ * isBlank(new Map())
+ * // => true
+ *
+ * isBlank(false)
+ * // => false
+ *
+ * isBlank(1);
+ * // => false
+ *
+ * isBlank([1, 2, 3])
+ * // => false
+ *
+ * isBlank({ 'a': 1 })
+ * // => false
+ *
+ * @param value
+ * @returns {boolean}
+ */
+
+const isBlank = value => Boolean(isEmpty(value) && !isBoolean(value) && !isNumber(value));
+const parseJWT = token => {
+  const base64Url = token.split('.')[1];
+  const base64 = base64Url.replace('-', '+').replace('_', '/');
+  return JSON.parse(window.atob(base64));
+};
+const convertUnicode = value => value.replace(/\\u(\w\w\w\w)/g, (_, match) => String.fromCharCode(parseInt(match, 16)));
+
+const toHash = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '/';
+  return value.replace(/[/.]/g, '|');
+};
+
+/**
+ * Handle floating point precision. 0.2 + 0.1 = 0.30000000000000004
+ * @param {Number|String} value
+ * @return {Number}
+ */
+const toNumeric = value => Number(parseFloat(value).toPrecision(12));
+/**
+ * Cap a value between a min and max value, so it stays within bounds
+ * @param {Number} value
+ * @param {Number} minValue
+ * @param {Number} maxValue
+ * @return {Number}
+ */
+
+const clamp = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  let minValue = arguments.length > 1 ? arguments[1] : undefined;
+  let maxValue = arguments.length > 2 ? arguments[2] : undefined;
+  return Math.min(Math.max(toNumeric(value), minValue), maxValue);
+};
+/**
+ * Check if the value is a number according to React number input validation
+ * @param value
+ * @return {Boolean}
+ */
+
+const isReactNumeric = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return String(value).match(/^-?(\d+|\d+\.\d+|\.\d+)([eE][-+]?\d+)?$/) !== null;
+};
+/**
+ * Check if the value can become a number according to React number input validation
+ * @param value
+ * @return {Boolean}
+ */
+
+const isReactNumericIncomplete = function () {
+  let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return String(value).match(/(?!^-?\d+$)^-?(\d+\.?)([eE][-+]?)?$/) !== null;
+};
+/**
+ * Transforms a scientific number (1e7) to a string (0.000001)
+ * @param value
+ * @return {string}
+ */
+
+const toFixed = value => Number(value).toFixed(20).replace(/\.?0+$/, '');
+
+// eslint-disable-next-line no-warning-comments
+// todo: this does not belong in a generic utils lib, move this to implementation
+const s3ApiKeyMap = [['_u_i_c_station_code', 'UICStationCode'], ['origin_uic', 'originUIC'], ['destination_uic', 'destinationUIC']];
+const camelCaseInflectorMap = new Map(s3ApiKeyMap);
+const snakeCaseInflectorMap = s3ApiKeyMap.reduce((map, inflection) => {
+  return map.set(inflection[1], inflection[0]);
+}, new Map());
+
+const convertWithInflectorCreator = (inflector, keyConverter) => key => inflector.has(key) ? inflector.get(key) : keyConverter(key);
+
+const deepConvertKeys = function (keyConverter) {
+  let whiteListChildren = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  const convertKeys = (node, parentKey) => {
+    if (Array.isArray(node)) return node.map(convertKeys);
+
+    if (isPlainObject(node)) {
+      return transform(node, (result, value, key) => {
+        const _key = whiteListChildren.includes(parentKey) ? key : keyConverter(key);
+
+        return set(result, _key, isObjectLike(value) ? convertKeys(value, _key) : value);
+      });
+    }
+
+    return node;
+  };
+
+  return convertKeys;
+};
+const deepConvertValues = valueConvertor => {
+  let originalNode;
+
+  const convertValues = node => {
+    originalNode = originalNode || node;
+    if (Array.isArray(node)) return node.map(convertValues);
+
+    if (isPlainObject(node)) {
+      return transform(node, (result, value, key) => {
+        const _value = isObjectLike(value) ? convertValues(value) : valueConvertor(key, value, originalNode);
+
+        return set(result, key, _value);
+      });
+    }
+
+    return node;
+  };
+
+  return convertValues;
+};
+const deepCamelCaseKeys = deepConvertKeys(convertWithInflectorCreator(camelCaseInflectorMap, camelCase));
+const deepSnakeCaseKeys = deepConvertKeys(convertWithInflectorCreator(snakeCaseInflectorMap, snakeCase));
+
+const omitByPredicateDeep = (obj, predicate) => {
+  return reduce(obj, (result, value, key) => {
+    if (isObject(value) || isArray(value)) {
+      if (isArray(result)) {
+        result.push(omitByPredicateDeep(value, predicate));
+      } else {
+        result[key] = omitByPredicateDeep(value, predicate);
+      }
+    } else if (!predicate(value)) {
+      if (isArray(result)) {
+        result.push(value);
+      } else {
+        result[key] = value;
+      }
+    }
+
+    return result;
+  }, isArray(obj) ? [] : {});
+};
+/**
+ * Recursively remove all nil values deeply nested properties of objects and arrays
+ *
+ * note: do not use for cyclical object or Date properties
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+
+const omitNilDeep = obj => omitByPredicateDeep(obj, value => isNil(value));
+
+const stringifyQueryEncode = query => qs.stringify(query, {
+  encode: true,
+  skipNulls: true
+});
+const parseQueryString = queryString => qs.parse(queryString, {
+  ignoreQueryPrefix: true,
+  decoder: (value, decoder) => {
+    const keywords = {
+      true: true,
+      false: false,
+      null: null,
+      undefined
+    };
+
+    if (value in keywords) {
+      return keywords[value];
+    }
+
+    return decoder(value);
+  }
+});
+
+export { abbreviate, clamp, convertUnicode, deepCamelCaseKeys, deepConvertKeys, deepConvertValues, deepSnakeCaseKeys, flatMap, hasValue, indexByKeyValue, isBlank, isEmptyValue, isReactNumeric, isReactNumericIncomplete, lowestValue, omitByPredicateDeep, omitNilDeep, parseJWT, parseQueryString, pluck, pluckUnique, removeSpaces, stringifyQueryEncode, toFixed, toHash, toNumeric, toPath, trimSpaces, unique };

package/jest.config.coverage.json

@@ -0,0 +1,6 @@
+{
+  "collectCoverage": true,
+  "collectCoverageFrom": ["src/**/*.{js,jsx,ts,tsx}"],
+  "coverageDirectory": "../../var/reports/lib/utils/coverage",
+  "coverageReporters": ["lcov"]
+}

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@s3p-js-deep-purple/utils",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "license": "UNLICENSED",
+  "version": "1.1.99",
+  "description": "Common string, array, date, object, etc utils for S3 Portal",
+  "main": "dist/s3p-js-deep-purple-utils.cjs.js",
+  "module": "dist/s3p-js-deep-purple-utils.esm.js",
+  "types": "dist/s3p-js-deep-purple-utils.cjs.d.ts",
+  "author": "Sqills Products BV",
+  "private": false,
+  "scripts": {
+    "test": "NODE_ENV=test ./node_modules/.bin/jest",
+    "test-coverage": "NODE_ENV=test ./node_modules/.bin/jest --config ./jest.config.coverage.json",
+    "preinstall": "./bin/preinstall.sh"
+  },
+  "devDependencies": {
+    "jest": "^27.5.1"
+  },
+  "dependencies": {
+    "qs": "^6.10.3"
+  },
+  "peerDependencies": {
+    "core-js": "^3.21.1",
+    "lodash": "^4.17.21"
+  }
 }

package/src/array.js

@@ -0,0 +1,24 @@
+import get from 'lodash/get'
+
+export const unique = array => Array.from(new Set(array))
+
+export const pluck = (array, field) => array.map(obj => get(obj || {}, field))
+
+export const pluckUnique = (...args) => unique(pluck(...args))
+
+export const flatMap = (array, field) =>
+  array.reduce((newArray, obj) => {
+    newArray.push(...(obj || {})[field])
+    return newArray
+  }, [])
+
+export const indexByKeyValue = (items, propKey, propValue) =>
+  (items || []).reduce((object, item) => {
+    const key = item[propKey]
+    if (key) {
+      object[key] = propValue ? item[propValue] : item
+    }
+    return object
+  }, {})
+
+export const lowestValue = (array, field) => Math.min(...array.map(object => object[field]))