@valkyriestudios/utils 5.0.0 → 5.2.0

package/README.md

@@ -12,14 +12,14 @@ A collection of single-function utilities for common tasks
 ## Available Functions
 
 ### array
-- **isArray(val:any)**<br>
+- **isArray(val:any)**
 Check if a variable is of type Array
 ```
 isArray({a:1}); // FALSE
 isArray([]); // TRUE
 ```
 
-- **isNotEmptyArray(val:any)**<br>
+- **isNotEmptyArray(val:any)**
 Check if a variable a non-empty array
 ```
 isNotEmptyArray({a:1}); // FALSE
@@ -27,7 +27,105 @@ isNotEmptyArray([]); // FALSE
 isNotEmptyArray([0, 1, 2]); // TRUE
 ```
 
-- **dedupe(val:Array)**<br>
+- **mapKey(val:array[Object], key:string, opts:object={})**
+Map a non-primitive object array into an object map by key
+```
+mapKey([
+    {uid: 12, name: 'Peter'},
+    {uid: 15, name: 'Jonas'},
+    {uid: 87, name: 'Josh'},
+], 'uid');
+
+output: 
+
+{
+    12: {uid: 12, name: 'Peter'},
+    15: {uid: 15, name: 'Jonas'},
+    87: {uid: 87, name: 'Josh'},
+}
+```
+
+Autofilters anything not meeting the spec:
+```
+[
+    0,
+    {uid: 12, name: 'Peter'},
+    false,
+    'foobar',
+    {uid: 15, name: 'Jonas'},
+    [{hi: 'there'}],
+    null,
+    undefined,
+    new Date(),
+    {uid: 87, name: 'Josh'},
+], 'uid');
+
+output:
+
+{
+    12: {uid: 12, name: 'Peter'},
+    15: {uid: 15, name: 'Jonas'},
+    87: {uid: 87, name: 'Josh'},
+}
+```
+
+allows merging objects onto existing keys: 
+```
+[
+    0,
+    {uid: 12, name: 'Peter'},
+    false,
+    'foobar',
+    {uid: 15, name: 'Jonas', dob: '2022-02-07'},
+    [{hi: 'there'}],
+    {uid: 15, name: 'Bob'},
+    null,
+    undefined,
+    {name: 'Alana'},
+    new Date(),
+    {uid: 87, name: 'Josh'},
+    {uid: 12, name: 'Farah'},
+], 'uid', {merge: true})
+
+output:
+
+{
+    12: {uid: 12, name: 'Farah'},
+    15: {uid: 15, name: 'Bob', dob: '2022-02-07'},
+    87: {uid: 87, name: 'Josh'},
+}
+```
+
+- **mapFn(val:array[Object], key:Function, opts:object={})**
+Same behavior as mapKey but instead of a key, a function is passed to generate your own key. Eg:
+
+```
+mapFn([
+    {uid: 12, name: 'Peter'},
+    {uid: 15, name: 'Jonas'},
+    {uid: 87, name: 'Josh'},
+], el => el.uid))
+
+output:
+
+{
+    12: {uid: 12, name: 'Peter'},
+    15: {uid: 15, name: 'Jonas'},
+    87: {uid: 87, name: 'Josh'},
+}
+```
+
+options are the same as the mapKey function
+
+- **mapPrimitive(val:any, opts:object={keytrim:true,valtrim:false,keyround:false,valround:false})**
+Map an array of primitives (number/string)
+```
+mapPrimitive([1,2,3]); // {1: 1, 2: 2, 3: 3}
+mapPrimitive(['hello', 'hello', 'foo', 'bar']); // {hello: 'hello', foo: 'foo', bar: 'bar'}
+mapPrimitive(['hello', ' hello', 'foo', '  foo'], {keytrim: true, valtrim: true}); // {hello: 'hello', foo: 'foo'}
+```
+
+- **dedupe(val:Array)**
 Remove all duplicates from an array, behind the scenes it uses the fnv 1A hash algorithm to performantly do comparisons.
 ```
 dedupe(['a','a','b','c','c']); // ['a', 'b', 'c']
@@ -37,8 +135,19 @@ dedupe([new Date('2012-02-02'), new Date('2012-02-02')]); // [new Date('2012-02-
 dedupe(['hello', 'hello', 'world']); // ['hello', 'world']
 ```
 
+- **join(val:Array, opts:object={delim:' ',trim:true,valtrim:true,valround:false})**
+Concatenate the values within an array into a string, behind the scenes this will automatically filter out any value that is not a string or numerical value. For strings it will automatically trim (and remove if empty after trimming) before joining.
+
+```
+join(['Valkyrie', 'Studios']); // 'Valkyrie Studios'
+join([5.1, '  years ', 'ago'], {valround: 0}); // '5 years ago'
+join(['peter   ', '  valkyrie  '], {delim: '@'}); // 'peter@valkyrie'
+join([user.first_name, user.last_name]); // 'John' (where user is {first_name: 'John', last_name: false})
+join(['  a', 1], {delim: '', valtrim: false, trim: false}); // '  a1'
+```
+
 ### boolean
-- **isBoolean(val:any)**<br>
+- **isBoolean(val:any)**
 Check if a variable is of type Boolean
 ```
 isBoolean(null); // FALSE
@@ -47,16 +156,16 @@ isBoolean(true); // TRUE
 ```
 
 ### caching
-- **memoize(fn:Function)**<br>
+- **memoize(fn:Function)**
 memoize the output of a specific function to allow for the creation of an internal cache using the fnv 1A hash algorithm
 ```
 const memoized_function = memoize((a, b) => {
-	return a + b;
+    return a + b;
 });
 ```
 
 ### date
-- **isDate(val:any)**<br>
+- **isDate(val:any)**
 Check if a variable is of type Date
 ```
 isDate(new Date('December 17, 1995 03:24:00'); // TRUE
@@ -64,7 +173,7 @@ isDate('December 17, 1995 03:24:00'); // FALSE
 ```
 
 ### deep
-- **deepFreeze(val:Object)**<br>
+- **deepFreeze(val:Object)**
 Recursively freezes all properties of an object
 ```
 const myObj = deepFreeze({
@@ -81,7 +190,7 @@ Object.isFrozen(myObj.b); // TRUE
 Object.isFrozen(myObj.b.d); // TRUE
 ```
 
-- **deepSeal(val:Object)**<br>
+- **deepSeal(val:Object)**
 Recursively freezes all properties of an object
 ```
 const myObj = deepSeal({
@@ -99,7 +208,7 @@ Object.isSealed(myObj.b.d); // TRUE
 Object.isFrozen(myObj.b.d); // FALSE
 ```
 
-- **deepSet(obj:Object, path:string, value:any=null, define:boolean=false)**<br>
+- **deepSet(obj:Object, path:string, value:any=null, define:boolean=false)**
 Sets a property and its value deep in the structure of an object
 ```
 const myObj = {
@@ -129,7 +238,7 @@ deepSet(myObj, 'b.c', { value: function () => {...} }, true);
 myObj.b.c; // Function
 ```
 
-- **deepGet(obj:Object, path:string, get_parent:boolean=false)**<br>
+- **deepGet(obj:Object, path:string, get_parent:boolean=false)**
 Retrieves a value based on a path in a deeply nested object
 ```
 const myObj = {
@@ -153,7 +262,7 @@ deepGet(myObj, 'b[0].price'); // 2
 ```
 
 ### equal
-- **equal(a:any, b:any)**<br>
+- **equal(a:any, b:any)**
 Check if a variable is equal to another one
 ```
 equal(5, 6); // FALSE
@@ -165,40 +274,31 @@ equal(new Date('2012-20-09'), '2012-20-09'); // TRUE ( check is being done on un
 equal(new RegExp(/ab+c/, 'i'), /ab+c/i); // TRUE
 ```
 
-### formdata
-- **isFormData(val:any)**<br>
-Check if a variable is an instance of FormData
-```
-isFormData(FormData(...)); // TRUE
-isFormData('Hello'); // FALSE
-isFormData({a: 1, b:2}); // FALSE
-```
-
 ### function
-- **isFunction(val:any)**<br>
+- **isFunction(val:any)**
 Check if a variable is a Function
 
-- **noop()**<br>
+- **noop()**
 An empty function that can be used in (for example) piping
 
-- **noopreturn(val:any)**<br>
+- **noopreturn(val:any)**
 An empty function that will pass back the variable that it was passed
 
-- **noopresolve(val:any)**<br>
+- **noopresolve(val:any)**
 An empty function that returns a promise that will immediately resolve itself and pass back any variable that was passed to it
 
-- **sleep(val:int)**<br>
+- **sleep(val:int)**
 An empty function that returns a promise that will resolve after X milliseconds, default is set to 1000ms.
-<br>
+**
 
 ### hash
-- **guid()**<br>
+- **guid()**
 Generate a unique identifier (guid) according to RFC4122
 ```
 guid(); // 245caf1a-86af-11e7-bb31-be2e44b06b34
 ```
 
-- **fnv1A(val:any)**<br>
+- **fnv1A(val:any)**
 Generate a fnv1A hash from an object, using a 32-bit prime/offset
 ```
 fnv1A('hello world'); // -2023343616
@@ -209,7 +309,7 @@ fnv1A(new Date('2012-02-02')); // 1655579136
 ```
 
 ### number
-- **isNumber(val:any)**<br>
+- **isNumber(val:any)**
 Check if a variable is a number
 ```
 isNumber('foo'); // FALSE
@@ -217,7 +317,7 @@ isNumber(4); // TRUE
 isNumber(0.5); // TRUE
 ```
 
-- **isNumberAbove(val:number, comp:number)**<br>
+- **isNumberAbove(val:number, comp:number)**
 Check if a variable is above a certain bound
 ```
 isNumberAbove(5, 0); // TRUE
@@ -226,7 +326,7 @@ isNumberAbove(-1, -1); // FALSE
 isNumberAbove(-10, -9); // FALSE
 ```
 
-- **isNumberBelow(val:number, comp:number)**<br>
+- **isNumberBelow(val:number, comp:number)**
 Check if a variable is below a certain bound
 ```
 isNumberBelow(0, 5); // TRUE
@@ -235,7 +335,7 @@ isNumberBelow(-1, -1); // FALSE
 isNumberBelow(-9, -10); // FALSE
 ```
 
-- **isNumberBetween(val:number, min:number, max:number)**<br>
+- **isNumberBetween(val:number, min:number, max:number)**
 Check if a variable is between a range of numbers
 ```
 isNumberBetween(5, 0, 10); // TRUE
@@ -245,14 +345,51 @@ isNumberBetween(0, 0, 1); // TRUE
 isNumberBetween(-1, 0, 1); // FALSE
 ```
 
-- **isNumericalNaN(val:any)**<br>
+- **isInteger(val:any)**
+Check if a variable is an integer
+```
+isInteger('foo'); // FALSE
+isInteger(4); // TRUE
+isInteger(0.5); // FALSE
+```
+
+- **isIntegerAbove(val:number, comp:number)**
+Check if a variable is an integer above a certain bound
+```
+isIntegerAbove(5, 0); // TRUE
+isIntegerAbove(.1, 0); // FALSE
+isIntegerAbove(-1, -1); // FALSE
+isIntegerAbove(-10, -9); // FALSE
+```
+
+- **isIntegerBelow(val:number, comp:number)**
+Check if a variable is an integer below a certain bound
+```
+isIntegerBelow(0, 5); // TRUE
+isIntegerBelow(0, .1); // TRUE
+isIntegerBelow(.4, 5); // FALsE
+isIntegerBelow(-1, -1); // FALSE
+isIntegerBelow(-9, -10); // FALSE
+```
+
+- **isIntegerBetween(val:number, min:number, max:number)**
+Check if a variable is an integer between a range of numbers
+```
+isIntegerBetween(5, 0, 10); // TRUE
+isIntegerBetween(.1, 0, 1); // FALSE
+isIntegerBetween(-.1, -1, 0); // FALSE
+isIntegerBetween(0, 0, 1); // TRUE
+isIntegerBetween(-1, 0, 1); // FALSE
+```
+
+- **isNumericalNaN(val:any)**
 Check if a variable is a numerical nan ( a number that is a NaN, this distinguishment is made since both a string or a number can be NaN)
 ```
 isNumericalNaN('foo'); // FALSE
 isNumericalNaN(NaN); // TRUE
 ```
 
-- **toPercentage(val:Number,precision:Number=0,min:Number=0,max:Number=1)**<br>
+- **toPercentage(val:Number,precision:Number=0,min:Number=0,max:Number=1)**
 Calculate the percentage of a specific value in a range
 ```
 toPercentage(0.50106579, 5); // 50.11658
@@ -260,7 +397,7 @@ toPercentage(-356, 0, -1000, 1000); // 32
 toPercentage(0.5); // 50
 ```
 
-- **round(val:Number,precision:Number=0)**<br>
+- **round(val:Number,precision:Number=0)**
 Round a numeric value to a specific amount of decimals
 ```
 round(5.123456789, 0); // 5
@@ -268,7 +405,7 @@ round(5.123456789, 2); // 5.12
 round(5.123456789, 5); // 5.12346
 ```
 
-- **randomBetween(min:Number=0,max:Number=10)**<br>
+- **randomBetween(min:Number=0,max:Number=10)**
 Generate a random numeric value between a min and max range
 ```
 randomBetween(); // Will generate a random between 0 and 10
@@ -276,21 +413,21 @@ randomBetween(25, 100); // Will generate a random between 25 and 100
 ```
 
 ### object
-- **forValues(obj:Object={}, cb:Function=noopreturn)**<br>
+- **forValues(obj:Object={}, cb:Function=noopreturn)**
 Iterate over the keys of the object and apply the callback function to their values
 ```
 const obj = {a: 1, b: 2, c: 3};
 forValues(obj, (key, value, index) => value + 1); // {a: 2, b:3, c:4}
 ```
 
-- **isObject(val:any)**<br>
+- **isObject(val:any)**
 Check if a variable is of type Object
 ```
 isObject({a: 1}); // TRUE
 isObject(1); // FALSE
 ```
 
-- **isNotEmptyObject(val:any)**<br>
+- **isNotEmptyObject(val:any)**
 Check if a variable a non-empty object
 ```
 isNotEmptyObject({a:1}); // TRUE
@@ -298,20 +435,20 @@ isNotEmptyObject({}); // FALSE
 isNotEmptyObject('Hi'); // FALSE
 ```
 
-- **pick(obj:Object={}, keys:Array[string]=[])**<br>
-Copies the keys passed in the 'keys' array from the passed object to a new object and returns that object.<br>
+- **pick(obj:Object={}, keys:Array[string]=[])**
+Copies the keys passed in the 'keys' array from the passed object to a new object and returns that object.**
 <small>If a key wasn't found it will be set as undefined</small>
 ```
 pick({a: 1, b: 2, c: 3}, ['a','b']); // {a: 1, b: 2}
 ```
 
-- **merge(target:Object={},obj:Object={})**<br>
+- **merge(target:Object={},obj:Object={})**
 Merges two objects together, with the preference over the second object.
 ```
 merge({a: 1, b: false}, {a: 900, c: 50}); // {a: 900, b: false, c: 50}
 ```
 
-- **zip(keys:Array[string]=[], values:Array[string]=[], default_to:any=null)**<br>
+- **zip(keys:Array[string]=[], values:Array[string]=[], default_to:any=null)**
 Creates an object from a keys and a values array. Mapping them together.
 ```
 zip(['a', 'b'], [100, 200]); // {a: 100, b: 200}
@@ -323,7 +460,7 @@ zip(['a','b']); // {a: null, b: null}
 zip(['a','b', false, 9999]); // {a: 9999, b: 9999}
 ```
 
-- **define(props:Object, obj:Object={})**<br>
+- **define(props:Object, obj:Object={})**
 Creates an object with the passed accessors set on it
 ```
 define(
@@ -346,7 +483,7 @@ define({
 }); // { a : () => ... }
 ```
 
-- **defineFrozen(props:Object, obj:Object={})**<br>
+- **defineFrozen(props:Object, obj:Object={})**
 Creates an object with the passed accessors set on it, and returns it as a frozen object
 ```
 const myObject = defineFrozen({
@@ -359,7 +496,7 @@ myObject; // { a : () => ... }
 Object.isFrozen(myObject); // TRUE
 ```
 
-- **defineSealed(props:Object, obj:Object={})**<br>
+- **defineSealed(props:Object, obj:Object={})**
 Creates an object with the passed accessors set on it, and returns it as a sealed object
 ```
 const myObject = defineSealed({
@@ -373,7 +510,7 @@ Object.isSealed(myObject); // TRUE
 ```
 
 ### regexp
-- **isRegExp(val:any)**<br>
+- **isRegExp(val:any)**
 Check if a variable is an instance of RegExp
 ```
 isRegExp('foo'); // FALSE
@@ -383,14 +520,14 @@ isRegExp(/ab+c/i); // FALSE
 ```
 
 ### string
-- **isString(val:any)**<br>
+- **isString(val:any)**
 Check if a variable is a string
 ```
 isString('foo'); // TRUE
 isString(4); // FALSE
 ```
 
-- **isStringBetween(val:string, min:number, max:number, trimmed:boolean=true)**<br>
+- **isStringBetween(val:string, min:number, max:number, trimmed:boolean=true)**
 Check if a variable is between a range of numbers
 ```
 isStringBetween('Peter', 4, 10); // TRUE
@@ -401,7 +538,7 @@ isStringBetween('    Joe', 1, 3); // TRUE
 isStringBetween('    Joe', 1, 3, false); // FALSE
 ```
 
-- **isNotEmptyString(val:any, trimmed:boolean=true)**<br>
+- **isNotEmptyString(val:any, trimmed:boolean=true)**
 Check if a variable a non-empty string
 ```
 isNotEmptyString({a:1}); // FALSE
@@ -411,5 +548,15 @@ isNotEmptyString(' ', false); // TRUE
 isNotEmptyString('Hi'); // TRUE
 ```
 
+- **shorten(val:any, length:integer, postfix:string=...)**
+Shorten a string and add a postfix if string went over length
+```
+shorten('To the moon and beyond', 11, '..'); // 'To the moon..'
+shorten('Hi', 250); // 'Hi'
+shorten('To the moon and beyond'); // 'To the moon...'
+shorten('To the moon and beyond', 11, ' '); // 'To the moon '
+```
+
 ## Contributors
 - Peter Vermeulen : [Valkyrie Studios](www.valkyriestudios.be) 
+

package/array/dedupe.js

@@ -7,10 +7,13 @@ exports["default"] = _default;
 
 var _fnv1A = _interopRequireDefault(require("../hash/fnv1A"));
 
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 function _default() {
   var val = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  if (!(0, _isNotEmpty["default"])(val)) return [];
   var seen = {};
   return val.filter(function (item) {
     var hash = (0, _fnv1A["default"])(item);

package/array/join.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+exports["default"] = _default;
+
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
+var _isNotEmpty2 = _interopRequireDefault(require("../string/isNotEmpty"));
+
+var _is = _interopRequireDefault(require("../number/is"));
+
+var _isNotEmpty3 = _interopRequireDefault(require("../object/isNotEmpty"));
+
+var _round = _interopRequireDefault(require("../number/round"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: !0 }; return { done: !1, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = !0, didErr = !1, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = !0; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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 _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 _default(arr) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (!(0, _isNotEmpty["default"])(arr)) return '';
+  var OPTS = Object.assign({
+    delim: ' ',
+    trim: !0,
+    valtrim: !0,
+    valround: !1
+  }, (0, _isNotEmpty3["default"])(options) ? options : {});
+  var filtered = [];
+
+  var _iterator = _createForOfIteratorHelper(arr),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var el = _step.value;
+
+      if ((0, _isNotEmpty2["default"])(el)) {
+        filtered.push(OPTS.valtrim === !0 ? el.trim() : el);
+      } else if ((0, _is["default"])(el)) {
+        filtered.push((0, _is["default"])(OPTS.valround) ? (0, _round["default"])(el, OPTS.valround) : el);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return OPTS.trim === !0 ? filtered.join(OPTS.delim).trim() : filtered.join(OPTS.delim);
+}

package/array/mapFn.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+exports["default"] = _default;
+
+var _is = _interopRequireDefault(require("../object/is"));
+
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
+var _is2 = _interopRequireDefault(require("../function/is"));
+
+var _isNotEmpty2 = _interopRequireDefault(require("../string/isNotEmpty"));
+
+var _is3 = _interopRequireDefault(require("../number/is"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: !0 }; return { done: !1, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = !0, didErr = !1, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = !0; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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 _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 _default(arr, fn) {
+  var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!(0, _isNotEmpty["default"])(arr) || !(0, _is2["default"])(fn)) return {};
+  var OPTS = Object.assign({
+    merge: !1
+  }, (0, _is["default"])(opts) ? opts : {});
+  var map = {};
+  var hash = !1;
+
+  var _iterator = _createForOfIteratorHelper(arr),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var el = _step.value;
+      if (!(0, _is["default"])(el)) continue;
+      hash = fn(el);
+      if (!(0, _is3["default"])(hash) && !(0, _isNotEmpty2["default"])(hash)) continue;
+
+      if (OPTS.merge === !0 && map.hasOwnProperty(hash)) {
+        map[hash] = Object.assign(map[hash], el);
+      } else {
+        map[hash] = el;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return map;
+}

package/array/mapKey.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+exports["default"] = _default;
+
+var _is = _interopRequireDefault(require("../object/is"));
+
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
+var _isNotEmpty2 = _interopRequireDefault(require("../string/isNotEmpty"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: !0 }; return { done: !1, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = !0, didErr = !1, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = !0; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+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 _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 _default(arr, key) {
+  var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!(0, _isNotEmpty["default"])(arr) || !(0, _isNotEmpty2["default"])(key)) return {};
+  var OPTS = Object.assign({
+    merge: !1
+  }, (0, _is["default"])(opts) ? opts : {});
+  var map = {};
+
+  var _iterator = _createForOfIteratorHelper(arr),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var el = _step.value;
+      if (!(0, _is["default"])(el) || !el.hasOwnProperty(key)) continue;
+
+      if (OPTS.merge === !0 && map.hasOwnProperty(el[key])) {
+        map[el[key]] = Object.assign(map[el[key]], el);
+      } else {
+        map[el[key]] = el;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return map;
+}