@bigbinary/neeto-commons-frontend 0.0.1 → 0.0.2

package/pure.cjs.js

@@ -0,0 +1,418 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ramda = require('ramda');
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+  if (_i == null) return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+
+  var _s, _e;
+
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+
+  return _arr;
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+
+  return arr2;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+
+var slugify = function slugify(string) {
+  return string.toString().toLowerCase().replace(/\s+/g, "-") // Replace spaces with -
+  .replace(/&/g, "-and-") // Replace & with 'and'
+  .replace(/[^\w-]+/g, "") // Remove all non-word characters
+  .replace(/--+/g, "-") // Replace multiple - with single -
+  .replace(/^-+/, "") // Trim - from start of text
+  .replace(/-+$/, "");
+}; // Trim - from end of text
+
+var humanize = function humanize(string) {
+  string = string.replace(/[_-]+/g, " ").replace(/\s{2,}/g, " ").replace(/([a-z\d])([A-Z])/g, "$1" + " " + "$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1" + " " + "$2").toLowerCase().trim();
+  string = string.charAt(0).toUpperCase() + string.slice(1);
+  return string;
+};
+var snakeToCamelCase = function snakeToCamelCase(string) {
+  return string.replace(/(_\w)/g, function (letter) {
+    return letter[1].toUpperCase();
+  });
+};
+var camelToSnakeCase = function camelToSnakeCase(string) {
+  return string.replace(/[A-Z]/g, function (letter) {
+    return "_".concat(letter.toLowerCase());
+  });
+};
+var capitalize = function capitalize(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+};
+var truncate = function truncate(string, length) {
+  return string.length > length ? ramda.concat(ramda.slice(0, length, string), "...") : string;
+};
+
+var matchesImpl = function matchesImpl(pattern, object) {
+  var __parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : object;
+
+  if (object === pattern) return true;
+  if (typeof pattern === "function" && pattern(object, __parent)) return true;
+  if (ramda.isNil(pattern) || ramda.isNil(object)) return false;
+  if (_typeof(pattern) !== "object") return false;
+  return Object.entries(pattern).every(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+
+    return matchesImpl(value, object[key], __parent);
+  });
+};
+
+var transformObjectDeep = function transformObjectDeep(object, keyValueTransformer) {
+  var objectPreProcessor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+
+  if (objectPreProcessor && typeof objectPreProcessor === "function") {
+    object = objectPreProcessor(object);
+  }
+
+  if (Array.isArray(object)) {
+    return object.map(function (obj) {
+      return transformObjectDeep(obj, keyValueTransformer, objectPreProcessor);
+    });
+  } else if (object === null || _typeof(object) !== "object") {
+    return object;
+  }
+
+  return Object.fromEntries(Object.entries(object).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+        key = _ref4[0],
+        value = _ref4[1];
+
+    return keyValueTransformer(key, transformObjectDeep(value, keyValueTransformer, objectPreProcessor));
+  }));
+};
+var keysToCamelCase = function keysToCamelCase(object) {
+  return transformObjectDeep(object, function (key, value) {
+    return [snakeToCamelCase(key), value];
+  });
+};
+var keysToSnakeCase = function keysToSnakeCase(object) {
+  return transformObjectDeep(object, function (key, value) {
+    return [camelToSnakeCase(key), value];
+  });
+};
+var serializeKeysToSnakeCase = function serializeKeysToSnakeCase(object) {
+  return transformObjectDeep(object, function (key, value) {
+    return [camelToSnakeCase(key), value];
+  }, function (object) {
+    return typeof (object === null || object === void 0 ? void 0 : object.toJSON) === "function" ? object.toJSON() : object;
+  });
+};
+var preprocessForSerialization = function preprocessForSerialization(object) {
+  return transformObjectDeep(object, function (key, value) {
+    return [key, value];
+  }, function (object) {
+    return typeof (object === null || object === void 0 ? void 0 : object.toJSON) === "function" ? object.toJSON() : object;
+  });
+};
+var deepFreezeObject = function deepFreezeObject(object) {
+  if (object && _typeof(object) === "object" && !Object.isFrozen(object)) {
+    Object.keys(object).forEach(function (property) {
+      return deepFreezeObject(object[property]);
+    });
+    Object.freeze(object);
+  }
+
+  return object;
+};
+var matches = /*#__PURE__*/ramda.curry(function (pattern, object) {
+  return matchesImpl(pattern, object);
+});
+var filterNonNull = function filterNonNull(object) {
+  return Object.fromEntries(Object.entries(object).filter(function (_ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+        v = _ref6[1];
+
+    return !ramda.isNil(v);
+  }).map(function (_ref7) {
+    var _ref8 = _slicedToArray(_ref7, 2),
+        k = _ref8[0],
+        v = _ref8[1];
+
+    return [k, _typeof(v) === "object" && !Array.isArray(v) ? filterNonNull(v) : v];
+  }));
+};
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var removeById = /*#__PURE__*/ramda.curry(function (id, array) {
+  return array.filter(function (item) {
+    return item.id !== id;
+  });
+});
+var findById = /*#__PURE__*/ramda.curry(function (id, array) {
+  return array.find(function (item) {
+    return item.id === id;
+  });
+});
+var replaceById = /*#__PURE__*/ramda.curry(function (id, newItem, array) {
+  return array.map(function (item) {
+    return item.id === id ? newItem : item;
+  });
+});
+var modifyById = /*#__PURE__*/ramda.curry(function (id, modifier, array) {
+  return array.map(function (item) {
+    return item.id === id ? modifier(item) : item;
+  });
+});
+var findBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return array.find(matches(pattern));
+});
+var removeBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return array.filter(ramda.complement(matches(pattern)));
+});
+var replaceBy = /*#__PURE__*/ramda.curry(function (pattern, newItem, array) {
+  return array.map(function (item) {
+    return matches(pattern, item) ? newItem : item;
+  });
+});
+var modifyBy = /*#__PURE__*/ramda.curry(function (pattern, modifier, array) {
+  return array.map(function (item) {
+    return matches(pattern, item) ? modifier(item) : item;
+  });
+});
+var existsById = /*#__PURE__*/ramda.curry(function (id, array) {
+  return array.some(function (item) {
+    return item.id === id;
+  });
+});
+var existsBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return array.some(matches(pattern));
+});
+var findLastBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return ramda.findLast(matches(pattern), array);
+});
+var findIndexById = /*#__PURE__*/ramda.curry(function (id, array) {
+  return array.findIndex(function (item) {
+    return item.id === id;
+  });
+});
+var findIndexBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return array.findIndex(matches(pattern));
+});
+var findLastIndexBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return ramda.findLastIndex(matches(pattern), array);
+});
+var filterBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return array.filter(matches(pattern));
+});
+var countBy = /*#__PURE__*/ramda.curry(function (pattern, array) {
+  return ramda.count(matches(pattern), array);
+});
+var copyKeys = /*#__PURE__*/ramda.curry(function (keyMap, objectArray) {
+  return objectArray.map(function (object) {
+    var shallowCopy = _objectSpread({}, object);
+
+    for (var source in keyMap) {
+      shallowCopy[keyMap[source]] = object[source];
+    }
+
+    return shallowCopy;
+  });
+});
+var renameKeys = /*#__PURE__*/ramda.curry(function (keyMap, objectArray) {
+  return objectArray.map(function (object) {
+    var shallowCopy = _objectSpread({}, object);
+
+    for (var source in keyMap) {
+      shallowCopy[keyMap[source]] = object[source];
+      delete shallowCopy[source];
+    }
+
+    return shallowCopy;
+  });
+});
+var copyKeysDeep = /*#__PURE__*/ramda.curry(function (keyMap, objectArray) {
+  var copyKeysSingleObject = function copyKeysSingleObject(object, keyMap) {
+    var root = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : object;
+    return _objectSpread(_objectSpread({}, object), ramda.fromPairs(ramda.toPairs(keyMap).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          destination = _ref2[0],
+          source = _ref2[1];
+
+      if (typeof source === "function") {
+        return [destination, source(object[destination], root)];
+      } else if (Array.isArray(source)) {
+        return [destination, ramda.path(source, root)];
+      } else if (_typeof(source) === "object") {
+        return [destination, copyKeysSingleObject(object[destination], source, root)];
+      }
+
+      return [destination, object[source]];
+    })));
+  };
+
+  return objectArray.map(function (object) {
+    return copyKeysSingleObject(object, keyMap);
+  });
+});
+
+var noop = function noop() {};
+var toLabelAndValue = function toLabelAndValue(string) {
+  return {
+    label: string,
+    value: string
+  };
+};
+var getRandomInt = function getRandomInt() {
+  var a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Number.MAX_SAFE_INTEGER;
+  var b = arguments.length > 1 ? arguments[1] : undefined;
+
+  if (b) {
+    a = Math.ceil(a);
+    b = Math.floor(b);
+  } else {
+    b = a;
+    a = 0;
+  }
+
+  return Math.floor(Math.random() * (b - a) + a);
+};
+var randomPick = function randomPick() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var randomNumber = getRandomInt(0, args.length);
+  return args[randomNumber];
+};
+var dynamicArray = function dynamicArray(count, elementGenerator) {
+  return Array.from({
+    length: count
+  }, function (_, index) {
+    return elementGenerator(index);
+  });
+};
+var isNotNil = /*#__PURE__*/ramda.complement(ramda.isNil);
+var isNotEmpty = /*#__PURE__*/ramda.complement(ramda.isEmpty);
+var notEquals = /*#__PURE__*/ramda.curry(function (x, y) {
+  return x !== y;
+});
+var isNot = notEquals;
+var notEqualsDeep = /*#__PURE__*/ramda.complement(ramda.equals);
+var isNotEqualDeep = notEqualsDeep;
+
+exports.camelToSnakeCase = camelToSnakeCase;
+exports.capitalize = capitalize;
+exports.copyKeys = copyKeys;
+exports.copyKeysDeep = copyKeysDeep;
+exports.countBy = countBy;
+exports.deepFreezeObject = deepFreezeObject;
+exports.dynamicArray = dynamicArray;
+exports.existsBy = existsBy;
+exports.existsById = existsById;
+exports.filterBy = filterBy;
+exports.filterNonNull = filterNonNull;
+exports.findBy = findBy;
+exports.findById = findById;
+exports.findIndexBy = findIndexBy;
+exports.findIndexById = findIndexById;
+exports.findLastBy = findLastBy;
+exports.findLastIndexBy = findLastIndexBy;
+exports.getRandomInt = getRandomInt;
+exports.humanize = humanize;
+exports.isNot = isNot;
+exports.isNotEmpty = isNotEmpty;
+exports.isNotEqualDeep = isNotEqualDeep;
+exports.isNotNil = isNotNil;
+exports.keysToCamelCase = keysToCamelCase;
+exports.keysToSnakeCase = keysToSnakeCase;
+exports.matches = matches;
+exports.modifyBy = modifyBy;
+exports.modifyById = modifyById;
+exports.noop = noop;
+exports.notEquals = notEquals;
+exports.notEqualsDeep = notEqualsDeep;
+exports.preprocessForSerialization = preprocessForSerialization;
+exports.randomPick = randomPick;
+exports.removeBy = removeBy;
+exports.removeById = removeById;
+exports.renameKeys = renameKeys;
+exports.replaceBy = replaceBy;
+exports.replaceById = replaceById;
+exports.serializeKeysToSnakeCase = serializeKeysToSnakeCase;
+exports.slugify = slugify;
+exports.snakeToCamelCase = snakeToCamelCase;
+exports.toLabelAndValue = toLabelAndValue;
+exports.transformObjectDeep = transformObjectDeep;
+exports.truncate = truncate;

package/pure.d.ts

@@ -0,0 +1,186 @@
+export type Primitives = symbol | string | number | boolean | null | undefined;
+export type ObjectAndPrimitives = Primitives | object;
+type KeyType = string | number | symbol;
+
+type Matchable<Obj, Parent, key extends keyof Obj> =
+  | ((object: Obj[key], parent: Parent) => boolean)
+  | MatchPattern<Obj[key], Parent>
+  | Primitives;
+
+type MatchPattern<Obj = any, Parent = Obj> = Obj extends any[]
+  ?
+      | Matchable<Obj, Parent, number>[]
+      | { [key: number]: Matchable<Obj, Parent, number> }
+  : Obj extends Primitives
+  ? Obj
+  :
+      | {
+          [key in keyof Partial<Obj>]: Matchable<Obj, Parent, key>;
+        } & {
+          [key: KeyType]: Matchable<any, Parent, KeyType>;
+        };
+
+export function camelToSnakeCase(string: string): string;
+export function capitalize(string: string): string;
+
+export function copyKeys<T>(
+  keyMap: { [key in keyof Partial<T>]: string },
+  objectArray: T[]
+): (T & { [key: string]: any })[];
+export function copyKeys(keyMap: {
+  [key: string]: string;
+}): <T>(objectArray: T[]) => (T & { [key: string]: any })[];
+
+export function copyKeysDeep(keyMap: object, objectArray: object[]): object[];
+export function copyKeysDeep(
+  keyMap: object
+): (objectArray: object[]) => object[];
+
+export function countBy<T>(pattern: MatchPattern<T>, entityArray: T[]): number;
+export function countBy(
+  pattern: MatchPattern
+): (entityArray: object[]) => number;
+
+export function deepFreezeObject<T>(object: T): Readonly<T>;
+
+export function dynamicArray<T>(
+  count: number,
+  elementGenerator: (index: number) => T
+): T[];
+
+export function existsBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: T[]
+): boolean;
+export function existsBy(
+  pattern: MatchPattern
+): (entityArray: object[]) => boolean;
+
+export function existsById(id: any, entityArray: object[]): boolean;
+export function existsById(id: any): (entityArray: object[]) => boolean;
+
+export function filterBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T[];
+export function filterBy(pattern: MatchPattern): <T>(entityArray: T[]) => T[];
+
+export function filterNonNull(object: object): object;
+
+export function findBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T;
+export function findBy(pattern: MatchPattern): <T>(entityArray: T[]) => T;
+
+export function findById<T>(id: any, entityArray: T[]): T;
+export function findById(id: any): <T>(entityArray: T[]) => T;
+
+export function findIndexBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: T[]
+): number;
+export function findIndexBy(
+  pattern: MatchPattern
+): (entityArray: object[]) => number;
+
+export function findIndexById(id: any, entityArray: object[]): number;
+export function findIndexById(id: any): (entityArray: object[]) => number;
+
+export function findLastBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T;
+export function findLastBy(pattern: MatchPattern): <T>(entityArray: T[]) => T;
+
+export function findLastIndexBy(id: any, entityArray: object[]): number;
+export function findLastIndexBy(id: any): (entityArray: object[]) => number;
+
+export function getRandomInt(a?: number, b?: number): number;
+export function humanize(string: string): string;
+
+export function isNot(a: any, b: any): boolean;
+export function isNot(a: any): (b: any) => boolean;
+
+export const isNotEmpty: (a: any) => boolean;
+
+export function isNotEqualDeep(a: any, b: any): boolean;
+export function isNotEqualDeep(a: any): (b: any) => boolean;
+
+export const isNotNil: (a: any) => boolean;
+
+export function keysToCamelCase(object: any): any;
+export function keysToSnakeCase(object: any): any;
+
+export function matches<T>(pattern: MatchPattern<T>, data: T): boolean;
+export function matches(pattern: MatchPattern): (data: any) => boolean;
+
+export function modifyBy<T>(
+  pattern: MatchPattern<T>,
+  modifier: (previous: T) => T,
+  entityArray: T[]
+): T[];
+export function modifyBy<T>(
+  pattern: MatchPattern<T>,
+  modifier: (previous: T) => T
+): (entityArray: T[]) => T[];
+export function modifyBy(
+  pattern: MatchPattern
+): <T>(modifier: (previous: T) => T, entityArray: T[]) => T[];
+export function modifyBy(
+  pattern: MatchPattern
+): <T>(modifier: (previous: T) => T) => (entityArray: T[]) => T[];
+
+export function modifyById<T>(
+  id: any,
+  modifier: (previous: T) => T,
+  entityArray: T[]
+): T[];
+export function modifyById<T>(
+  id: any,
+  modifier: (previous: T) => T
+): (entityArray: T[]) => T[];
+export function modifyById(
+  id: any
+): <T>(modifier: (previous: T) => T, entityArray: T[]) => T[];
+export function modifyById(
+  id: any
+): <T>(modifier: (previous: T) => T) => (entityArray: T[]) => T[];
+
+export function noop(...args: any[]): void;
+
+export function notEquals(a: any, b: any): boolean;
+export function notEquals(a: any): (b: any) => boolean;
+
+export function notEqualsDeep(a: any, b: any): boolean;
+export function notEqualsDeep(a: any): (b: any) => boolean;
+
+export function randomPick<T>(...args: T[]): T;
+
+export function removeBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T[];
+export function removeBy(pattern: MatchPattern): <T>(entityArray: T[]) => T[];
+
+export function removeById<T>(id: any, entityArray: T[]): T[];
+export function removeById(id: any): <T>(entityArray: T[]) => T[];
+
+export function renameKeys<T, M extends { [key in keyof Partial<T>]: string }>(
+  keyMap: M,
+  entityArray: T[]
+): (Omit<T, keyof M> & { [key: string]: any })[];
+
+export function renameKeys<M extends { [key: string]: string }>(
+  keyMap: M
+): <T>(entityArray: T[]) => (Omit<T, keyof M> & { [key: string]: any })[];
+
+export function replaceBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T[];
+export function replaceBy(pattern: MatchPattern): <T>(entityArray: T[]) => T[];
+
+export function replaceById<T>(id: any, entityArray: T[]): T[];
+export function replaceById(id: any): <T>(entityArray: T[]) => T[];
+
+export function serializeKeysToSnakeCase(object: object): object;
+export function preprocessForSerialization(object: object): object;
+export function slugify(string: string): string;
+export function snakeToCamelCase(string: string): string;
+export function toLabelAndValue(string: string): {
+  label: string;
+  value: string;
+};
+export function transformObjectDeep(
+  object: object,
+  keyValueTransformer: (key: string | number | symbol, object: any) => any[],
+  objectPreProcessor?: (object: any) => any
+): object;
+
+export function truncate(string: string, length: number): string;