@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/object/autoExtend.js

@@ -0,0 +1,44 @@
+import { extend } from "./extend";
+/**
+ * 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
+ */
+const autoExtend = function (namespace, obj) {
+    if (!bbn[namespace]) {
+        bbn[namespace] = {};
+        //$.extend(true, bbn[namespace], obj);
+        extend(bbn[namespace], obj);
+    }
+    else {
+        // $.extend(true, bbn[namespace], obj);
+        extend(bbn[namespace], obj);
+    }
+};
+export { autoExtend };

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

@@ -0,0 +1,2 @@
+declare const checkProps: (obj: object, props: string | string[], checkEmpty?: boolean) => boolean;
+export { checkProps };

package/dist/fn/object/checkProps.js

@@ -0,0 +1,5 @@
+import { checkPropsDetails } from './checkPropsDetails';
+const checkProps = function (obj, props, checkEmpty = false) {
+    return checkPropsDetails(obj, props, checkEmpty).result;
+};
+export { checkProps };

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

@@ -0,0 +1,2 @@
+declare const checkPropsDetails: (obj: object, props: string | string[], checkEmpty?: boolean) => BbnResError;
+export { checkPropsDetails };

package/dist/fn/object/checkPropsDetails.js

@@ -0,0 +1,53 @@
+import { isArray } from "../type/isArray";
+import { isObject } from "../type/isObject";
+import { each } from "../loop/each";
+import { substr } from "../string/substr";
+const checkPropsDetails = function (obj, props, checkEmpty = false) {
+    let res = {
+        error: false,
+        result: true,
+    };
+    if (typeof props === "string") {
+        props = [props];
+    }
+    if (!isArray(props)) {
+        res.error = bbn._("checkProps must receive a string or an array as props argument");
+    }
+    if (!isObject(obj)) {
+        res.error = bbn._("checkProps must receive an object as obj argument");
+    }
+    if (!res.error) {
+        let check;
+        each(props, (varName) => {
+            varName = varName.trim().split(":");
+            let type = varName[1] || false;
+            varName = varName[0];
+            if (obj[varName] === undefined) {
+                res.error = varName + " " + bbn._("is not defined");
+            }
+            else if (type) {
+                check =
+                    "is" +
+                        substr(type, 0, 1).toUpperCase() +
+                        substr(type, 1).toLowerCase();
+                if (bbn.fn[check] === undefined) {
+                    res.error = type + " " + bbn._("is not a valid type");
+                }
+                else if (!bbn.fn[check](obj[varName])) {
+                    res.error = varName + " " + bbn._("is not a") + " " + type;
+                }
+            }
+            else if (checkEmpty && !obj[varName]) {
+                res.error = varName + " " + bbn._("is empty");
+            }
+            if (res.error) {
+                return false;
+            }
+        });
+    }
+    if (res.error) {
+        res.result = false;
+    }
+    return res;
+};
+export { checkPropsDetails };

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

@@ -0,0 +1,2 @@
+declare const checkPropsOrDie: (obj: object, props: string | string[], checkEmpty?: boolean) => boolean;
+export { checkPropsOrDie };

package/dist/fn/object/checkPropsOrDie.js

@@ -0,0 +1,9 @@
+import { checkPropsDetails } from "./checkPropsDetails";
+const checkPropsOrDie = function (obj, props, checkEmpty = false) {
+    let res = checkPropsDetails(obj, props, checkEmpty);
+    if (res.error) {
+        throw new Error(res.error);
+    }
+    return true;
+};
+export { checkPropsOrDie };

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

@@ -0,0 +1,7 @@
+/**
+ * Returns a function to give to JSON.stringify in order to avoid circular values.
+ *
+ * @returns Function
+ */
+declare const circularReplacer: () => (key: any, value: any) => any;
+export { circularReplacer };

package/dist/fn/object/circularReplacer.js

@@ -0,0 +1,39 @@
+import { isDom } from "../type/isDom";
+import { isCp } from "../type/isCp";
+import { log } from "../browser/log";
+/**
+ * Returns a function to give to JSON.stringify in order to avoid circular values.
+ *
+ * @returns Function
+ */
+const circularReplacer = function () {
+    const visited = new WeakSet();
+    return (key, value) => {
+        if (typeof value === "object" && value !== null) {
+            if (visited.has(value)) {
+                return;
+            }
+            visited.add(value);
+            if (![undefined, Object, Array, null].includes(value.constructor)) {
+                if (isDom(value)) {
+                    if (value.bbnId) {
+                        value =
+                            "__BBN_DOM__" + value.tagName + "/" + value.bbnId + value.bbnHash;
+                    }
+                    else {
+                        value = "__BBN_DOM__" + value.tagName + "/" + value.className;
+                    }
+                }
+                else if (isCp(value)) {
+                    log("IS CP");
+                    value = "__BBN_CP__" + value.$options.name + "/" + value.$cid;
+                }
+                else {
+                    value = value.constructor.toString();
+                }
+            }
+        }
+        return value;
+    };
+};
+export { circularReplacer };

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

@@ -0,0 +1,19 @@
+/**
+ * Creates and returns a perfect clone - but different - from the given object.
+ *
+ * @method   clone
+ * @global
+ * @example
+ * ```javascript
+ * let obj = {name: "Thomas"};
+ * let objCopy = bbn.fn.clone(obj);
+ * obj.name = "Julie";
+ * // obj:     {name: "Julie"}
+ * // objCopy: {name: "Thomas"}
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} obj The source object
+ * @returns  {Object} A new object
+ */
+declare const clone: (obj: any) => any;
+export { clone };

package/dist/fn/object/clone.js

@@ -0,0 +1,33 @@
+import { isArray } from "../type/isArray";
+import { isObject } from "../type/isObject";
+import { extend } from "./extend";
+/**
+ * Creates and returns a perfect clone - but different - from the given object.
+ *
+ * @method   clone
+ * @global
+ * @example
+ * ```javascript
+ * let obj = {name: "Thomas"};
+ * let objCopy = bbn.fn.clone(obj);
+ * obj.name = "Julie";
+ * // obj:     {name: "Julie"}
+ * // objCopy: {name: "Thomas"}
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} obj The source object
+ * @returns  {Object} A new object
+ */
+const clone = function (obj) {
+    if (isArray(obj)) {
+        return obj.slice().map((a) => {
+            return typeof a === "object" ? clone(a) : a;
+        });
+    }
+    if (isObject(obj)) {
+        const o = Object.create(Object.getPrototypeOf(obj));
+        return extend(true, o, obj);
+    }
+    return obj;
+};
+export { clone };

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

@@ -0,0 +1,53 @@
+/**
+ * Performs a comparison between two values based on the given operator and returns a boolean.
+ *
+ * It is internally used by all the filtering functions; the available operators are:
+ * - _===_, _=_, _equal_, _eq_, _is_, which stand for __===__
+ * - _!==_, _notequal_, _neq_, _isnot_, which stand for __!==__
+ * - _!=_, _different_, which stand for __!=__
+ * - _contains_, _contain_, _icontains_, _icontain_
+ * - _starts_, _start_
+ * - _startswith_, _startsi_, _starti_, _istarts_, _istart_
+ * - _endswith_, _endsi_, _endi_, _iends_, _iend_
+ * - _like_
+ * - _gt_, _>_, which stand for __>__
+ * - _lt_, _<_, which stand for __<__
+ * - _gte_, _>=_, which stand for __>=__
+ * - _lte_, _<=_, which stand for __<=__
+ * - _isnull_, which stands for __=== null__
+ * - _isnotnull_, which stands for __!== null__
+ * - _isempty_, which stands for __=== ''__
+ * - _isnotempty_, which stands for __!== ''__
+ *
+ * The defaut operator (if none is given) is __==__ .
+ *
+ * @method   compare
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.compare('foo', 'bar', 'eq');
+ * // false
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.compare('foo', 'bar', 'neq');
+ * // true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.compare(3, 1, '>');
+ * // true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.compare("JavaScript", "script", 'contain');
+ * // true
+ * ```
+ * @memberof bbn.fn
+ * @param    {String|Number} v1
+ * @param    {String|Number} v2
+ * @param    {String}        operator
+ * @returns  {Boolean}       True if the values' comparison complies with the operator, false otherwise
+ */
+declare const compare: (v1: any, v2: any, operator: any) => boolean;
+export { compare };

package/dist/fn/object/compare.js

@@ -0,0 +1,150 @@
+import { isEmpty } from '../type/isEmpty';
+import { removeAccents } from '../string/removeAccents';
+import { isNull } from '../type/isNull';
+import { isObject } from '../type/isObject';
+import { isSame } from '../type/isSame';
+/**
+ * Performs a comparison between two values based on the given operator and returns a boolean.
+ *
+ * It is internally used by all the filtering functions; the available operators are:
+ * - _===_, _=_, _equal_, _eq_, _is_, which stand for __===__
+ * - _!==_, _notequal_, _neq_, _isnot_, which stand for __!==__
+ * - _!=_, _different_, which stand for __!=__
+ * - _contains_, _contain_, _icontains_, _icontain_
+ * - _starts_, _start_
+ * - _startswith_, _startsi_, _starti_, _istarts_, _istart_
+ * - _endswith_, _endsi_, _endi_, _iends_, _iend_
+ * - _like_
+ * - _gt_, _>_, which stand for __>__
+ * - _lt_, _<_, which stand for __<__
+ * - _gte_, _>=_, which stand for __>=__
+ * - _lte_, _<=_, which stand for __<=__
+ * - _isnull_, which stands for __=== null__
+ * - _isnotnull_, which stands for __!== null__
+ * - _isempty_, which stands for __=== ''__
+ * - _isnotempty_, which stands for __!== ''__
+ *
+ * The defaut operator (if none is given) is __==__ .
+ *
+ * @method   compare
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.compare('foo', 'bar', 'eq');
+ * // false
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.compare('foo', 'bar', 'neq');
+ * // true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.compare(3, 1, '>');
+ * // true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.compare("JavaScript", "script", 'contain');
+ * // true
+ * ```
+ * @memberof bbn.fn
+ * @param    {String|Number} v1
+ * @param    {String|Number} v2
+ * @param    {String}        operator
+ * @returns  {Boolean}       True if the values' comparison complies with the operator, false otherwise
+ */
+const compare = function (v1, v2, operator) {
+    switch (operator) {
+        case '===':
+        case '=':
+        case 'equal':
+        case 'eq':
+        case 'is':
+            return v1 === v2;
+        case '!==':
+        case 'notequal':
+        case 'neq':
+        case 'isnot':
+            return v1 !== v2;
+        case '!=':
+        case 'different':
+            return v1 != v2;
+        case 'contains':
+        case 'contain':
+        case 'icontains':
+        case 'icontain':
+            if (isEmpty(v1) || isEmpty(v2)) {
+                return false;
+            }
+            return removeAccents(v1).toLowerCase().indexOf(removeAccents(v2).toLowerCase()) !== -1;
+        case 'doesnotcontain':
+        case 'donotcontain':
+            if (isNull(v1) || isNull(v2)) {
+                return true;
+            }
+            return removeAccents(v1.toLowerCase()).indexOf(removeAccents(v2.toLowerCase())) === -1;
+        case 'starts':
+        case 'start':
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            if (typeof v1 !== 'string') {
+                v1 = v1.toString() || '';
+            }
+            if (typeof v2 !== 'string') {
+                v2 = v2.toString() || '';
+            }
+            return v1.indexOf(v2) === 0;
+        case 'startswith':
+        case 'startsi':
+        case 'starti':
+        case 'istarts':
+        case 'istart':
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            return removeAccents(v1).toLowerCase().indexOf(removeAccents(v2).toLowerCase()) === 0;
+        case 'endswith':
+        case 'endsi':
+        case 'endi':
+        case 'iends':
+        case 'iend':
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            return v1.lastIndexOf(v2) === v1.length - v2.length;
+        case 'like':
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            return removeAccents(v1).toLowerCase() === removeAccents(v2).toLowerCase();
+        case 'gt':
+        case '>':
+            return v1 > v2;
+        case 'gte':
+        case '>=':
+            return v1 >= v2;
+        case 'lt':
+        case '<':
+            return v1 < v2;
+        case 'lte':
+        case '<=':
+            return v1 <= v2;
+        case 'isnull':
+            return v1 === null;
+        case 'isnotnull':
+            return v1 !== null;
+        case 'isempty':
+            return v1 === '';
+        case 'isnotempty':
+            return v1 !== '';
+        case '==':
+            if (isObject(v1, v2)) {
+                return isSame(v1, v2);
+            }
+        default:
+            return v1 == v2;
+    }
+};
+export { compare };

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

@@ -0,0 +1,46 @@
+/**
+ * Checks whether the given data object complies or not with the given filter.
+ *
+ * The filter format must be full (i.e. with the properties logic and conditions) such as
+ * seen in the function bbn.fn.search and can be generated by the function bbn.fn.filterToConditions.
+ *
+ * @method   compareConditions
+ * @global
+ * @example
+ * ```javascript
+ * let item = {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589};
+ * bbn.fn.compareConditions(item, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *        field: "director",
+ *        value: "Steven Spielberg"
+ *     }
+ *   ]
+ * });
+ * // true
+ * bbn.fn.compareConditions(item, bbn.fn.filterToConditions({director: "Steven Soderberg"}));
+ * // false
+ * bbn.fn.compareConditions(item, bbn.fn.filterToConditions({director: "Steven Spielberg"}));
+ * // true
+ * bbn.fn.compareConditions(item, bbn.fn.filterToConditions({year: 1980}, ">"));
+ * // true
+ * bbn.fn.compareConditions(item, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *        field: "year",
+ *        operator: "<",
+ *        value: 1980
+ *     }
+ *   ]
+ * });
+ * // false
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} data
+ * @param    {Object} filter
+ * @returns  {Boolean}
+ */
+declare const compareConditions: (data: any, filter: any) => boolean;
+export { compareConditions };

package/dist/fn/object/compareConditions.js

@@ -0,0 +1,86 @@
+import { isArray } from "../type/isArray";
+import { each } from "../loop/each";
+import { compare } from "./compare";
+import { getProperty } from "./getProperty";
+/**
+ * Checks whether the given data object complies or not with the given filter.
+ *
+ * The filter format must be full (i.e. with the properties logic and conditions) such as
+ * seen in the function bbn.fn.search and can be generated by the function bbn.fn.filterToConditions.
+ *
+ * @method   compareConditions
+ * @global
+ * @example
+ * ```javascript
+ * let item = {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589};
+ * bbn.fn.compareConditions(item, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *        field: "director",
+ *        value: "Steven Spielberg"
+ *     }
+ *   ]
+ * });
+ * // true
+ * bbn.fn.compareConditions(item, bbn.fn.filterToConditions({director: "Steven Soderberg"}));
+ * // false
+ * bbn.fn.compareConditions(item, bbn.fn.filterToConditions({director: "Steven Spielberg"}));
+ * // true
+ * bbn.fn.compareConditions(item, bbn.fn.filterToConditions({year: 1980}, ">"));
+ * // true
+ * bbn.fn.compareConditions(item, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *        field: "year",
+ *        operator: "<",
+ *        value: 1980
+ *     }
+ *   ]
+ * });
+ * // false
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} data
+ * @param    {Object} filter
+ * @returns  {Boolean}
+ */
+const compareConditions = function (data, filter) {
+    if (!filter.conditions || !filter.logic || !isArray(filter.conditions)) {
+        throw new Error("Error in compareConditions: the filter should an abject with conditions and logic properties and conditions should be an array of objects");
+    }
+    let ok = filter.logic === "AND" ? true : false;
+    each(filter.conditions, (a) => {
+        let comparator;
+        if (a.conditions && isArray(a.conditions)) {
+            comparator = compareConditions(data, a);
+        }
+        else {
+            comparator = compare(getProperty(data, a.field), a.value, a.operator);
+            if (comparator) {
+                let bits = a.field.split(".");
+                let prop = bits.pop();
+                if (bits.length) {
+                    each(bits, (b) => (data = data[b]));
+                }
+                // Case where both are undefined: value and prop which doesn't exist; they are not the same!
+                if (getProperty(data, prop) === undefined && a.value !== undefined) {
+                    comparator = false;
+                }
+            }
+        }
+        if (comparator) {
+            if (filter.logic === "OR") {
+                ok = true;
+                return false;
+            }
+        }
+        else if (filter.logic === "AND") {
+            ok = false;
+            return false;
+        }
+    });
+    return ok;
+};
+export { compareConditions };

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

@@ -0,0 +1,56 @@
+/**
+ * Counts the number of objects matching the given filter in the given array.
+ *
+ * The arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   count
+ * @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.count(ar, "id", 256);
+ * // 1
+ * bbn.fn.count(ar, {director: "Steven Spielberg"});
+ * // 2
+ * bbn.fn.search(ar, "year", 1975, ">");
+ * // 3
+ * // Complex filters: all the movies from Spielberg between 1974 and 1980
+ * bbn.fn.search(ar, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *       field: "director",
+ *       operator: "eq",
+ *       value: "Steven Spielberg"
+ *     }, {
+ *       logic: "AND",
+ *       conditions: [
+ *         {
+ *            field: "year",
+ *            operator: ">=",
+ *            value: 1974
+ *         }, {
+ *            field: "year",
+ *            operator: "<=",
+ *            value: 1980
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * });
+ * // 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
+ * @returns  {Number}                   The number of items
+ */
+declare const count: (arr: any[], prop: object | string, val?: any, operator?: string) => number;
+export { count };

package/dist/fn/object/count.js

@@ -0,0 +1,59 @@
+import { filter } from './filter';
+/**
+ * Counts the number of objects matching the given filter in the given array.
+ *
+ * The arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   count
+ * @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.count(ar, "id", 256);
+ * // 1
+ * bbn.fn.count(ar, {director: "Steven Spielberg"});
+ * // 2
+ * bbn.fn.search(ar, "year", 1975, ">");
+ * // 3
+ * // Complex filters: all the movies from Spielberg between 1974 and 1980
+ * bbn.fn.search(ar, {
+ *   logic: "AND",
+ *   conditions: [
+ *     {
+ *       field: "director",
+ *       operator: "eq",
+ *       value: "Steven Spielberg"
+ *     }, {
+ *       logic: "AND",
+ *       conditions: [
+ *         {
+ *            field: "year",
+ *            operator: ">=",
+ *            value: 1974
+ *         }, {
+ *            field: "year",
+ *            operator: "<=",
+ *            value: 1980
+ *         }
+ *       ]
+ *     }
+ *   ]
+ * });
+ * // 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
+ * @returns  {Number}                   The number of items
+ */
+const count = function (arr, prop, val = null, operator = '=') {
+    return filter(arr, prop, val, operator).length || 0;
+};
+export { count };

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

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