@bigbinary/neeto-commons-frontend 2.0.11 → 2.0.13

package/pure.d.ts

@@ -1,6 +1,7 @@
 export type Primitives = symbol | string | number | boolean | null | undefined;
 export type ObjectAndPrimitives = Primitives | object;
 type KeyType = string | number | symbol;
+type NilOr<T> = T | null | undefined;
 
 type Matchable<Obj, Parent, key extends keyof Obj> =
   | ((object: Obj[key], parent: Parent) => boolean)
@@ -21,7 +22,10 @@ type MatchPattern<Obj = any, Parent = Obj> = Obj extends any[]
         };
 
 export function camelToSnakeCase(string: string): string;
+export function _camelToSnakeCase(string: NilOr<string>): NilOr<string>;
+
 export function capitalize(string: string): string;
+export function _capitalize(string: NilOr<string>): NilOr<string>;
 
 export function copyKeys<T>(
   keyMap: { [key in keyof Partial<T>]: string },
@@ -30,16 +34,37 @@ export function copyKeys<T>(
 export function copyKeys(keyMap: {
   [key: string]: string;
 }): <T>(objectArray: T[]) => (T & { [key: string]: any })[];
+export function _copyKeys<T>(
+  keyMap: { [key in keyof Partial<T>]: string },
+  objectArray: NilOr<T[]>
+): NilOr<(T & { [key: string]: any })[]>;
+export function _copyKeys(keyMap: {
+  [key: string]: string;
+}): <T>(objectArray: NilOr<T[]>) => NilOr<(T & { [key: string]: any })[]>;
 
 export function copyKeysDeep(keyMap: object, objectArray: object[]): object[];
 export function copyKeysDeep(
   keyMap: object
 ): (objectArray: object[]) => object[];
+export function _copyKeysDeep(
+  keyMap: object,
+  objectArray: NilOr<object[]>
+): NilOr<object[]>;
+export function _copyKeysDeep(
+  keyMap: object
+): (objectArray: NilOr<object[]>) => NilOr<object[]>;
 
 export function countBy<T>(pattern: MatchPattern<T>, entityArray: T[]): number;
 export function countBy(
   pattern: MatchPattern
 ): (entityArray: object[]) => number;
+export function _countBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<number>;
+export function _countBy(
+  pattern: MatchPattern
+): (entityArray: NilOr<object[]>) => NilOr<number>;
 
 export function deepFreezeObject<T>(object: T): Readonly<T>;
 
@@ -56,19 +81,51 @@ export function existsBy(
   pattern: MatchPattern
 ): (entityArray: object[]) => boolean;
 
+export function _existsBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<boolean>;
+export function _existsBy(
+  pattern: MatchPattern
+): (entityArray: NilOr<object[]>) => NilOr<boolean>;
+
 export function existsById(id: any, entityArray: object[]): boolean;
 export function existsById(id: any): (entityArray: object[]) => boolean;
+export function _existsById(
+  id: any,
+  entityArray: NilOr<object[]>
+): NilOr<boolean>;
+export function _existsById(
+  id: any
+): (entityArray: NilOr<object[]>) => NilOr<boolean>;
 
 export function filterBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T[];
 export function filterBy(pattern: MatchPattern): <T>(entityArray: T[]) => T[];
+export function _filterBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<T[]>;
+export function _filterBy(
+  pattern: MatchPattern
+): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
 
 export function filterNonNull(object: object): object;
+export function _filterNonNull(object: NilOr<object>): NilOr<object>;
 
 export function findBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T;
 export function findBy(pattern: MatchPattern): <T>(entityArray: T[]) => T;
+export function _findBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<T>;
+export function _findBy(
+  pattern: MatchPattern
+): <T>(entityArray: NilOr<T[]>) => NilOr<T>;
 
 export function findById<T>(id: any, entityArray: T[]): T;
 export function findById(id: any): <T>(entityArray: T[]) => T;
+export function _findById<T>(id: any, entityArray: NilOr<T[]>): NilOr<T>;
+export function _findById(id: any): <T>(entityArray: NilOr<T[]>) => NilOr<T>;
 
 export function findIndexBy<T>(
   pattern: MatchPattern<T>,
@@ -77,18 +134,47 @@ export function findIndexBy<T>(
 export function findIndexBy(
   pattern: MatchPattern
 ): (entityArray: object[]) => number;
+export function _findIndexBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<number>;
+export function _findIndexBy(
+  pattern: MatchPattern
+): (entityArray: NilOr<object[]>) => NilOr<number>;
 
 export function findIndexById(id: any, entityArray: object[]): number;
 export function findIndexById(id: any): (entityArray: object[]) => number;
+export function _findIndexById(
+  id: any,
+  entityArray: NilOr<object[]>
+): NilOr<number>;
+export function _findIndexById(
+  id: any
+): (entityArray: NilOr<object[]>) => NilOr<number>;
 
 export function findLastBy<T>(pattern: MatchPattern<T>, entityArray: T[]): T;
 export function findLastBy(pattern: MatchPattern): <T>(entityArray: T[]) => T;
+export function _findLastBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<T>;
+export function _findLastBy(
+  pattern: MatchPattern
+): <T>(entityArray: NilOr<T[]>) => NilOr<T>;
 
 export function findLastIndexBy(id: any, entityArray: object[]): number;
 export function findLastIndexBy(id: any): (entityArray: object[]) => number;
+export function _findLastIndexBy(
+  id: any,
+  entityArray: NilOr<object[]>
+): NilOr<number>;
+export function _findLastIndexBy(
+  id: any
+): (entityArray: NilOr<object[]>) => NilOr<number>;
 
 export function getRandomInt(a?: number, b?: number): number;
 export function humanize(string: string): string;
+export function _humanize(string: NilOr<string>): NilOr<string>;
 
 export function isNot(a: any, b: any): boolean;
 export function isNot(a: any): (b: any) => boolean;
@@ -121,6 +207,21 @@ export function modifyBy(
 export function modifyBy(
   pattern: MatchPattern
 ): <T>(modifier: (previous: T) => T) => (entityArray: T[]) => T[];
+export function _modifyBy<T>(
+  pattern: MatchPattern<T>,
+  modifier: (previous: T) => T,
+  entityArray: NilOr<T[]>
+): NilOr<T[]>;
+export function _modifyBy<T>(
+  pattern: MatchPattern<T>,
+  modifier: (previous: T) => T
+): (entityArray: NilOr<T[]>) => NilOr<T[]>;
+export function _modifyBy(
+  pattern: MatchPattern
+): <T>(modifier: (previous: T) => T, entityArray: NilOr<T[]>) => NilOr<T[]>;
+export function _modifyBy(
+  pattern: MatchPattern
+): <T>(modifier: (previous: T) => T) => (entityArray: NilOr<T[]>) => NilOr<T[]>;
 
 export function modifyById<T>(
   id: any,
@@ -137,6 +238,21 @@ export function modifyById(
 export function modifyById(
   id: any
 ): <T>(modifier: (previous: T) => T) => (entityArray: T[]) => T[];
+export function _modifyById<T>(
+  id: any,
+  modifier: (previous: T) => T,
+  entityArray: NilOr<T[]>
+): NilOr<T[]>;
+export function _modifyById<T>(
+  id: any,
+  modifier: (previous: T) => T
+): (entityArray: NilOr<T[]>) => NilOr<T[]>;
+export function _modifyById(
+  id: any
+): <T>(modifier: (previous: T) => T, entityArray: NilOr<T[]>) => NilOr<T[]>;
+export function _modifyById(
+  id: any
+): <T>(modifier: (previous: T) => T) => (entityArray: NilOr<T[]>) => NilOr<T[]>;
 
 export function noop(...args: any[]): void;
 
@@ -150,29 +266,64 @@ 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 _removeBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<T[]>;
+export function _removeBy(
+  pattern: MatchPattern
+): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
 
 export function removeById<T>(id: any, entityArray: T[]): T[];
 export function removeById(id: any): <T>(entityArray: T[]) => T[];
+export function _removeById<T>(id: any, entityArray: NilOr<T[]>): NilOr<T[]>;
+export function _removeById(
+  id: any
+): <T>(entityArray: NilOr<T[]>) => NilOr<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 _renameKeys<T, M extends { [key in keyof Partial<T>]: string }>(
+  keyMap: M,
+  entityArray: NilOr<T[]>
+): NilOr<(Omit<T, keyof M> & { [key: string]: any })[]>;
+export function _renameKeys<M extends { [key: string]: string }>(
+  keyMap: M
+): <T>(
+  entityArray: NilOr<T[]>
+) => NilOr<(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 _replaceBy<T>(
+  pattern: MatchPattern<T>,
+  entityArray: NilOr<T[]>
+): NilOr<T[]>;
+export function _replaceBy(
+  pattern: MatchPattern
+): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
 
 export function replaceById<T>(id: any, entityArray: T[]): T[];
 export function replaceById(id: any): <T>(entityArray: T[]) => T[];
+export function _replaceById<T>(id: any, entityArray: NilOr<T[]>): NilOr<T[]>;
+export function _replaceById(
+  id: any
+): <T>(entityArray: NilOr<T[]>) => NilOr<T[]>;
 
 export function serializeKeysToSnakeCase(object: object): object;
 export function preprocessForSerialization(object: object): object;
+
 export function slugify(string: string): string;
+export function _slugify(string: NilOr<string>): NilOr<string>;
+
 export function snakeToCamelCase(string: string): string;
+export function _snakeToCamelCase(string: NilOr<string>): NilOr<string>;
+
 export function toLabelAndValue(string: string): {
   label: string;
   value: string;
@@ -184,3 +335,8 @@ export function transformObjectDeep(
 ): object;
 
 export function truncate(string: string, length: number): string;
+export function truncate(string: NilOr<string>, length: number): NilOr<string>;
+
+export function nullSafe<T extends Function>(
+  func: T
+): (...args: any) => ReturnType<T>;

package/pure.js

@@ -1,4 +1,4 @@
-import { concat, slice, curry, isNil, complement, findLast, findLastIndex, count, fromPairs, toPairs, path, isEmpty, equals } from 'ramda';
+import { curryN, isNil, complement, isEmpty, curry, equals, concat, slice, findLast, findLastIndex, count, fromPairs, toPairs, path } from 'ramda';
 
 function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
@@ -71,6 +71,67 @@ function _typeof(obj) {
   }, _typeof(obj);
 }
 
+/**
+ * @template {Function} T
+ * @param {T} func
+ * @returns {T}
+ */
+
+var nullSafe = function nullSafe(func) {
+  return (// @ts-ignore
+    curryN(func.length, function () {
+      var _ref;
+
+      var dataArg = (_ref = func.length - 1, _ref < 0 || arguments.length <= _ref ? undefined : arguments[_ref]);
+      return isNil(dataArg) ? dataArg : func.apply(void 0, arguments);
+    })
+  );
+};
+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__*/complement(isNil);
+var isNotEmpty = /*#__PURE__*/complement(isEmpty);
+var notEquals = /*#__PURE__*/curry(function (x, y) {
+  return x !== y;
+});
+var isNot = notEquals;
+var notEqualsDeep = /*#__PURE__*/complement(equals);
+var isNotEqualDeep = notEqualsDeep;
+
 var slugify = function slugify(string) {
   return string.toString().toLowerCase().replace(/\s+/g, "-") // Replace spaces with -
   .replace(/&/g, "-and-") // Replace & with 'and'
@@ -101,6 +162,14 @@ var capitalize = function capitalize(string) {
 var truncate = function truncate(string, length) {
   return string.length > length ? concat(slice(0, length, string), "...") : string;
 };
+var _slugify = nullSafe(slugify);
+var _humanize = nullSafe(humanize);
+var _snakeToCamelCase = nullSafe(snakeToCamelCase);
+var _camelToSnakeCase = nullSafe(camelToSnakeCase);
+var _capitalize = nullSafe(capitalize);
+var _truncate = function _truncate(string, length) {
+  return isNil(string) ? string : truncate(string, length);
+};
 
 var matchesImpl = function matchesImpl(pattern, object) {
   var __parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : object;
@@ -192,6 +261,7 @@ var filterNonNull = function filterNonNull(object) {
     return [k, _typeof(v) === "object" && !Array.isArray(v) ? filterNonNull(v) : v];
   }));
 };
+var _filterNonNull = nullSafe(filterNonNull);
 
 function _defineProperty(obj, key, value) {
   if (key in obj) {
@@ -322,50 +392,24 @@ var copyKeysDeep = /*#__PURE__*/curry(function (keyMap, objectArray) {
     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__*/complement(isNil);
-var isNotEmpty = /*#__PURE__*/complement(isEmpty);
-var notEquals = /*#__PURE__*/curry(function (x, y) {
-  return x !== y;
-});
-var isNot = notEquals;
-var notEqualsDeep = /*#__PURE__*/complement(equals);
-var isNotEqualDeep = notEqualsDeep;
-
-export { camelToSnakeCase, capitalize, copyKeys, copyKeysDeep, countBy, deepFreezeObject, dynamicArray, existsBy, existsById, filterBy, filterNonNull, findBy, findById, findIndexBy, findIndexById, findLastBy, findLastIndexBy, getRandomInt, humanize, isNot, isNotEmpty, isNotEqualDeep, isNotNil, keysToCamelCase, keysToSnakeCase, matches, modifyBy, modifyById, noop, notEquals, notEqualsDeep, preprocessForSerialization, randomPick, removeBy, removeById, renameKeys, replaceBy, replaceById, serializeKeysToSnakeCase, slugify, snakeToCamelCase, toLabelAndValue, transformObjectDeep, truncate };
+var _removeById = /*#__PURE__*/nullSafe(removeById);
+var _findById = /*#__PURE__*/nullSafe(findById);
+var _replaceById = /*#__PURE__*/nullSafe(replaceById);
+var _modifyById = /*#__PURE__*/nullSafe(modifyById);
+var _findBy = /*#__PURE__*/nullSafe(findBy);
+var _removeBy = /*#__PURE__*/nullSafe(removeBy);
+var _replaceBy = /*#__PURE__*/nullSafe(replaceBy);
+var _modifyBy = /*#__PURE__*/nullSafe(modifyBy);
+var _existsById = /*#__PURE__*/nullSafe(existsById);
+var _existsBy = /*#__PURE__*/nullSafe(existsBy);
+var _findLastBy = /*#__PURE__*/nullSafe(findLastBy);
+var _findIndexById = /*#__PURE__*/nullSafe(findIndexById);
+var _findIndexBy = /*#__PURE__*/nullSafe(findIndexBy);
+var _findLastIndexBy = /*#__PURE__*/nullSafe(findLastIndexBy);
+var _filterBy = /*#__PURE__*/nullSafe(filterBy);
+var _countBy = /*#__PURE__*/nullSafe(countBy);
+var _copyKeys = /*#__PURE__*/nullSafe(copyKeys);
+var _renameKeys = /*#__PURE__*/nullSafe(renameKeys);
+var _copyKeysDeep = /*#__PURE__*/nullSafe(copyKeysDeep);
+
+export { _camelToSnakeCase, _capitalize, _copyKeys, _copyKeysDeep, _countBy, _existsBy, _existsById, _filterBy, _filterNonNull, _findBy, _findById, _findIndexBy, _findIndexById, _findLastBy, _findLastIndexBy, _humanize, _modifyBy, _modifyById, _removeBy, _removeById, _renameKeys, _replaceBy, _replaceById, _slugify, _snakeToCamelCase, _truncate, camelToSnakeCase, capitalize, copyKeys, copyKeysDeep, countBy, deepFreezeObject, dynamicArray, existsBy, existsById, filterBy, filterNonNull, findBy, findById, findIndexBy, findIndexById, findLastBy, findLastIndexBy, getRandomInt, humanize, isNot, isNotEmpty, isNotEqualDeep, isNotNil, keysToCamelCase, keysToSnakeCase, matches, modifyBy, modifyById, noop, notEquals, notEqualsDeep, nullSafe, preprocessForSerialization, randomPick, removeBy, removeById, renameKeys, replaceBy, replaceById, serializeKeysToSnakeCase, slugify, snakeToCamelCase, toLabelAndValue, transformObjectDeep, truncate };