@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/object/getRow.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Returns the first object matching the given filter in an array of objects.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method    getRow
+ * @global
+ * @example
+ * ```javascript
+ * let ar = [
+ *   {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ *   {name: "Goonies", director: "Richard Donner", year: 1985, id: 689},
+ *   {name: "Star wars", director: "George Lucas", year: 1977, id: 256},
+ *   {name: "Jaws", director: "Steven Spielberg", year: 1975, id: 423}
+ * ];
+ * bbn.fn.getRow(ar, {director: "Steven Spielberg"});
+ * // {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ * bbn.fn.getRow(ar, "director", "Steven Spielberg");
+ * // Same result as the previous example
+ * bbn.fn.getRow(ar, {
+ *   logic: "OR",
+ *   conditions: [
+ *     {
+ *        field: "director",
+ *        value: "Richard Donner"
+ *     }, {
+ *        field: "director",
+ *        value: "George Lucas"
+ *     }
+ *   ]
+ * );
+ * // {name: "Goonies", director: "Richard Donner", year: 1985, id: 689},
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}                    arr       The subject array
+ * @param    {(String|Object|Function)} prop      A property's name or a filter object or function
+ * @param    {*}                        val       The value with which comparing the given property
+ * @param    {String}                   operator  The operator to use for comparison with the value as used in bbn.fn.compare
+ * @returns  {Object|Boolean}           The item if found, false otherwise
+ */
+declare const getRow: (arr: any[], prop: object | string, val?: any, operator?: string) => any | false;
+export { getRow };

package/dist/fn/object/getRow.js

@@ -0,0 +1,49 @@
+import { search } from './search';
+/**
+ * Returns the first object matching the given filter in an array of objects.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method    getRow
+ * @global
+ * @example
+ * ```javascript
+ * let ar = [
+ *   {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ *   {name: "Goonies", director: "Richard Donner", year: 1985, id: 689},
+ *   {name: "Star wars", director: "George Lucas", year: 1977, id: 256},
+ *   {name: "Jaws", director: "Steven Spielberg", year: 1975, id: 423}
+ * ];
+ * bbn.fn.getRow(ar, {director: "Steven Spielberg"});
+ * // {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ * bbn.fn.getRow(ar, "director", "Steven Spielberg");
+ * // Same result as the previous example
+ * bbn.fn.getRow(ar, {
+ *   logic: "OR",
+ *   conditions: [
+ *     {
+ *        field: "director",
+ *        value: "Richard Donner"
+ *     }, {
+ *        field: "director",
+ *        value: "George Lucas"
+ *     }
+ *   ]
+ * );
+ * // {name: "Goonies", director: "Richard Donner", year: 1985, id: 689},
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}                    arr       The subject array
+ * @param    {(String|Object|Function)} prop      A property's name or a filter object or function
+ * @param    {*}                        val       The value with which comparing the given property
+ * @param    {String}                   operator  The operator to use for comparison with the value as used in bbn.fn.compare
+ * @returns  {Object|Boolean}           The item if found, false otherwise
+ */
+const getRow = function (arr, prop, val = null, operator = '=') {
+    var idx = search(arr, prop, val, operator);
+    if (idx > -1) {
+        return arr[idx];
+    }
+    return false;
+};
+export { getRow };

package/dist/fn/object/map.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Returns a new array generated by the execution of a function for each item of the given array.
+ *
+ * The deepProp argument is the name of property which should contain a nested array on which
+ * the function should also be applied recursively.
+ *
+ * @method   map
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.map([1, 2, 3, 4], a => {
+ *   return a + 1;
+ * });
+ * // [2, 3, 4, 5]
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.map(
+ *   [{
+ *     name: "tools",
+ *     items: [
+ *       {
+ *          name: "hammers"
+ *       }, {
+ *          name: "screwdrivers",
+ *          items: [
+ *            {name: "flat screwdrivers"},
+ *            {name: "slotted screwdrivers"},
+ *            {name: "Hex screwdrivers"},
+ *          ]
+ *       }
+ *     ]
+ *   }, {
+ *     name: "Kitchenware"
+ *   }],
+ *   d => {
+ *     d.warranty = d.name === "Hex screwdrivers" ? "10 years" : "1 year";
+ *     return d;
+ *   },
+ *   "items"
+ * );
+ * // [
+ * //    {
+ * //       name: "tools",
+ * //       warranty: "1 year",
+ * //       items: [
+ * //         {
+ * //            name: "hammers",
+ * //            warranty: "1 year",
+ * //         }, {
+ * //            name: "screwdrivers",
+ * //            warranty: "1 year",
+ * //            items: [
+ * //              {name: "flat screwdrivers", warranty: "1 year"},
+ * //              {name: "slotted screwdrivers", warranty: "1 year"},
+ * //              {name: "Hex screwdrivers", warranty: "10 year"},
+ * //            ]
+ * //         }
+ * //       ]
+ * //    }, {
+ * //       name: "Kitchenware",
+ * //       warranty: "1 year"
+ * //    }
+ * // ]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}    arr
+ * @param    {Function} fn
+ * @param    {Boolean}  deepProp
+ * @param    {Number}   level
+ * @returns  {Array}
+ */
+declare const map: (arr: any, fn: any, deepProp: any, level?: number) => any;
+export { map };

package/dist/fn/object/map.js

@@ -0,0 +1,83 @@
+import { isArray } from "../type/isArray";
+/**
+ * Returns a new array generated by the execution of a function for each item of the given array.
+ *
+ * The deepProp argument is the name of property which should contain a nested array on which
+ * the function should also be applied recursively.
+ *
+ * @method   map
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.map([1, 2, 3, 4], a => {
+ *   return a + 1;
+ * });
+ * // [2, 3, 4, 5]
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.map(
+ *   [{
+ *     name: "tools",
+ *     items: [
+ *       {
+ *          name: "hammers"
+ *       }, {
+ *          name: "screwdrivers",
+ *          items: [
+ *            {name: "flat screwdrivers"},
+ *            {name: "slotted screwdrivers"},
+ *            {name: "Hex screwdrivers"},
+ *          ]
+ *       }
+ *     ]
+ *   }, {
+ *     name: "Kitchenware"
+ *   }],
+ *   d => {
+ *     d.warranty = d.name === "Hex screwdrivers" ? "10 years" : "1 year";
+ *     return d;
+ *   },
+ *   "items"
+ * );
+ * // [
+ * //    {
+ * //       name: "tools",
+ * //       warranty: "1 year",
+ * //       items: [
+ * //         {
+ * //            name: "hammers",
+ * //            warranty: "1 year",
+ * //         }, {
+ * //            name: "screwdrivers",
+ * //            warranty: "1 year",
+ * //            items: [
+ * //              {name: "flat screwdrivers", warranty: "1 year"},
+ * //              {name: "slotted screwdrivers", warranty: "1 year"},
+ * //              {name: "Hex screwdrivers", warranty: "10 year"},
+ * //            ]
+ * //         }
+ * //       ]
+ * //    }, {
+ * //       name: "Kitchenware",
+ * //       warranty: "1 year"
+ * //    }
+ * // ]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}    arr
+ * @param    {Function} fn
+ * @param    {Boolean}  deepProp
+ * @param    {Number}   level
+ * @returns  {Array}
+ */
+const map = function (arr, fn, deepProp, level = 0) {
+    return arr.map((a, i) => {
+        a = fn(a, i, level);
+        if (deepProp && a[deepProp] && isArray(a[deepProp])) {
+            a[deepProp] = map(a[deepProp], fn, deepProp, level + 1);
+        }
+        return a;
+    });
+};
+export { map };

package/dist/fn/object/move.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Moves an element to a different position within the given array.
+ *
+ * The same array is returned, with its elements reordered according to the executed movement.
+ *
+ * @method   move
+ * @global
+ * @todo     Finish doc
+ * @example
+ * ```javascript
+ * bbbn.fn.move([
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Out of Africa", year: 1985}
+ * ], 1, 2);
+ * // [
+ * //   {movie: "Brazil", year: 1985},
+ * //   {movie: "Out of Africa", year: 1985},
+ * //   {movie: "Donnie Darko", year: 2001}
+ * // ]
+ * ```
+ *  @example
+ * ```javascript
+ * bbn.fn.move([1, 2, 3, 4], 3, 0);
+ * // [4, 1, 2, 3]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}  arr       The array
+ * @param    {Number} fromIndex The index of the element to move
+ * @param    {Number} toIndex   The future index of the element
+ * @returns  {Array}  The same array, with elements repositionned.
+ */
+declare const move: (arr: any[], fromIndex: number, toIndex: number) => any[];
+export { move };

package/dist/fn/object/move.js

@@ -0,0 +1,43 @@
+/**
+ * Moves an element to a different position within the given array.
+ *
+ * The same array is returned, with its elements reordered according to the executed movement.
+ *
+ * @method   move
+ * @global
+ * @todo     Finish doc
+ * @example
+ * ```javascript
+ * bbbn.fn.move([
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Out of Africa", year: 1985}
+ * ], 1, 2);
+ * // [
+ * //   {movie: "Brazil", year: 1985},
+ * //   {movie: "Out of Africa", year: 1985},
+ * //   {movie: "Donnie Darko", year: 2001}
+ * // ]
+ * ```
+ *  @example
+ * ```javascript
+ * bbn.fn.move([1, 2, 3, 4], 3, 0);
+ * // [4, 1, 2, 3]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}  arr       The array
+ * @param    {Number} fromIndex The index of the element to move
+ * @param    {Number} toIndex   The future index of the element
+ * @returns  {Array}  The same array, with elements repositionned.
+ */
+const move = function (arr, fromIndex, toIndex) {
+    if (toIndex >= arr.length) {
+        let k = toIndex - arr.length;
+        while (k-- + 1) {
+            arr.push(undefined);
+        }
+    }
+    arr.splice(toIndex, 0, arr.splice(fromIndex, 1)[0]);
+    return arr;
+};
+export { move };

package/dist/fn/object/multiorder.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Sorts an array of objects based on a set of properties.
+ *
+ * The resulting array is the same object, the order is based on _compareValues function
+ * applied for each given properties in orders argument.
+ *
+ * @method   multiorder
+ * @global
+ * @example
+ * ```javascript
+ * let ar = [
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Out of Africa", year: 1985},
+ *   {movie: "Ran", year: 1985},
+ *   {movie: "Back to the future", year: 1985},
+ *   {movie: "Barry Lindon", year: 1976}
+ * ];
+ * bbn.fn.multiorder(ar, [
+ *   {field: "year", dir: "desc"},
+ *   {field: "movie", dir: "asc"}
+ * ]);
+ * // [
+ * //   {movie: "Donnie Darko", year: 2001},
+ * //   {movie: "Back to the future", year: 1985},
+ * //   {movie: "Brazil", year: 1985},
+ * //   {movie: "Out of Africa", year: 1985},
+ * //   {movie: "Ran", year: 1985},
+ * //   {movie: "Barry Lindon", year: 1976}
+ * // ]
+ * bbn.fn.multiorder(ar, {year: "desc", movie: "asc"});
+ * // Same result with object shortcut
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}        arr    The array to order
+ * @param    {Array|Object} orders The properties and directions (asc, desc) to order by
+ * @returns  {Array}        The same array (arr), ordered differently
+ */
+declare const multiorder: (arr: object[], orders: object | BbnOrderItem[]) => object[];
+export { multiorder };

package/dist/fn/object/multiorder.js

@@ -0,0 +1,60 @@
+import { _compareValues } from './_compareValues';
+/**
+ * Sorts an array of objects based on a set of properties.
+ *
+ * The resulting array is the same object, the order is based on _compareValues function
+ * applied for each given properties in orders argument.
+ *
+ * @method   multiorder
+ * @global
+ * @example
+ * ```javascript
+ * let ar = [
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Out of Africa", year: 1985},
+ *   {movie: "Ran", year: 1985},
+ *   {movie: "Back to the future", year: 1985},
+ *   {movie: "Barry Lindon", year: 1976}
+ * ];
+ * bbn.fn.multiorder(ar, [
+ *   {field: "year", dir: "desc"},
+ *   {field: "movie", dir: "asc"}
+ * ]);
+ * // [
+ * //   {movie: "Donnie Darko", year: 2001},
+ * //   {movie: "Back to the future", year: 1985},
+ * //   {movie: "Brazil", year: 1985},
+ * //   {movie: "Out of Africa", year: 1985},
+ * //   {movie: "Ran", year: 1985},
+ * //   {movie: "Barry Lindon", year: 1976}
+ * // ]
+ * bbn.fn.multiorder(ar, {year: "desc", movie: "asc"});
+ * // Same result with object shortcut
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}        arr    The array to order
+ * @param    {Array|Object} orders The properties and directions (asc, desc) to order by
+ * @returns  {Array}        The same array (arr), ordered differently
+ */
+const multiorder = function (arr, orders) {
+    let currentOrders;
+    if (!Array.isArray(orders) && typeof orders === 'object') {
+        currentOrders = [];
+        for (var n in orders) {
+            currentOrders.push({ field: n, dir: orders[n] });
+        }
+    }
+    let r = arr.slice();
+    return r.sort((a, b) => {
+        let res;
+        for (let order of currentOrders) {
+            res = _compareValues(a, b, order.field, order.dir);
+            if (res !== 0) {
+                return res;
+            }
+        }
+        return 0;
+    });
+};
+export { multiorder };

package/dist/fn/object/numProperties.d.ts

@@ -0,0 +1,31 @@
+/**
+  * Returns the number of properties contained in the object.
+  *
+  * Only takes into account the own properties - not the inherited ones - and the non _private_ ones.
+  *
+  * @method   numProperties
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.numProperties({author: "Chuck Palahniuk", "title": "Fight club"});
+  * // 2
+  * ```
+  * @example
+  * ```javascript
+  * bbn.fn.numProperties({username: "chuck", "password": "soap", _bbn_timestamp: 1587323193751});
+  * // 2
+  * @example
+  * ```javascript
+  * let d = new Date();
+  * bbn.fn.numProperties(d);
+  * // 0
+  * d.myProp = 1;
+  * bbn.fn.numProperties(d);
+  * // 1
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object} obj The object to analyze
+  * @returns  {Number} The number of properties
+  */
+declare const numProperties: (obj: object) => number;
+export { numProperties };

package/dist/fn/object/numProperties.js

@@ -0,0 +1,36 @@
+/**
+  * Returns the number of properties contained in the object.
+  *
+  * Only takes into account the own properties - not the inherited ones - and the non _private_ ones.
+  *
+  * @method   numProperties
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.numProperties({author: "Chuck Palahniuk", "title": "Fight club"});
+  * // 2
+  * ```
+  * @example
+  * ```javascript
+  * bbn.fn.numProperties({username: "chuck", "password": "soap", _bbn_timestamp: 1587323193751});
+  * // 2
+  * @example
+  * ```javascript
+  * let d = new Date();
+  * bbn.fn.numProperties(d);
+  * // 0
+  * d.myProp = 1;
+  * bbn.fn.numProperties(d);
+  * // 1
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object} obj The object to analyze
+  * @returns  {Number} The number of properties
+  */
+const numProperties = function (obj) {
+    if (!obj || typeof obj !== 'object') {
+        return 0;
+    }
+    return Object.keys(obj).length;
+};
+export { numProperties };

package/dist/fn/object/order.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sorts an array of objects based on the given property.
+ *
+ * The resulting array is the same object, the order is based on _compareValues function.
+ *
+ * @method   order
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.order([
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Barry Lindon", year: 1976}
+ * ], 'year', 'DESC')
+ * // [
+ * //   {movie: "Donnie Darko", year: 2001},
+ * //   {movie: "Brazil", year: 1985},
+ * //   {movie: "Barry Lindon", year: 1976}
+ * // ]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}  arr       The array to order
+ * @param    {String} prop      The property on which the order is based
+ * @param    {String} [dir=asc] The direction of the order (desc or asc by default)
+ * @returns  {Array}
+ */
+declare const order: (arr: any, prop: any, dir?: string) => any;
+export { order };

package/dist/fn/object/order.js

@@ -0,0 +1,36 @@
+import { _compareValues } from './_compareValues';
+/**
+ * Sorts an array of objects based on the given property.
+ *
+ * The resulting array is the same object, the order is based on _compareValues function.
+ *
+ * @method   order
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.order([
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Barry Lindon", year: 1976}
+ * ], 'year', 'DESC')
+ * // [
+ * //   {movie: "Donnie Darko", year: 2001},
+ * //   {movie: "Brazil", year: 1985},
+ * //   {movie: "Barry Lindon", year: 1976}
+ * // ]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}  arr       The array to order
+ * @param    {String} prop      The property on which the order is based
+ * @param    {String} [dir=asc] The direction of the order (desc or asc by default)
+ * @returns  {Array}
+ */
+const order = function (arr, prop, dir = 'asc') {
+    if (arr) {
+        return arr.sort(function (a, b) {
+            return _compareValues(a, b, prop, dir);
+        });
+    }
+    return arr;
+};
+export { order };

package/dist/fn/object/pickValue.d.ts

@@ -0,0 +1,2 @@
+declare const pickValue: (arr: any[]) => any;
+export { pickValue };

package/dist/fn/object/pickValue.js

@@ -0,0 +1,6 @@
+const pickValue = function (arr) {
+    if (Array.isArray(arr) && arr.length) {
+        return arr[Math.floor(Math.random() * arr.length)];
+    }
+};
+export { pickValue };

package/dist/fn/object/removeEmpty.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns a new array, having removed all elements deemed empty from the given array.
+ *
+ * Removes all the elements which are empty, i.e. false, 0, null, '', NaN, or undefined.
+ *
+ * @method   removeEmpty
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.removeEmpty([{prop1: 10, prop2: 20}, '', {}, null, 1, undefined, 0, false, 25]);
+ * // [{prop1: 10, prop2: 20}, 1, 25]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array} arr
+ * @returns  {Array}
+ */
+declare const removeEmpty: (arr: any[]) => any[];
+export { removeEmpty };

package/dist/fn/object/removeEmpty.js

@@ -0,0 +1,47 @@
+import { isArray } from "../type/isArray";
+import { isObject } from "../type/isObject";
+import { numProperties } from "./numProperties";
+/**
+ * Returns a new array, having removed all elements deemed empty from the given array.
+ *
+ * Removes all the elements which are empty, i.e. false, 0, null, '', NaN, or undefined.
+ *
+ * @method   removeEmpty
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.removeEmpty([{prop1: 10, prop2: 20}, '', {}, null, 1, undefined, 0, false, 25]);
+ * // [{prop1: 10, prop2: 20}, 1, 25]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array} arr
+ * @returns  {Array}
+ */
+const removeEmpty = function (arr) {
+    var tmp = [];
+    if (isArray(arr)) {
+        for (let i = 0; i < arr.length; i++) {
+            let ok = false;
+            if (arr[i]) {
+                if (isArray(arr[i])) {
+                    if (arr[i].length) {
+                        ok = true;
+                    }
+                }
+                else if (isObject(arr[i])) {
+                    if (numProperties(arr[i])) {
+                        ok = true;
+                    }
+                }
+                else {
+                    ok = true;
+                }
+            }
+            if (ok) {
+                tmp.push(arr[i]);
+            }
+        }
+    }
+    return tmp;
+};
+export { removeEmpty };

package/dist/fn/object/removePrivateProp.d.ts

@@ -0,0 +1,24 @@
+/**
+  * Returns an object with the original objects' properties starting with an alphanumeric character.
+  *
+  * It is presumed that external libraries, bbn variables use prefixes such as _ or $ for
+  * naming private properties; this returns a new object purged from these properties.
+  *
+  * @method   removePrivateProp
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.removePrivateProp({
+  *   _bbn_timestamp: 1587269593987,
+  *   name: "Wonka",
+  *   fname: "Willy"
+  * });
+  * // {name: "Wonka", fname: "Willy"}
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object}  obj  The original object
+  * @param    {Boolean} deep If true the function will be reapplied on object properties
+  * @returns  {Object}  A new object without only the _public_ properties.
+  */
+declare const removePrivateProp: (obj: object, deep?: boolean) => any;
+export { removePrivateProp };