@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/object/removePrivateProp.js

@@ -0,0 +1,41 @@
+import { substr } from '../string/substr';
+/**
+  * 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.
+  */
+const removePrivateProp = function (obj, deep = false) {
+    let r = null;
+    if (typeof obj === 'object') {
+        r = {};
+        for (var n in obj) {
+            if (substr(n, 0, 1).match(/^[A-z0-9]$/) && (n in obj)) {
+                if (deep && typeof obj[n] === 'object') {
+                    r[n] = removePrivateProp(obj[n], true);
+                }
+                else {
+                    r[n] = obj[n];
+                }
+            }
+        }
+    }
+    return r || false;
+};
+export { removePrivateProp };

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

@@ -0,0 +1,101 @@
+import { Filter } from './filterToConditions';
+/**
+ * Retrieves the index of the array's first element corresponding to the given filter.
+ *
+ * Returns -1 if the element is not found. If the second parameter is an object or function
+ * for filtering as defined in bbn.fn.filter, the remaining parameters will be shifted to the
+ * left, i.e. val becomes operator, and operator startFrom. And if operator is a number, its value will
+ * be given to startFrom and operator will be undefined. The filter object can be complex with different
+ * operators (as seen in bbn.fn.compare) and logics (AND/OR), and infinitely nested, of this form:
+ * ```javascript
+ * {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *       field: "prop1",
+ *       operator: "eq",
+ *       value: "value1"
+ *     }, {
+ *       logic: "OR",
+ *       conditions: [
+ *         {
+ *            field: "prop2",
+ *            operator: "eq",
+ *            value: 1
+ *         }. {
+ *            field: "prop2",
+ *            operator: "eq",
+ *            value: 2
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ * This way of managing the arguments is used in all the filtering functions.
+ *
+ * @method   search
+ * @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.search(ar, "id", 256);
+ * // 2
+ *
+ * bbn.fn.search(ar, {director: "Steven Spielberg"});
+ * // 0
+ *
+ * bbn.fn.search(ar, {year: 1975, director: "Steven Spielberg"});
+ * // 3
+ *
+ * bbn.fn.search(ar, {director: "Steven Spielberg"}, 1);
+ * // 3
+ *
+ * // Complex filters
+ * bbn.fn.search(ar, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *       field: "director",
+ *       operator: "eq",
+ *       value: "Steven Spielberg"
+ *     }, {
+ *       logic: "OR",
+ *       conditions: [
+ *         {
+ *            field: "year",
+ *            operator: "eq",
+ *            value: 1974
+ *         }, {
+ *            field: "year",
+ *            operator: "eq",
+ *            value: 1975
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * });
+ * // 3
+ *
+ * Simple array
+ * bbn.fn.search(['a', 'b', 'c'], null, 'b');
+ * // 1
+ *
+ * ```
+ *
+ * @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
+ * @param    {Number}                   startFrom The index from which the search should start
+ * @returns  {Number}                   The index if found, otherwise -1
+ */
+declare const search: (arr: any[], prop: string | object | Filter | ((a: any, i: string | number | symbol) => boolean), val?: any, operator?: number | string, startFrom?: number) => number;
+export { search };

package/dist/fn/object/search.js

@@ -0,0 +1,177 @@
+import { isIterable } from '../type/isIterable';
+import { compareConditions } from './compareConditions';
+import { filterToConditions } from './filterToConditions';
+import { isObject } from '../type/isObject';
+import { numProperties } from './numProperties';
+import { isNumber } from '../type/isNumber';
+/**
+ * Retrieves the index of the array's first element corresponding to the given filter.
+ *
+ * Returns -1 if the element is not found. If the second parameter is an object or function
+ * for filtering as defined in bbn.fn.filter, the remaining parameters will be shifted to the
+ * left, i.e. val becomes operator, and operator startFrom. And if operator is a number, its value will
+ * be given to startFrom and operator will be undefined. The filter object can be complex with different
+ * operators (as seen in bbn.fn.compare) and logics (AND/OR), and infinitely nested, of this form:
+ * ```javascript
+ * {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *       field: "prop1",
+ *       operator: "eq",
+ *       value: "value1"
+ *     }, {
+ *       logic: "OR",
+ *       conditions: [
+ *         {
+ *            field: "prop2",
+ *            operator: "eq",
+ *            value: 1
+ *         }. {
+ *            field: "prop2",
+ *            operator: "eq",
+ *            value: 2
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ * This way of managing the arguments is used in all the filtering functions.
+ *
+ * @method   search
+ * @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.search(ar, "id", 256);
+ * // 2
+ *
+ * bbn.fn.search(ar, {director: "Steven Spielberg"});
+ * // 0
+ *
+ * bbn.fn.search(ar, {year: 1975, director: "Steven Spielberg"});
+ * // 3
+ *
+ * bbn.fn.search(ar, {director: "Steven Spielberg"}, 1);
+ * // 3
+ *
+ * // Complex filters
+ * bbn.fn.search(ar, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *       field: "director",
+ *       operator: "eq",
+ *       value: "Steven Spielberg"
+ *     }, {
+ *       logic: "OR",
+ *       conditions: [
+ *         {
+ *            field: "year",
+ *            operator: "eq",
+ *            value: 1974
+ *         }, {
+ *            field: "year",
+ *            operator: "eq",
+ *            value: 1975
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * });
+ * // 3
+ *
+ * Simple array
+ * bbn.fn.search(['a', 'b', 'c'], null, 'b');
+ * // 1
+ *
+ * ```
+ *
+ * @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
+ * @param    {Number}                   startFrom The index from which the search should start
+ * @returns  {Number}                   The index if found, otherwise -1
+ */
+const search = function (arr, prop, val = null, operator = '=', startFrom = 0) {
+    if (!isIterable(arr)) {
+        throw new Error(bbn._('The first argument for a search should be iterable') + ' ' + typeof arr + ' ' + bbn._('given'));
+    }
+    if (!arr.length) {
+        return -1;
+    }
+    let filter;
+    let isFn = false;
+    if (typeof prop === 'string') {
+        filter = {
+            conditions: [
+                {
+                    field: prop,
+                    value: val,
+                    operator: operator || '=',
+                },
+            ]
+        };
+    }
+    else if (!prop) {
+        isFn = true;
+        filter = a => {
+            return compareConditions({ value: a }, filterToConditions({
+                logic: 'AND',
+                conditions: [
+                    {
+                        field: 'value',
+                        operator: operator || '=',
+                        value: val,
+                    },
+                ],
+            }));
+        };
+    }
+    else {
+        startFrom = typeof (operator) === 'number' ? operator : 0;
+        operator = val;
+        if (isObject(prop)) {
+            filter = prop;
+        }
+        else if (typeof (prop) === 'function') {
+            isFn = true;
+            filter = prop;
+        }
+    }
+    if (isFn || (isObject(filter) && numProperties(filter))) {
+        if (isNumber(operator)) {
+            startFrom = typeof (operator) === 'number' ? operator : 0;
+            operator = undefined;
+        }
+        if (!isNumber(startFrom)) {
+            startFrom = 0;
+        }
+        if (typeof filter === 'function') {
+            for (let i = startFrom; i < arr.length; i++) {
+                if (filter(arr[i])) {
+                    return i;
+                }
+            }
+        }
+        else {
+            filter = filterToConditions(filter);
+            for (let i = startFrom; i < arr.length; i++) {
+                if (compareConditions(arr[i], filter)) {
+                    return i;
+                }
+            }
+        }
+    }
+    return -1;
+};
+export { search };

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

@@ -0,0 +1,11 @@
+/**
+ * Sets a given property on the given object
+ *
+ * @param {Object} obj
+ * @param {String} prop
+ * @param {*} value
+ * @param {Boolean} writable
+ * @param {Boolean} configurable
+ */
+declare const setProp: (obj: object, prop: string, value: any, writable?: boolean, configurable?: boolean) => void;
+export { setProp };

package/dist/fn/object/setProp.js

@@ -0,0 +1,17 @@
+/**
+ * Sets a given property on the given object
+ *
+ * @param {Object} obj
+ * @param {String} prop
+ * @param {*} value
+ * @param {Boolean} writable
+ * @param {Boolean} configurable
+ */
+const setProp = function (obj, prop, value, writable = true, configurable = true) {
+    Object.defineProperty(obj, prop, {
+        value: value,
+        writable: writable,
+        configurable: configurable,
+    });
+};
+export { setProp };

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

@@ -0,0 +1,30 @@
+/**
+ * Returns the value of the given property from the given object.
+ *
+ * Looks for the given property in the given object, accepting dot (.) separator
+ * for deep property access, and returns its value if found and undefined otherwise.
+ *
+ * @method   getProperty
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.getProperty({a: 1, b: 2}, 'b');
+ * // 2
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.getProperty({a: 1, b: {o: {a: 33, h: 5}}}, 'b.o.a');
+ * // 33
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.getProperty({a: 1, b: {o: {a: 33, h: 5}}}, 'b.h.a');
+ * // undefined
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} obj
+ * @param    {String} prop
+ * @returns  {*}      The property's value or undefined
+ */
+declare const setProperty: (obj: object, prop: string, value: any, force?: boolean) => void;
+export { setProperty };

package/dist/fn/object/setProperty.js

@@ -0,0 +1,50 @@
+import { each } from '../loop/each';
+/**
+ * Returns the value of the given property from the given object.
+ *
+ * Looks for the given property in the given object, accepting dot (.) separator
+ * for deep property access, and returns its value if found and undefined otherwise.
+ *
+ * @method   getProperty
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.getProperty({a: 1, b: 2}, 'b');
+ * // 2
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.getProperty({a: 1, b: {o: {a: 33, h: 5}}}, 'b.o.a');
+ * // 33
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.getProperty({a: 1, b: {o: {a: 33, h: 5}}}, 'b.h.a');
+ * // undefined
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} obj
+ * @param    {String} prop
+ * @returns  {*}      The property's value or undefined
+ */
+const setProperty = function (obj, prop, value, force) {
+    if (typeof obj === 'object' && typeof prop === 'string') {
+        let o = obj;
+        const bits = prop.split('.');
+        each(bits, (v, i) => {
+            if (!o) {
+                if (!force) {
+                    throw new Error(bbn._('The object is invalid'));
+                }
+                o = {};
+            }
+            if (bits.length - 1 === i) {
+                o[v] = value;
+            }
+            else {
+                o = o[v];
+            }
+        });
+    }
+};
+export { setProperty };

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

@@ -0,0 +1,25 @@
+/**
+ * Shortens all the strings contained in the object properties or element in a array.
+ *
+ * Modifies directly the given object by cuttin all its too long strings, and adding ellipsis (...) in this case.
+ *
+ * @method   shortenObj
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.shortenObj({
+ *   title: "Once upon a time in the west",
+ *   synopsis: "There's a single piece of land around Flagstone with water on it, and rail baron Morton (Gabriele Ferzetti) aims to have it, knowing the new railroad will have to stop there. He sends his henchman Frank (Henry Fonda) to scare the land's owner, McBain (Frank Wolff), but Frank kills him instead and pins it on a known bandit, Cheyenne (Jason Robards). Meanwhile, a mysterious gunslinger with a score to settle (Charles Bronson) and McBain's new wife, Jill (Claudia Cardinale), arrive in town."
+ * }, 50)
+ * // {
+ * //   "title": "Once upon a time in the west",
+ * //   "synopsis": "There's a single piece of land around Flagstone wi..."
+ * // }
+ * ```
+ * @memberof bbn.fn
+ * @param    {(Object|Array)} obj
+ * @param    {Number}         [max=100]
+ * @returns  {(Object|Array)} The same object, modified
+ */
+declare const shortenObj: (obj: any, max?: number) => object;
+export { shortenObj };

package/dist/fn/object/shortenObj.js

@@ -0,0 +1,40 @@
+import { clone } from "./clone";
+import { each } from "../loop/each";
+import { isString } from "../type/isString";
+import { shorten } from "../string/shorten";
+/**
+ * Shortens all the strings contained in the object properties or element in a array.
+ *
+ * Modifies directly the given object by cuttin all its too long strings, and adding ellipsis (...) in this case.
+ *
+ * @method   shortenObj
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.shortenObj({
+ *   title: "Once upon a time in the west",
+ *   synopsis: "There's a single piece of land around Flagstone with water on it, and rail baron Morton (Gabriele Ferzetti) aims to have it, knowing the new railroad will have to stop there. He sends his henchman Frank (Henry Fonda) to scare the land's owner, McBain (Frank Wolff), but Frank kills him instead and pins it on a known bandit, Cheyenne (Jason Robards). Meanwhile, a mysterious gunslinger with a score to settle (Charles Bronson) and McBain's new wife, Jill (Claudia Cardinale), arrive in town."
+ * }, 50)
+ * // {
+ * //   "title": "Once upon a time in the west",
+ * //   "synopsis": "There's a single piece of land around Flagstone wi..."
+ * // }
+ * ```
+ * @memberof bbn.fn
+ * @param    {(Object|Array)} obj
+ * @param    {Number}         [max=100]
+ * @returns  {(Object|Array)} The same object, modified
+ */
+const shortenObj = function (obj, max = 100) {
+    let o = clone(obj);
+    each(o, (a, n) => {
+        if (isString(a) && a.length > max) {
+            o[n] = shorten(a, max);
+        }
+        else if (a && typeof a === "object") {
+            o[n] = shortenObj(a);
+        }
+    });
+    return o;
+};
+export { shortenObj };

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

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

package/dist/fn/object/shuffle.js

@@ -0,0 +1,13 @@
+const shuffle = function (array) {
+    let currentIndex = array.length, randomIndex;
+    // While there remain elements to shuffle.
+    while (currentIndex != 0) {
+        // Pick a remaining element.
+        randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+        // And swap it with the current element.
+        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+    }
+    return array;
+};
+export { shuffle };

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

@@ -0,0 +1,2 @@
+declare const stat: (returnStat: any) => void;
+export { stat };

package/dist/fn/object/stat.js

@@ -0,0 +1,49 @@
+const stat = function (returnStat) {
+    return;
+    /*
+    if (bbn.env.logging) {
+        var logs = bbn.vars.loggers;
+        for (var i = 0; i < arguments.length; i++) {
+            var a = arguments[i],
+                type = typeof a;
+            if (type === 'boolean' || type === 'undefined') {
+                break;
+            } else {
+                if (type === 'object') {
+                    a = getPath(a);
+                } else {
+                    a = a.toString();
+                }
+                if (!logs[a]) {
+                    logs[a] = {
+                        _num: 0,
+                    };
+                }
+                logs[a]._num++;
+                logs = logs[a];
+            }
+        }
+        if (arguments[arguments.length - 1] === true) {
+            var treat = function (obj) {
+                var v = {};
+                for (var n in obj) {
+                    if (n.indexOf('_') !== 0) {
+                        v[n + '(' + obj[n]._num + ')'] = treat(obj[n]);
+                    }
+                }
+                return v;
+            };
+            return treat(logs);
+        }
+        if (arguments[arguments.length - 1] === false) {
+            for (var n in logs) {
+                delete logs[n];
+            }
+            logs._num = 0;
+            return;
+        }
+        return returnStat;
+    }
+    */
+};
+export { stat };

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

@@ -0,0 +1,46 @@
+/**
+ * Returns the sum of the given property or function for the array's elements matching the filter.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   sum
+ * @global
+ * @example
+ * ```javascript
+ * let invited = [
+ *   {name: "Robert De Niro", attendees: 2, confirmed: true},
+ *   {name: "Al Pacino", attendees: 1, confirmed: false},
+ *   {name: "James Caan", attendees: 4, confirmed: false},
+ *   {name: "Harvey Keitel", attendees: 5, confirmed: true}
+ * ];
+ * // No filter
+ * bbn.fn.sum(invited, "attendees");
+ * // 12
+ * // Filter
+ * bbn.fn.sum(invited, "attendees", {confirmed: true});
+ * // 7
+ * ```
+ * @example
+ * ```javascript
+ * let cart = [
+ *    {article: "Toothpaste", price: 2.50, quantity: 1},
+ *    {article: "Toothbrush", price: 6, quantity: 2},
+ *    {article: "Banana", price: 0.50, quantity: 3},
+ *    {article: "T-shirt", price: 14, quantity: 3}
+ * ];
+ * bbn.fn.sum(cart, a => a.price * a.quantity);
+ * // 58
+ * // Only the items with a quantity equal to 3
+ * bbn.fn.sum(cart, a => a.price * a.quantity, {quantity: 3});
+ * // 43.5
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}                    arr        The subject array
+ * @param    {(String|Function)}        numberProp The property's name for which the value should be added to the sum, or a function returning the number.
+ * @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  {Number}                   The sum
+ */
+declare const sum: (arr: object[], numberProp: string | ((a: any) => any), prop: object | string, val?: any, operator?: string) => number;
+export { sum };

package/dist/fn/object/sum.js

@@ -0,0 +1,57 @@
+import { each } from '../loop/each';
+import { filter } from './filter';
+/**
+ * Returns the sum of the given property or function for the array's elements matching the filter.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   sum
+ * @global
+ * @example
+ * ```javascript
+ * let invited = [
+ *   {name: "Robert De Niro", attendees: 2, confirmed: true},
+ *   {name: "Al Pacino", attendees: 1, confirmed: false},
+ *   {name: "James Caan", attendees: 4, confirmed: false},
+ *   {name: "Harvey Keitel", attendees: 5, confirmed: true}
+ * ];
+ * // No filter
+ * bbn.fn.sum(invited, "attendees");
+ * // 12
+ * // Filter
+ * bbn.fn.sum(invited, "attendees", {confirmed: true});
+ * // 7
+ * ```
+ * @example
+ * ```javascript
+ * let cart = [
+ *    {article: "Toothpaste", price: 2.50, quantity: 1},
+ *    {article: "Toothbrush", price: 6, quantity: 2},
+ *    {article: "Banana", price: 0.50, quantity: 3},
+ *    {article: "T-shirt", price: 14, quantity: 3}
+ * ];
+ * bbn.fn.sum(cart, a => a.price * a.quantity);
+ * // 58
+ * // Only the items with a quantity equal to 3
+ * bbn.fn.sum(cart, a => a.price * a.quantity, {quantity: 3});
+ * // 43.5
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}                    arr        The subject array
+ * @param    {(String|Function)}        numberProp The property's name for which the value should be added to the sum, or a function returning the number.
+ * @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  {Number}                   The sum
+ */
+const sum = function (arr, numberProp, prop, val, operator) {
+    let r = 0;
+    each(filter(arr, prop, val, operator), (a) => {
+        let tmp = typeof numberProp === 'function' ? numberProp(a) : a[numberProp];
+        if (tmp) {
+            r += parseFloat(tmp) || 0;
+        }
+    });
+    return r;
+};
+export { sum };