@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/misc/analyzeFunction.js

@@ -0,0 +1,141 @@
+import { md5 } from '../string/md5';
+const analyzeFunction = function (fn) {
+    const functionString = fn.toString();
+    let all = functionString.split('');
+    let exp = '';
+    let isArrow = false;
+    let isAsync = false;
+    let hasFunction = false;
+    let name = null;
+    let parOpened = 0;
+    let parClosed = 0;
+    let args = [];
+    let currentArg = {};
+    let body;
+    let currentQuote = '';
+    let escapable = ['"', "'", '`'];
+    let isEscaped = false;
+    let settingDefault = false;
+    for (let i = 0; i < all.length; i++) {
+        if (all[i] === currentQuote && !isEscaped && currentQuote) {
+            currentQuote = '';
+            exp += all[i];
+        }
+        else if (currentQuote) {
+            exp += all[i];
+        }
+        else if (escapable.includes(all[i]) && !isEscaped) {
+            currentQuote = all[i];
+            exp += all[i];
+        }
+        else if (all[i] === '(') {
+            parOpened++;
+            if (exp.trim() !== '') {
+                if (exp.trim() === 'function') {
+                    hasFunction = true;
+                }
+                if (exp.trim() !== 'async') {
+                    name = exp.trim();
+                }
+                exp = '';
+            }
+        }
+        else if (all[i] === ')') {
+            if (parOpened === parClosed + 1) {
+                if (settingDefault) {
+                    currentArg.default = exp.trim();
+                    settingDefault = false;
+                }
+                else if (exp) {
+                    currentArg.name = exp.trim();
+                }
+                if (currentArg.name || currentArg.default) {
+                    args.push(currentArg);
+                    currentArg = {};
+                }
+                exp = '';
+            }
+            parClosed++;
+        }
+        else if (all[i] === '=') {
+            if (functionString.substr(i, 2) === '=>') {
+                if (exp.trim() !== '' && parOpened === parClosed) {
+                    currentArg.name = exp.trim();
+                    args.push(currentArg);
+                    currentArg = {};
+                    exp = '';
+                }
+                isArrow = true;
+                i++;
+                continue;
+            }
+            else if (parOpened > parClosed && !settingDefault) {
+                currentArg.name = exp.trim();
+                exp = '';
+                settingDefault = true;
+            }
+            else {
+                exp += all[i];
+            }
+        }
+        else if (all[i] === ',') {
+            if (parOpened > parClosed) {
+                if (settingDefault) {
+                    currentArg.default = exp.trim();
+                    settingDefault = false;
+                }
+                else if (exp) {
+                    currentArg.name = exp.trim();
+                }
+                if (currentArg.name || currentArg.default) {
+                    args.push(currentArg);
+                    currentArg = {};
+                }
+                exp = '';
+            }
+            else {
+                throw Error("Unexpected ',' while parsing function");
+            }
+        }
+        else if (all[i] === '{' || all[i] === '}') {
+            body = functionString.substring(i).trim();
+            break;
+        }
+        else if (isArrow) {
+            body = functionString.substring(functionString.indexOf('=>') + 2).trim();
+            break;
+        }
+        else if (all[i] === ' ') {
+            if (exp.trim() !== '') {
+                if (exp.trim() === 'async') {
+                    isAsync = true;
+                    exp = '';
+                }
+            }
+        }
+        else {
+            exp += all[i];
+        }
+    }
+    if (!body) {
+        if (isArrow) {
+            body = exp;
+        }
+        else {
+            throw Error('Unexpected end of function while parsing function');
+        }
+    }
+    const argString = args.map((arg) => arg.name + (arg.default ? ' = ' + arg.default : '')).join(', ');
+    const hash = md5(body + (name ? '-' + name : '') + (argString ? '-' + argString : ''));
+    return {
+        body,
+        args,
+        argString,
+        isArrow,
+        hasFunction,
+        name,
+        isAsync,
+        hash,
+    };
+};
+export { analyzeFunction };

package/dist/fn/misc/getTimeoff.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns the length of time the window has not been focused in seconds.
+ * @method   getTimeoff
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.getTimeoff();
+ * // 0
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const getTimeoff: () => number;
+export { getTimeoff };

package/dist/fn/misc/getTimeoff.js

@@ -0,0 +1,19 @@
+/**
+ * Returns the length of time the window has not been focused in seconds.
+ * @method   getTimeoff
+ * @global
+ * @example
+ * ``` javascript
+ * bbn.fn.getTimeoff();
+ * // 0
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const getTimeoff = function () {
+    if (!bbn.env.isFocused) {
+        return Math.round(new Date().getTime() / 1000 - bbn.env.timeoff);
+    }
+    return 0;
+};
+export { getTimeoff };

package/dist/fn/misc/money.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns the given value to money format basing on the given configuration.
+ *
+ * @method   money
+ * @global
+ *
+ * @example
+ * ``` javascript
+ * // "5 856.0 $"
+ * bbn.fn.money(5856, false, '$', false, '.' ,false, 1);
+ * ```
+ *
+ * @memberof bbn.fn
+ * @param {String|Number} val The value.
+ * @param {Boolean} kilo If the value has to be rendered in kilo.
+ * @param {String} currency The currency.
+ * @param {String} novalue The string to return if no valid value is given.
+ * @param {String} decimal The character to use separate decimals.
+ * @param {String} thousands The character to use to separate thounsands.
+ * @param {Number} precision The number of decimals places.
+ */
+declare const money: (val: number, kilo?: boolean, currency?: string, novalue?: string | false, decimal?: string, thousands?: string, precision?: number) => string;
+export { money };

package/dist/fn/misc/money.js

@@ -0,0 +1,122 @@
+import { isNumber } from '../type/isNumber';
+/**
+ * Returns the given value to money format basing on the given configuration.
+ *
+ * @method   money
+ * @global
+ *
+ * @example
+ * ``` javascript
+ * // "5 856.0 $"
+ * bbn.fn.money(5856, false, '$', false, '.' ,false, 1);
+ * ```
+ *
+ * @memberof bbn.fn
+ * @param {String|Number} val The value.
+ * @param {Boolean} kilo If the value has to be rendered in kilo.
+ * @param {String} currency The currency.
+ * @param {String} novalue The string to return if no valid value is given.
+ * @param {String} decimal The character to use separate decimals.
+ * @param {String} thousands The character to use to separate thounsands.
+ * @param {Number} precision The number of decimals places.
+ */
+const money = function (val, kilo, currency, novalue, decimal, thousands, precision) {
+    /*
+    money(val, kilo){
+      let decimal = ',',
+          currency = '€',
+          thousands = ' ';
+      if ( (isNaN(val) || !val) ){
+        return '-';
+      }
+      if ( isNaN(val) || !val ){
+        return 0;
+      }
+      if ( kilo && val ){
+        val = val / 1000;
+        if ( currency ){
+          currency = 'K' + currency;
+        }
+      }
+      return parseFloat(val).toFixed(0).replace(/./g, function(c, i, a) {
+        if ( c === '.' ){
+          return decimal;
+        }
+        return i && ((a.length - i) % 3 === 0) ? thousands + c : c;
+      }) + ( currency ? ' ' + currency : '');
+    },
+
+       */
+    if (!decimal) {
+        decimal =
+            decimal === undefined && bbn.env.money && bbn.env.money.decimal !== undefined ? bbn.env.money.decimal : '.';
+    }
+    if (!currency) {
+        currency =
+            currency === undefined && bbn.env.money && bbn.env.money.currency !== undefined
+                ? bbn.env.money.currency
+                : '';
+    }
+    if (!thousands) {
+        thousands =
+            thousands === undefined && bbn.env.money && bbn.env.money.thousands !== undefined
+                ? bbn.env.money.thousands
+                : ' ';
+    }
+    if (!precision) {
+        precision =
+            precision === undefined && bbn.env.money && bbn.env.money.precision !== undefined
+                ? bbn.env.money.precision
+                : 0;
+    }
+    if (!kilo) {
+        kilo = kilo === undefined && bbn.env.money && bbn.env.money.kilo !== undefined ? bbn.env.money.kilo : false;
+    }
+    if (!novalue) {
+        novalue =
+            novalue === undefined && bbn.env.money && bbn.env.money.novalue !== undefined
+                ? bbn.env.money.novalue
+                : false;
+    }
+    if (!isNumber(precision)) {
+        precision = kilo ? 3 : 0;
+    }
+    if ((val === 0) && (typeof precision === 'number') && (precision > 0)) {
+        let res = val.toFixed(precision).replace('.', decimal);
+        if (currency) {
+            res += ' ' + (kilo ? 'K' + currency : currency);
+        }
+        return res;
+    }
+    if ((isNaN(val) || !val) && novalue) {
+        return novalue;
+    }
+    if (isNaN(val) || !val) {
+        return 0 + (currency ? ' ' + currency : '');
+    }
+    if (kilo && val) {
+        val = val / 1000;
+        if (currency) {
+            currency = 'K' + currency;
+        }
+    }
+    let v = val.toFixed(precision);
+    let decimalPosition = 0;
+    let decimalIdx = 10000;
+    if (v) {
+        decimalIdx = v.indexOf('.');
+        if (decimalIdx <= 0) {
+            decimalIdx = 10000;
+        }
+        else {
+            decimalPosition = v.length - decimalIdx;
+        }
+    }
+    return (v.replace(/./g, function (c, i, a) {
+        if (c === '.') {
+            return decimal;
+        }
+        return i && (a.length - i - decimalPosition) % 3 === 0 && i < decimalIdx ? thousands + c : c;
+    }) + (currency ? ' ' + currency : ''));
+};
+export { money };

package/dist/fn/misc/percent.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns the value of the proportion giving the percentage and the total from where to be calculated.
+ * @method   percent
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //150
+ * bbn.fn.percent('15',1000);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * //75
+ * bbn.fn.percent(15,500);
+ * ```
+ * @memberof bbn.fn
+ * @param    {Number|String} percent
+ * @param    {Number|String} cent
+ * @returns  {Number}
+ */
+declare const percent: (percent: any, cent: any) => number;
+export { percent };

package/dist/fn/misc/percent.js

@@ -0,0 +1,25 @@
+/**
+ * Returns the value of the proportion giving the percentage and the total from where to be calculated.
+ * @method   percent
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //150
+ * bbn.fn.percent('15',1000);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * //75
+ * bbn.fn.percent(15,500);
+ * ```
+ * @memberof bbn.fn
+ * @param    {Number|String} percent
+ * @param    {Number|String} cent
+ * @returns  {Number}
+ */
+const percent = function (percent, cent) {
+    return (cent / 100) * percent;
+};
+export { percent };

package/dist/fn/misc/randomInt.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns a random integer.
+ *
+ * Generates and returns a random number in a range of numbers defined
+ * by passed arguments a minimum and a maximum.
+ *
+ * @method   randomInt
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //56
+ * bbn.fn.randomInt(1,100);
+ * ```
+ *
+ * @memberof bbn.fn
+ * @param    {Number} min
+ * @param    {Number} max
+ * @returns  {Number}
+ */
+declare const randomInt: (min: number, max: number) => number;
+export { randomInt };

package/dist/fn/misc/randomInt.js

@@ -0,0 +1,24 @@
+/**
+ * Returns a random integer.
+ *
+ * Generates and returns a random number in a range of numbers defined
+ * by passed arguments a minimum and a maximum.
+ *
+ * @method   randomInt
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //56
+ * bbn.fn.randomInt(1,100);
+ * ```
+ *
+ * @memberof bbn.fn
+ * @param    {Number} min
+ * @param    {Number} max
+ * @returns  {Number}
+ */
+const randomInt = function (min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+};
+export { randomInt };

package/dist/fn/misc/roundDecimal.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @method   roundDecimal
+ * @todo     Add method description for roundDecimal
+ * @global
+ * @memberof bbn.fn
+ * @param    {Number} value
+ * @param    {Number} decimals
+ * @returns  {}
+ */
+declare const roundDecimal: (value: number, decimals: number) => number;
+export { roundDecimal };

package/dist/fn/misc/roundDecimal.js

@@ -0,0 +1,13 @@
+/**
+ * @method   roundDecimal
+ * @todo     Add method description for roundDecimal
+ * @global
+ * @memberof bbn.fn
+ * @param    {Number} value
+ * @param    {Number} decimals
+ * @returns  {}
+ */
+const roundDecimal = function (value, decimals) {
+    return Math.round(Math.pow(Math.pow(value, decimals), -decimals));
+};
+export { roundDecimal };

package/dist/fn/misc/translate.d.ts

@@ -0,0 +1,2 @@
+declare const translate: (o: object, namespace?: string) => void;
+export { translate };

package/dist/fn/misc/translate.js

@@ -0,0 +1,8 @@
+import { iterate } from '../loop/iterate';
+const translate = function (o, namespace) {
+    let lng = namespace ? bbn.lng[namespace.indexOf('_') === 0 ? namespace : '_' + namespace] : bbn.lng;
+    iterate(o, (v, k) => {
+        lng[k] = v;
+    });
+};
+export { translate };

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

@@ -0,0 +1,40 @@
+/**
+  * Compares the given property in the given objects and returns -1, 1, or 0 depending on their difference.
+  *
+  * This is only used as a sorting function by bbn.fn.order and bbn.fn.multiorder.
+  *
+  * @method   _compareValues
+  * @global
+  * @example
+  * ```javascript
+  * // Same value
+  * bbn.fn._compareValues({year: 2015, value: 2}, {year: 2016, value: 2}, 'value');
+  * // 0
+  * ```
+  * @example
+  * ```javascript
+  * // First value smaller than second
+  * bbn.fn._compareValues({year: 2015, value: 2}, {year: 2016, value: 2}, 'year');
+  * // -1
+  * ```
+  * @example
+  * ```javascript
+  * // First value greater than second
+  * bbn.fn._compareValues({year: 2017, value: 2}, {year: 2016, value: 2}, 'year');
+  * // 1
+  * ```
+  * @example
+  * ```javascript
+  * // First value is undefined
+  * bbn.fn._compareValues({year: 2017}, {year: 2016, value: 2}, 'value');
+  * // 1
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object} a    First object for comparison
+  * @param    {Object} b    Second object for comparison
+  * @param    {String} prop Property to compare
+  * @param    {String} [dir=asc]  Direction of comparison (desc or asc by default)
+  * @returns  {Number} Always either -1, 1, or 0
+  */
+declare const _compareValues: (a: any, b: any, prop: any, dir?: string) => 0 | 1 | -1;
+export { _compareValues };

package/dist/fn/object/_compareValues.js

@@ -0,0 +1,78 @@
+import { getProperty } from "./getProperty";
+import { isString } from "../type/isString";
+import { removeAccents } from "../string/removeAccents";
+import { isDate } from "../type/isDate";
+/**
+  * Compares the given property in the given objects and returns -1, 1, or 0 depending on their difference.
+  *
+  * This is only used as a sorting function by bbn.fn.order and bbn.fn.multiorder.
+  *
+  * @method   _compareValues
+  * @global
+  * @example
+  * ```javascript
+  * // Same value
+  * bbn.fn._compareValues({year: 2015, value: 2}, {year: 2016, value: 2}, 'value');
+  * // 0
+  * ```
+  * @example
+  * ```javascript
+  * // First value smaller than second
+  * bbn.fn._compareValues({year: 2015, value: 2}, {year: 2016, value: 2}, 'year');
+  * // -1
+  * ```
+  * @example
+  * ```javascript
+  * // First value greater than second
+  * bbn.fn._compareValues({year: 2017, value: 2}, {year: 2016, value: 2}, 'year');
+  * // 1
+  * ```
+  * @example
+  * ```javascript
+  * // First value is undefined
+  * bbn.fn._compareValues({year: 2017}, {year: 2016, value: 2}, 'value');
+  * // 1
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object} a    First object for comparison
+  * @param    {Object} b    Second object for comparison
+  * @param    {String} prop Property to compare
+  * @param    {String} [dir=asc]  Direction of comparison (desc or asc by default)
+  * @returns  {Number} Always either -1, 1, or 0
+  */
+const _compareValues = function (a, b, prop, dir = "asc") {
+    let va = getProperty(a, prop), vb = getProperty(b, prop), ta = (typeof va).toLowerCase(), tb = (typeof vb).toLowerCase();
+    if (dir !== "asc" && isString(dir) && dir.toLowerCase() === "desc") {
+        dir = "desc";
+    }
+    if (ta !== tb) {
+        va = ta;
+        vb = tb;
+    }
+    else {
+        switch (ta) {
+            case "string":
+                va = removeAccents(va).toLowerCase();
+                vb = removeAccents(vb).toLowerCase();
+                break;
+            case "boolean":
+                va = va ? 1 : 0;
+                vb = vb ? 1 : 0;
+                break;
+            case "object":
+                if (isDate(va)) {
+                    va = va.getTime();
+                    vb = isDate(vb) ? vb.getTime() : 0;
+                }
+                break;
+        }
+    }
+    if (va < vb) {
+        return dir === "desc" ? 1 : -1;
+    }
+    if (va > vb) {
+        return dir === "desc" ? -1 : 1;
+    }
+    return 0;
+};
+export { _compareValues };

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

@@ -0,0 +1,33 @@
+/**
+ * Creates and returns a new array made of the given property's values from the given array of objects.
+ *
+ * The returned array will always have the same length of the given array, even if the property is not found.
+ *
+ * @method   arrayFromProp
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.arrayFromProp([
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Barry Lindon", year: 1976}
+ * ], "year");
+ * // [1985, 2001, 1976]
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.arrayFromProp([
+ *   {pupil: "Agnes Varda", grade: {year: "B", month: "A"}},
+ *   {pupil: "Jacques Rivette"},
+ *   {pupil: "Luc Besson", grade: {year: "C", month: "D"}},
+ *   {pupil: "Nicole Garcia", grade: {year: "B", month: "B"}}
+ * ], "grade.month");
+ * // ["A", undefined, "D", "B"]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}  arr
+ * @param    {String} prop
+ * @returns  {Array}  The new array
+ */
+declare const arrayFromProp: (arr: any, prop: any) => any[];
+export { arrayFromProp };

package/dist/fn/object/arrayFromProp.js

@@ -0,0 +1,41 @@
+import { each } from "../loop/each";
+import { getProperty } from "./getProperty";
+/**
+ * Creates and returns a new array made of the given property's values from the given array of objects.
+ *
+ * The returned array will always have the same length of the given array, even if the property is not found.
+ *
+ * @method   arrayFromProp
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.arrayFromProp([
+ *   {movie: "Brazil", year: 1985},
+ *   {movie: "Donnie Darko", year: 2001},
+ *   {movie: "Barry Lindon", year: 1976}
+ * ], "year");
+ * // [1985, 2001, 1976]
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.arrayFromProp([
+ *   {pupil: "Agnes Varda", grade: {year: "B", month: "A"}},
+ *   {pupil: "Jacques Rivette"},
+ *   {pupil: "Luc Besson", grade: {year: "C", month: "D"}},
+ *   {pupil: "Nicole Garcia", grade: {year: "B", month: "B"}}
+ * ], "grade.month");
+ * // ["A", undefined, "D", "B"]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}  arr
+ * @param    {String} prop
+ * @returns  {Array}  The new array
+ */
+const arrayFromProp = function (arr, prop) {
+    let r = [];
+    each(arr, (a, i) => {
+        r.push(getProperty(a, prop));
+    });
+    return r;
+};
+export { arrayFromProp };

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

@@ -0,0 +1,33 @@
+/**
+ * Extends the bbn object by passing the namespace and the object it will merge with.
+ *
+ * This function is a self-centric shortcut for adding functions or proerties
+ * to the bbn object itself.
+ *
+ * @method   autoExtend
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.autoExtend("fn", {myOwnFunction: () => "Result of my own function"});
+ * bbn.fn.myOwnFunction();
+ * // Result of my own function
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.autoExtend("env", {serverLanguage: "php"});
+ * bbn.env.sercerLanguage
+ * // php
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.autoExtend("myProject", {name: "My Project"});
+ * bbn.myProject.name
+ * // Project
+ * ```
+ * @memberof bbn.fn
+ * @param    {String}    namespace The bbn property, existing or not, in which the object will be merged
+ * @param    {Object}    obj       The object to merge
+ * @returns  {undefined} No return value
+ */
+declare const autoExtend: (namespace: any, obj: any) => void;
+export { autoExtend };