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

package/src/casing.ts

@@ -0,0 +1,70 @@
+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'
+
+type ConvertibleType = Record<string, unknown>
+type OverrideKeymapType = [string, string][]
+
+// eslint-disable-next-line no-warning-comments
+// todo: this does not belong in a generic utils lib, move this to implementation
+const s3ApiKeyMap: OverrideKeymapType = [
+  ['_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: Map<string, string>, keyConverter: (string) => string) =>
+  (key: string): string =>
+    inflector.has(key) ? (inflector.get(key) as string) : keyConverter(key)
+
+type KeyConverterType<T> = (node: T, parentKey?: string | number) => T
+
+export const deepConvertKeys = (
+  keyConverter: (string) => string,
+  whiteListChildren: string[] = []
+): KeyConverterType<ConvertibleType> => {
+  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 as string) ? key : keyConverter(key)
+        return set(result as Record<string, unknown>, _key, isObjectLike(value) ? convertKeys(value, _key) : value)
+      })
+    }
+    return node
+  }
+  return convertKeys
+}
+
+type ConvertibleRecord = Record<string | number | symbol, unknown>
+
+export const deepConvertValues = (
+  valueConvertor: (key: string | number | symbol, value: unknown, originalNode: unknown) => unknown
+): ((node: ConvertibleRecord) => ConvertibleRecord) => {
+  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 as Record<string, unknown>, key, _value)
+      })
+    }
+    return node
+  }
+  return convertValues
+}
+
+export const deepCamelCaseKeys = deepConvertKeys(convertWithInflectorCreator(camelCaseInflectorMap, camelCase))
+export const deepSnakeCaseKeys = deepConvertKeys(convertWithInflectorCreator(snakeCaseInflectorMap, snakeCase))

package/src/index.ts

@@ -0,0 +1,10 @@
+export {default as toPath} from './to-path'
+export {unique, flatMap, indexByKeyValue, lowestValue, pluck, pluckUnique} from './array'
+export {hasValue, isEmptyValue} from './is-empty'
+export {isBlank, abbreviate, convertUnicode, parseJWT, removeSpaces, trimSpaces} from './string'
+export {default as toHash} from './to-hash'
+export {toFixed, clamp, isReactNumeric, isReactNumericIncomplete, toNumeric} from './number'
+export {deepCamelCaseKeys, deepSnakeCaseKeys, deepConvertKeys, deepConvertValues} from './casing'
+export {omitByPredicateDeep, omitNilDeep} from './object'
+export {parseQueryString, stringifyQueryEncode} from './url'
+export * from './types'

package/src/is-empty.js

@@ -0,0 +1,8 @@
+export 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
+
+export const hasValue = value => !isEmptyValue(value)

package/src/number.js

@@ -0,0 +1,40 @@
+/**
+ * Handle floating point precision. 0.2 + 0.1 = 0.30000000000000004
+ * @param {Number|String} value
+ * @return {Number}
+ */
+export 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}
+ */
+export const clamp = (value = 0, minValue, maxValue) => 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}
+ */
+export const isReactNumeric = (value = '') => 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}
+ */
+export const isReactNumericIncomplete = (value = '') =>
+  String(value).match(/(?!^-?\d+$)^-?(\d+\.?)([eE][-+]?)?$/) !== null
+
+/**
+ * Transforms a scientific number (1e7) to a string (0.000001)
+ * @param value
+ * @return {string}
+ */
+export const toFixed = value =>
+  Number(value)
+    .toFixed(20)
+    .replace(/\.?0+$/, '')

package/src/object.ts

@@ -0,0 +1,45 @@
+import {PickByValue, Optional} from 'utility-types'
+import isObject from 'lodash/isObject'
+import isArray from 'lodash/isArray'
+import isNil from 'lodash/isNil'
+import reduce from 'lodash/reduce'
+
+export const omitByPredicateDeep = <
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  GenericObjectType extends object,
+  // this makes any properties optional that can be nil type (not deeply though)
+  GenericReturnedObjectType = Optional<GenericObjectType, keyof PickByValue<GenericObjectType, undefined | null>>
+>(
+  obj: GenericObjectType,
+  predicate: (value: GenericObjectType[keyof GenericObjectType]) => boolean
+): GenericReturnedObjectType => {
+  return reduce(
+    obj,
+    (result, value, key) => {
+      if (isObject(value) || isArray(value)) {
+        if (isArray(result)) {
+          result.push(omitByPredicateDeep(value as unknown as GenericObjectType, predicate))
+        } else {
+          result[key] = omitByPredicateDeep(value as unknown as GenericObjectType, predicate)
+        }
+      } else if (!predicate(value)) {
+        if (isArray(result)) {
+          result.push(value)
+        } else {
+          result[key] = value
+        }
+      }
+      return result
+    },
+    isArray(obj) ? [] : {}
+  ) as GenericReturnedObjectType
+}
+
+/**
+ * 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
+export const omitNilDeep = <T extends object, R = Optional<T, keyof PickByValue<T, undefined | null>>>(obj: T): R =>
+  omitByPredicateDeep(obj, value => isNil(value))

package/src/string.js

@@ -0,0 +1,73 @@
+import isEmpty from 'lodash/isEmpty'
+import isBoolean from 'lodash/isBoolean'
+import isNumber from 'lodash/isNumber'
+
+/**
+ * Abbreviate a sentence.
+ * John Doe becomes J.D.
+ * @param sentence
+ * @return {string}
+ */
+export const abbreviate = sentence =>
+  sentence
+    .trim()
+    .split(' ')
+    .map(word => (word.length ? `${word[0].toUpperCase()}.` : ''))
+    .join('')
+
+/**
+ * Remove spaces from a string
+ * @param value
+ * @returns {string}
+ */
+export const removeSpaces = value => (typeof value === 'string' ? value.replace(/\s/g, '') : value)
+
+/**
+ * trim spaces on both ends from a string
+ * @param value
+ * @returns {string}
+ */
+export 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}
+ */
+export const isBlank = value => Boolean(isEmpty(value) && !isBoolean(value) && !isNumber(value))
+
+export const parseJWT = token => {
+  const base64Url = token.split('.')[1]
+  const base64 = base64Url.replace('-', '+').replace('_', '/')
+  return JSON.parse(window.atob(base64))
+}
+
+export const convertUnicode = value =>
+  value.replace(/\\u(\w\w\w\w)/g, (_, match) => String.fromCharCode(parseInt(match, 16)))

package/src/to-hash.ts

@@ -0,0 +1,3 @@
+const toHash = (value = '/'): string => value.replace(/[/.]/g, '|')
+
+export default toHash

package/src/to-path.ts

@@ -0,0 +1,6 @@
+import {PathPartType} from './types'
+
+const toPath = (path: PathPartType | PathPartType[]): string =>
+  Array.isArray(path) ? path.filter(Boolean).join('.') : path || ''
+
+export default toPath

package/src/types.ts

@@ -0,0 +1,24 @@
+/**
+ * DeepReturnType
+ * @desc ReturnType that works for deeply nested structure
+ */
+export declare type DeepReturnType<T> = T extends (...args: unknown[]) => unknown
+  ? ReturnType<T>
+  : T extends Array<infer U>
+  ? _DeepReturnTypeArray<U>
+  : T extends Record<string, unknown>
+  ? _DeepReturnTypeObject<T>
+  : T
+
+/** @private */
+type _DeepReturnTypeArray<T> = Array<DeepReturnType<T>>
+
+/** @private */
+declare type _DeepReturnTypeObject<T> = {
+  [P in keyof T]: DeepReturnType<T[P]>
+}
+
+export type UppercaseOrLowercase<S extends string> = Uppercase<S> | Lowercase<S>
+
+export type PathPartType = string | undefined | null
+export type PathType = string | undefined

package/src/url.js

@@ -0,0 +1,22 @@
+import qs from 'qs'
+
+export const stringifyQueryEncode = query => qs.stringify(query, {encode: true, skipNulls: true})
+
+export 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)
+    }
+  })

package/tests/__snapshots__/casing.spec.js.snap

@@ -0,0 +1,35 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`deepCamelCaseKeys should convert the keys 1`] = `
+Object {
+  "deep": Object {
+    "nested": Object {
+      "foo": Object {
+        "fooBar": "foo-bar",
+      },
+    },
+  },
+  "nestedArray": Array [
+    Object {
+      "fooBar": "foo-bar",
+    },
+  ],
+}
+`;
+
+exports[`deepConvertValues should convert the values 1`] = `
+Object {
+  "deep": Object {
+    "nested": Object {
+      "foo": Object {
+        "foo-bar": "foo_bar",
+      },
+    },
+  },
+  "nested-array": Array [
+    Object {
+      "foo-bar": "foo_bar",
+    },
+  ],
+}
+`;

package/tests/casing.spec.js

@@ -0,0 +1,29 @@
+import {deepCamelCaseKeys, deepConvertValues} from '../src/casing'
+import snakeCase from 'lodash/snakeCase'
+
+const subject = {
+  deep: {
+    nested: {
+      foo: {
+        'foo-bar': 'foo-bar'
+      }
+    }
+  },
+  'nested-array': [{'foo-bar': 'foo-bar'}]
+}
+
+describe('deepCamelCaseKeys', () => {
+  it('should convert the keys', () => {
+    expect(deepCamelCaseKeys(subject)).toMatchSnapshot()
+  })
+})
+
+describe('deepConvertValues', () => {
+  it('should convert the values', () => {
+    expect(deepConvertValues(snakeCase)(subject)).toMatchSnapshot()
+  })
+
+  it('should handle undefined', () => {
+    expect(deepConvertValues(snakeCase)(undefined)).toEqual(undefined)
+  })
+})

package/tests/number.spec.js

@@ -0,0 +1,67 @@
+/* globals describe, it, expect */
+
+import {clamp, isReactNumeric, toFixed, toNumeric} from '../src/number'
+
+describe('toNumeric', () => {
+  it('should not have a floating point precision', () => {
+    expect(toNumeric(0.2 + 0.1)).toEqual(0.3)
+  })
+
+  it('should handle string', () => {
+    expect(toNumeric('0.1')).toEqual(0.1)
+  })
+
+  it('should handle small numbers', () => {
+    expect(toNumeric('0.0000000001')).toEqual(0.0000000001)
+  })
+
+  it('should handle negative numbers', () => {
+    expect(toNumeric(0 - 0.01)).toEqual(-0.01)
+  })
+})
+
+describe('isReactNumeric', () => {
+  it('should handle negative numbers', () => {
+    expect(isReactNumeric(-1)).toBeTruthy()
+  })
+
+  it('should handle small numbers', () => {
+    expect(isReactNumeric(0.0001)).toBeTruthy()
+  })
+
+  it('should handle strings', () => {
+    expect(isReactNumeric('1000.1')).toBeTruthy()
+  })
+})
+
+describe('clamp', () => {
+  it('should cap at a minimum', () => {
+    expect(clamp(10, 15, 100)).toEqual(15)
+  })
+
+  it('should cap at a maximum', () => {
+    expect(clamp(110, 15, 100)).toEqual(100)
+  })
+
+  it('should handle a string', () => {
+    expect(clamp('110', 15, 100)).toEqual(100)
+  })
+
+  it('should handle a small number', () => {
+    expect(clamp(0.001, 15, 100)).toEqual(15)
+  })
+})
+
+describe('toFixed', () => {
+  it('should change 1e-7 to 0.000001', () => {
+    expect(toFixed(1e-7)).toEqual('0.0000001')
+  })
+
+  it('should change 1e7 to 1000000', () => {
+    expect(toFixed(1e7)).toEqual('10000000')
+  })
+
+  it('should not change 1', () => {
+    expect(toFixed(1)).toEqual('1')
+  })
+})

package/tests/object.spec.ts

@@ -0,0 +1,77 @@
+/* globals describe, test, expect */
+
+import {omitNilDeep} from '../src/object'
+
+describe('omitNilDeep', () => {
+  test('remove nulls and undefined values from nested object', () => {
+    const obj = {
+      teste: undefined,
+      nullV: null,
+      x: 10,
+      iAmFalse: false,
+      iAmZero: 0,
+      iAmNaN: NaN,
+      name: 'yolololo',
+      a: null,
+      b: '',
+      c: {
+        a: [
+          {
+            n: 'a',
+            i: 248,
+            b: 0,
+            c: undefined
+          },
+          null,
+          {
+            t: 'b',
+            u: false,
+            v: null
+          },
+          undefined
+        ],
+        g: 'c',
+        h: null,
+        eager: {
+          p: 'd-test'
+        }
+      }
+    }
+    const expectedObj = {
+      x: 10,
+      iAmFalse: false,
+      iAmZero: 0,
+      iAmNaN: NaN,
+      name: 'yolololo',
+      b: '',
+      c: {
+        a: [
+          {
+            n: 'a',
+            i: 248,
+            b: 0
+          },
+          {
+            t: 'b',
+            u: false
+          }
+        ],
+        g: 'c',
+        eager: {
+          p: 'd-test'
+        }
+      }
+    }
+
+    expect(omitNilDeep(obj)).toEqual(expectedObj)
+    expect(omitNilDeep(obj.c.a)).toEqual(expectedObj.c.a)
+    expect(omitNilDeep({})).toEqual({})
+  })
+
+  test('remove nulls and undefined values from array', () => {
+    expect(omitNilDeep([])).toEqual([])
+    expect(
+      omitNilDeep(['a', null, 'b', undefined, 'c', false, 0, {}, NaN, {a: 'a', b: null, c: undefined, d: 'd'}])
+    ).toEqual(['a', 'b', 'c', false, 0, {}, NaN, {a: 'a', d: 'd'}])
+  })
+})

package/tests/string.spec.js

@@ -0,0 +1,77 @@
+/* globals describe, test, expect */
+
+import {isBlank, removeSpaces, trimSpaces} from '../src/string'
+
+describe('removeSpaces', () => {
+  test('remove spaces on the end', () => {
+    expect(removeSpaces('test   ')).toEqual('test')
+  })
+
+  test('remove spaces in the beginning', () => {
+    expect(removeSpaces('  test')).toEqual('test')
+  })
+
+  test('remove spaces in the middle', () => {
+    expect(removeSpaces('te st')).toEqual('test')
+  })
+})
+
+describe('trimSpaces', () => {
+  test('trim spaces on the end', () => {
+    expect(trimSpaces('test   ')).toEqual('test')
+  })
+
+  test('trim spaces in the beginning', () => {
+    expect(trimSpaces('  test')).toEqual('test')
+  })
+
+  test('dont trim spaces in the middle', () => {
+    expect(trimSpaces('te st')).toEqual('te st')
+  })
+})
+
+describe('isBlank', () => {
+  test('null', () => {
+    expect(isBlank(null)).toBeTruthy()
+  })
+
+  test('undefined', () => {
+    expect(isBlank(undefined)).toBeTruthy()
+  })
+
+  test('empty map', () => {
+    expect(isBlank(new Map())).toBeTruthy()
+  })
+
+  test('empty set', () => {
+    expect(isBlank(new Set())).toBeTruthy()
+  })
+
+  test('empty object', () => {
+    expect(isBlank({})).toBeTruthy()
+  })
+
+  test('empty array', () => {
+    expect(isBlank([])).toBeTruthy()
+  })
+
+  test('empty string', () => {
+    expect(isBlank('')).toBeTruthy()
+  })
+
+  test('false', () => {
+    expect(isBlank(false)).toBeFalsy()
+  })
+
+  test('true', () => {
+    expect(isBlank(true)).toBeFalsy()
+  })
+
+  test('string', () => {
+    expect(isBlank('test')).toBeFalsy()
+  })
+
+  test('number', () => {
+    expect(isBlank(0)).toBeFalsy()
+  })
+})

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true
+  },
+  "include": ["./src"]
+}