@valkyriestudios/utils 5.1.0 → 5.3.0

package/README.md

@@ -12,24 +12,24 @@ 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
-```
+```js
 isArray({a:1}); // FALSE
 isArray([]); // TRUE
 ```
 
-- **isNotEmptyArray(val:any)**<br>
+- **isNotEmptyArray(val:any)**
 Check if a variable a non-empty array
-```
+```js
 isNotEmptyArray({a:1}); // FALSE
 isNotEmptyArray([]); // FALSE
 isNotEmptyArray([0, 1, 2]); // TRUE
 ```
 
-- **mapKey(val:array[Object], key:string, opts:object={})**<br>
+- **mapKey(val:array[Object], key:string, opts:object={})**
 Map a non-primitive object array into an object map by key
-```
+```js
 mapKey([
     {uid: 12, name: 'Peter'},
     {uid: 15, name: 'Jonas'},
@@ -46,7 +46,7 @@ output:
 ```
 
 Autofilters anything not meeting the spec:
-```
+```js
 [
     0,
     {uid: 12, name: 'Peter'},
@@ -70,7 +70,7 @@ output:
 ```
 
 allows merging objects onto existing keys: 
-```
+```js
 [
     0,
     {uid: 12, name: 'Peter'},
@@ -96,10 +96,10 @@ output:
 }
 ```
 
-- **mapFn(val:array[Object], key:Function, opts:object={})**<br>
+- **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:
 
-```
+```js
 mapFn([
     {uid: 12, name: 'Peter'},
     {uid: 15, name: 'Jonas'},
@@ -117,17 +117,17 @@ output:
 
 options are the same as the mapKey function
 
-- **mapPrimitive(val:any, opts:object={keytrim:true,valtrim:false,keyround:false,valround:false})**<br>
+- **mapPrimitive(val:any, opts:object={keytrim:true,valtrim:false,keyround:false,valround:false})**
 Map an array of primitives (number/string)
-```
+```js
 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)**<br>
+- **dedupe(val:Array)**
 Remove all duplicates from an array, behind the scenes it uses the fnv 1A hash algorithm to performantly do comparisons.
-```
+```js
 dedupe(['a','a','b','c','c']); // ['a', 'b', 'c']
 dedupe(['1',1,'2',2]); // ['1','2']
 dedupe([new RegExp(/ab+c/, 'i'), new RegExp(/ab+c/, 'i')]); // [new RegExp(/ab+c/, 'i')]
@@ -135,36 +135,47 @@ 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.
+
+```js
+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
-```
+```js
 isBoolean(null); // FALSE
 isBoolean(false); // TRUE
 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
-```
+```js
 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
-```
+```js
 isDate(new Date('December 17, 1995 03:24:00'); // TRUE
 isDate('December 17, 1995 03:24:00'); // FALSE
 ```
 
 ### deep
-- **deepFreeze(val:Object)**<br>
+- **deepFreeze(val:Object)**
 Recursively freezes all properties of an object
-```
+```js
 const myObj = deepFreeze({
 	a: 2,
 	b: {
@@ -179,9 +190,9 @@ 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
-```
+```js
 const myObj = deepSeal({
 	a: 2,
 	b: {
@@ -197,16 +208,17 @@ 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
-```
+```js
 const myObj = {
 	a: 2,
 });
 deepSet(myObj, 'b.c.d.e', 4);
 myObj.b.c.d.e; // 4
 ```
-```
+
+```js
 const myObj = {
 	a: 2,
 	b: [
@@ -219,7 +231,8 @@ deepSet(myObj, 'b[1].price', 500);
 myObj.b[0].price; // 100
 myObj.b[1].price; // 500
 ```
-```
+
+```js
 const myObj = {
 	a: 2,
 });
@@ -227,9 +240,9 @@ 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
-```
+```js
 const myObj = {
 	a: 2,
 	b: [
@@ -239,7 +252,8 @@ const myObj = {
 });
 deepGet(myObj, 'b[0].price', true); // [{price: 2}, {price: 4}]
 ```
-```
+
+```js
 const myObj = {
 	a: 2,
 	b: [
@@ -251,9 +265,9 @@ 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
-```
+```js
 equal(5, 6); // FALSE
 equal(1, 1); // TRUE
 equal([0, 1, 2], [1, 2]); // FALSE
@@ -263,42 +277,33 @@ 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
-```
+```js
 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
-```
+```js
 fnv1A('hello world'); // -2023343616
 fnv1A({a:1,b:2}); // 361168128
 fnv1A(4); // 1630425728
@@ -307,35 +312,35 @@ fnv1A(new Date('2012-02-02')); // 1655579136
 ```
 
 ### number
-- **isNumber(val:any)**<br>
+- **isNumber(val:any)**
 Check if a variable is a number
-```
+```js
 isNumber('foo'); // FALSE
 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
-```
+```js
 isNumberAbove(5, 0); // TRUE
 isNumberAbove(.1, 0); // TRUE
 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
-```
+```js
 isNumberBelow(0, 5); // TRUE
 isNumberBelow(0, .1); // TRUE
 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
-```
+```js
 isNumberBetween(5, 0, 10); // TRUE
 isNumberBetween(.1, 0, 1); // TRUE
 isNumberBetween(-.1, -1, 0); // TRUE
@@ -343,87 +348,126 @@ isNumberBetween(0, 0, 1); // TRUE
 isNumberBetween(-1, 0, 1); // FALSE
 ```
 
-- **isNumericalNaN(val:any)**<br>
-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)
+- **isInteger(val:any)**
+Check if a variable is an integer
+```js
+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
+```js
+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
+```js
+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
+```js
+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)
+```js
 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
-```
+```js
 toPercentage(0.50106579, 5); // 50.11658
 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
-```
+```js
 round(5.123456789, 0); // 5
 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
-```
+```js
 randomBetween(); // Will generate a random between 0 and 10
 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
-```
+```js
 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
-```
+```js
 isObject({a: 1}); // TRUE
 isObject(1); // FALSE
 ```
 
-- **isNotEmptyObject(val:any)**<br>
+- **isNotEmptyObject(val:any)**
 Check if a variable a non-empty object
-```
+```js
 isNotEmptyObject({a:1}); // TRUE
 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>
-```
+```js
 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.
-```
+```js
 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.
-```
+```js
 zip(['a', 'b'], [100, 200]); // {a: 100, b: 200}
 ```
-```
+
+```js
 zip(['a','b']); // {a: null, b: null}
 ```
-```
+
+```js
 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
-```
+```js
 define(
 	{ 
 		a: {
@@ -435,7 +479,8 @@ define(
 );
 // { a : () => ..., b: 2 }
 ```
-```
+
+```js
 define({
 	a : {
 		enumerable: false,
@@ -444,9 +489,9 @@ 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
-```
+```js
 const myObject = defineFrozen({
 	a : {
 		enumerable: false,
@@ -457,9 +502,9 @@ 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
-```
+```js
 const myObject = defineSealed({
 	a : {
 		enumerable: false,
@@ -471,9 +516,9 @@ Object.isSealed(myObject); // TRUE
 ```
 
 ### regexp
-- **isRegExp(val:any)**<br>
+- **isRegExp(val:any)**
 Check if a variable is an instance of RegExp
-```
+```js
 isRegExp('foo'); // FALSE
 isRegExp(new RegExp('ab+c', 'i')); // TRUE
 isRegExp(new RegExp(/ab+c/, 'i')); // TRUE
@@ -481,16 +526,16 @@ isRegExp(/ab+c/i); // FALSE
 ```
 
 ### string
-- **isString(val:any)**<br>
+- **isString(val:any)**
 Check if a variable is a string
-```
+```js
 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
-```
+```js
 isStringBetween('Peter', 4, 10); // TRUE
 isStringBetween('Jeff', 4, 10); // TRUE
 isStringBetween('Moe', 4, 10); // FALSE
@@ -499,9 +544,9 @@ 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
-```
+```js
 isNotEmptyString({a:1}); // FALSE
 isNotEmptyString(''); // FALSE
 isNotEmptyString(' '); // FALSE
@@ -509,9 +554,9 @@ isNotEmptyString(' ', false); // TRUE
 isNotEmptyString('Hi'); // TRUE
 ```
 
-- **shorten(val:any, length:integer, postfix:string=...)**<br>
+- **shorten(val:any, length:integer, postfix:string=...)**
 Shorten a string and add a postfix if string went over length
-```
+```js
 shorten('To the moon and beyond', 11, '..'); // 'To the moon..'
 shorten('Hi', 250); // 'Hi'
 shorten('To the moon and beyond'); // 'To the moon...'
@@ -520,3 +565,4 @@ shorten('To the moon and beyond', 11, ' '); // 'To the moon '
 
 ## Contributors
 - Peter Vermeulen : [Valkyrie Studios](www.valkyriestudios.be) 
+

package/array/dedupe.js

@@ -4,21 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: !0
 });
 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);
+
     if (Object.prototype.hasOwnProperty.call(seen, hash)) return !1;
+
     seen[hash] = !0;
+
     return !0;
   });
 }

package/array/is.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: !0
 });
 exports["default"] = _default;
-
 function _default(val) {
   return Array.isArray(val);
 }

package/array/isNotEmpty.js

@@ -4,11 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: !0
 });
 exports["default"] = _default;
-
 var _is = _interopRequireDefault(require("./is"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
 function _default(val) {
   if (!(0, _is["default"])(val)) return !1;
   return val.length !== 0;

package/array/join.js

@@ -0,0 +1,43 @@
+'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);
+}