@bbn/bbn 1.0.59 → 1.0.60

package/dist/fn/object/createObject.js

@@ -0,0 +1,9 @@
+import { extend } from './extend';
+const createObject = function (...args) {
+    const obj = Object.create(null);
+    if (args.length) {
+        extend(obj, ...args);
+    }
+    return obj;
+};
+export { createObject };

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

@@ -0,0 +1,57 @@
+/**
+ * Retrieves all elements of a hierarchical array corresponding to the filter.
+ *
+ * The arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   findAll
+ * @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
+ * @todo Do the doc!
+ * @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 deepPath: (arr: any[], filter: object, deepProperty: string, res?: any[]) => false | any[];
+export { deepPath };

package/dist/fn/object/deepPath.js

@@ -0,0 +1,78 @@
+import { search } from './search';
+import { each } from '../loop/each';
+import { isArray } from '../type/isArray';
+/**
+ * Retrieves all elements of a hierarchical array corresponding to the filter.
+ *
+ * The arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   findAll
+ * @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
+ * @todo Do the doc!
+ * @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 deepPath = function (arr, filter, deepProperty, res = []) {
+    let idx;
+    let start = 0;
+    if ((idx = search(arr, filter, start)) > -1) {
+        res.push(idx);
+        return res;
+    }
+    each(arr, (it, i) => {
+        if (isArray(it[deepProperty])) {
+            let r = res.slice();
+            r.push(i);
+            let tmp = deepPath(it[deepProperty], filter, deepProperty, r);
+            if (tmp !== false) {
+                return tmp;
+            }
+        }
+    });
+    return false;
+};
+export { deepPath };

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

@@ -0,0 +1,8 @@
+/**
+ * Gets the given property from the given object
+ * @param {Object} obj
+ * @param {String} prop
+ * @returns
+ */
+declare const deleteProp: (obj: object, prop: string) => void;
+export { deleteProp };

package/dist/fn/object/deleteProp.js

@@ -0,0 +1,13 @@
+import { checkType } from "../type/checkType";
+/**
+ * Gets the given property from the given object
+ * @param {Object} obj
+ * @param {String} prop
+ * @returns
+ */
+const deleteProp = function (obj, prop) {
+    checkType(obj, "object", bbn._("The obj must be an object in setProp"));
+    checkType(prop, "string", bbn._("The prop must be a string in setProp"));
+    delete obj[prop];
+};
+export { deleteProp };

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

@@ -0,0 +1,79 @@
+/**
+  * Returns an object describing the differences for transforming the first given object into the second.
+  *
+  * The returned data will use the objects properties as keys. If unchanged is set to true, all the
+  * properties will be returned, otherwise only the different ones. Each of these keys will have the
+  * following properties:
+  * - type: can be _modified_, _created_, _deleted_, and if unchanged is set to true _unchanged_
+  * - data: the first object's property's value, or the second if type is _created_
+  * - newData: the second object's property's value in case of type _updated_
+  *
+  * @method   diffObj
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.diffObj(
+  *   {
+  *     name: "Thomas",
+  *     age: 45
+  *   }, {
+  *     name: "Eva",
+  *     sex: "Female",
+  *     retired: false
+  *   }
+  * );
+  * // {
+  * //   name: {
+  * //     type: "updated",
+  * //     data: "Thomas",
+  * //     newData: "Eva"
+  * //   },
+  * //   age: {
+  * //     type: "deleted",
+  * //     data: 45
+  * //   },
+  * //   sex: {
+  * //     type: "created",
+  * //     data: "Female"
+  * //   },
+  * //   retired: {
+  * //     type: "created",
+  * //     data: false
+  * //   }
+  * // }
+  * ```
+  * @example
+  * ```javascript
+  * bbn.fn.diffObj(
+  *   {pupil: "Agnes Varda", grade: {year: "B", month: "A"}},
+  *   {pupil: "Luc Besson", grade: {year: "C", month: "D"}}
+  * );
+  * // {
+  * //   "pupil": {
+  * //     "type": "updated",
+  * //     "data": "Agnes Varda",
+  * //     "newData": "Luc Besson"
+  * //   },
+  * //   "grade": {
+  * //     "year": {
+  * //       "type": "updated",
+  * //       "data": "B",
+  * //       "newData": "C"
+  * //     },
+  * //     "month": {
+  * //       "type": "updated",
+  * //       "data": "A",
+  * //       "newData": "D"
+  * //     }
+  * //   }
+  * // }
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object}  obj1
+  * @param    {Object}  obj2
+  * @param    {String}  unchanged
+  * @param    {Boolean} notRoot
+  * @returns  {Object}
+  */
+declare const diffObj: (obj1: object, obj2: object, unchanged?: boolean, notRoot?: boolean) => any;
+export { diffObj };

package/dist/fn/object/diffObj.js

@@ -0,0 +1,168 @@
+import { isDate } from '../type/isDate';
+import { createObject } from './createObject';
+import { isFunction } from '../type/isFunction';
+import { isValue } from '../type/isValue';
+import { isDom } from '../type/isDom';
+import { numProperties } from './numProperties';
+let diffObjProcessed = [];
+/**
+  * Returns an object describing the differences for transforming the first given object into the second.
+  *
+  * The returned data will use the objects properties as keys. If unchanged is set to true, all the
+  * properties will be returned, otherwise only the different ones. Each of these keys will have the
+  * following properties:
+  * - type: can be _modified_, _created_, _deleted_, and if unchanged is set to true _unchanged_
+  * - data: the first object's property's value, or the second if type is _created_
+  * - newData: the second object's property's value in case of type _updated_
+  *
+  * @method   diffObj
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.diffObj(
+  *   {
+  *     name: "Thomas",
+  *     age: 45
+  *   }, {
+  *     name: "Eva",
+  *     sex: "Female",
+  *     retired: false
+  *   }
+  * );
+  * // {
+  * //   name: {
+  * //     type: "updated",
+  * //     data: "Thomas",
+  * //     newData: "Eva"
+  * //   },
+  * //   age: {
+  * //     type: "deleted",
+  * //     data: 45
+  * //   },
+  * //   sex: {
+  * //     type: "created",
+  * //     data: "Female"
+  * //   },
+  * //   retired: {
+  * //     type: "created",
+  * //     data: false
+  * //   }
+  * // }
+  * ```
+  * @example
+  * ```javascript
+  * bbn.fn.diffObj(
+  *   {pupil: "Agnes Varda", grade: {year: "B", month: "A"}},
+  *   {pupil: "Luc Besson", grade: {year: "C", month: "D"}}
+  * );
+  * // {
+  * //   "pupil": {
+  * //     "type": "updated",
+  * //     "data": "Agnes Varda",
+  * //     "newData": "Luc Besson"
+  * //   },
+  * //   "grade": {
+  * //     "year": {
+  * //       "type": "updated",
+  * //       "data": "B",
+  * //       "newData": "C"
+  * //     },
+  * //     "month": {
+  * //       "type": "updated",
+  * //       "data": "A",
+  * //       "newData": "D"
+  * //     }
+  * //   }
+  * // }
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object}  obj1
+  * @param    {Object}  obj2
+  * @param    {String}  unchanged
+  * @param    {Boolean} notRoot
+  * @returns  {Object}
+  */
+const diffObj = function (obj1, obj2, unchanged = false, notRoot = false) {
+    if (!notRoot) {
+        diffObjProcessed = [];
+    }
+    let VALUE_CREATED = 'created', VALUE_UPDATED = 'updated', VALUE_DELETED = 'deleted', VALUE_UNCHANGED = 'unchanged', _compareValues = function (value1, value2) {
+        if (value1 === value2) {
+            return VALUE_UNCHANGED;
+        }
+        if (isDate(value1) && isDate(value2) && value1.getTime() === value2.getTime()) {
+            return VALUE_UNCHANGED;
+        }
+        if ('undefined' == typeof value1) {
+            return VALUE_CREATED;
+        }
+        if ('undefined' == typeof value2) {
+            return VALUE_DELETED;
+        }
+        return VALUE_UPDATED;
+    };
+    if (notRoot === undefined) {
+        notRoot = false;
+    }
+    let diff = createObject();
+    if (!isFunction(obj1) && !isFunction(obj2)) {
+        if (isValue(obj1) || isValue(obj2)) {
+            let res = _compareValues(obj1, obj2);
+            if (unchanged || res !== VALUE_UNCHANGED) {
+                let ret = createObject();
+                Object.defineProperty(ret, 'type', {
+                    value: res,
+                    enumerable: false,
+                });
+                Object.defineProperty(ret, 'data', {
+                    value: obj1 === undefined ? obj2 : obj1,
+                    enumerable: false,
+                });
+                Object.defineProperty(ret, '_bbnDiffObjProof', {
+                    value: true,
+                    enumerable: false,
+                });
+                if (obj1 !== undefined) {
+                    Object.defineProperty(ret, 'newData', {
+                        value: obj2,
+                        enumerable: false,
+                    });
+                }
+                return ret;
+            }
+            return false;
+        }
+        if (isDom(obj1) || isDom(obj2)) {
+            return false;
+        }
+        if (diffObjProcessed.includes(obj1) || diffObjProcessed.includes(obj2)) {
+            //error(bbn._("Can't compare objects because they contain circular references"));
+            return false;
+        }
+        diffObjProcessed.push(obj1, obj2);
+        for (let key in obj1) {
+            if (isFunction(obj1[key])) {
+                continue;
+            }
+            let value2 = undefined;
+            if ('undefined' != typeof obj2[key]) {
+                value2 = obj2[key];
+            }
+            let res = diffObj(obj1[key], value2, unchanged, true);
+            if (res) {
+                diff[key] = res;
+            }
+        }
+        for (let key in obj2) {
+            if (isFunction(obj2[key]) || 'undefined' != typeof obj1[key]) {
+                continue;
+            }
+            let res = diffObj(undefined, obj2[key], unchanged, true);
+            if (res) {
+                diff[key] = res;
+            }
+        }
+    }
+    return !notRoot || unchanged || numProperties(diff) ? diff : false;
+};
+export { diffObj };

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

@@ -0,0 +1,87 @@
+/**
+ * Merges the contents of two or more objects together into the first object.
+ *
+ * A boolean true argument can be done to operate a deep extend. In this case,
+ * the content of properties or subproperties arrays and objects will also be merged.
+ *
+ * @method   extend
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.extend(
+ *   {prop1: 10, prop2: 20},
+ *   {prop1: 11, prop3: 21},
+ *   {prop2: 22, prop4: false},
+ *   {prop5: false, prop3: 45}
+ * );
+ * // {prop1: 11, prop2: 22, prop3: 45, prop4: false, prop5: false}
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.extend(
+ *   {
+ *     prop1: [3, 5, 6],
+ *     prop2: {
+ *       subprop1: 87,
+ *       subprop2: 100
+ *     }
+ *   }, {
+ *     prop1: 11,
+ *     prop3: [8, 12, {aProperty: 1, anotherProperty: true}, 26]
+ *   }, {
+ *     prop2: {
+ *       subprop1: 90,
+ *       subprop3: 25
+ *     },
+ *     prop4: false
+ *   }, {
+ *     prop5: false,
+ *     prop3: [8, 45, {anotherProperty: false, andAnother: true}]
+ *   }
+ * );
+ * // {
+ * //   prop1: 11,
+ * //   prop2: {subprop1: 90, subprop3: 25},
+ * //   prop3: [8, 45, {anotherProperty: false, andAnother: true}],
+ * //   prop4: false,
+ * //   prop5: false
+ * // }
+ * ```
+ * @example
+ * ```javascript
+ * // Deep
+ * bbn.fn.extend(
+ *   true,
+ *   {
+ *     prop1: [3, 5, 6],
+ *     prop2: {
+ *       subprop1: 87,
+ *       subprop2: 100
+ *     }
+ *   }, {
+ *     prop1: 11,
+ *     prop3: [8, 12, {aProperty: 1, anotherProperty: true}, 26]
+ *   }, {
+ *     prop2: {
+ *       subprop1: 90,
+ *       subprop3: 25
+ *     },
+ *     prop4: false
+ *   }, {
+ *     prop5: false,
+ *     prop3: [8, 45, {anotherProperty: false, andAnother: true}]
+ *   }
+ * );
+ * // {
+ * //   prop1: 11,
+ * //   prop2: {subprop1: 90, subprop3: 25},
+ * //   prop3: [8, 45, {aProperty: 1, anotherProperty: false, andAnother: true}, 26],
+ * //   prop4: false,
+ * //   prop5: false
+ * // }
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Object} The first object argument, merged with the other objects given
+ */
+declare const extend: (...originalArgs: (boolean | object)[]) => any;
+export { extend };

package/dist/fn/object/extend.js

@@ -0,0 +1,158 @@
+import { iterate } from "../loop/iterate";
+import { isArray } from "../type/isArray";
+import { each } from "../loop/each";
+import { isObject } from "../type/isObject";
+/**
+ * Merges the contents of two or more objects together into the first object.
+ *
+ * A boolean true argument can be done to operate a deep extend. In this case,
+ * the content of properties or subproperties arrays and objects will also be merged.
+ *
+ * @method   extend
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.extend(
+ *   {prop1: 10, prop2: 20},
+ *   {prop1: 11, prop3: 21},
+ *   {prop2: 22, prop4: false},
+ *   {prop5: false, prop3: 45}
+ * );
+ * // {prop1: 11, prop2: 22, prop3: 45, prop4: false, prop5: false}
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.extend(
+ *   {
+ *     prop1: [3, 5, 6],
+ *     prop2: {
+ *       subprop1: 87,
+ *       subprop2: 100
+ *     }
+ *   }, {
+ *     prop1: 11,
+ *     prop3: [8, 12, {aProperty: 1, anotherProperty: true}, 26]
+ *   }, {
+ *     prop2: {
+ *       subprop1: 90,
+ *       subprop3: 25
+ *     },
+ *     prop4: false
+ *   }, {
+ *     prop5: false,
+ *     prop3: [8, 45, {anotherProperty: false, andAnother: true}]
+ *   }
+ * );
+ * // {
+ * //   prop1: 11,
+ * //   prop2: {subprop1: 90, subprop3: 25},
+ * //   prop3: [8, 45, {anotherProperty: false, andAnother: true}],
+ * //   prop4: false,
+ * //   prop5: false
+ * // }
+ * ```
+ * @example
+ * ```javascript
+ * // Deep
+ * bbn.fn.extend(
+ *   true,
+ *   {
+ *     prop1: [3, 5, 6],
+ *     prop2: {
+ *       subprop1: 87,
+ *       subprop2: 100
+ *     }
+ *   }, {
+ *     prop1: 11,
+ *     prop3: [8, 12, {aProperty: 1, anotherProperty: true}, 26]
+ *   }, {
+ *     prop2: {
+ *       subprop1: 90,
+ *       subprop3: 25
+ *     },
+ *     prop4: false
+ *   }, {
+ *     prop5: false,
+ *     prop3: [8, 45, {anotherProperty: false, andAnother: true}]
+ *   }
+ * );
+ * // {
+ * //   prop1: 11,
+ * //   prop2: {subprop1: 90, subprop3: 25},
+ * //   prop3: [8, 45, {aProperty: 1, anotherProperty: false, andAnother: true}, 26],
+ * //   prop4: false,
+ * //   prop5: false
+ * // }
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Object} The first object argument, merged with the other objects given
+ */
+const extend = function (...originalArgs) {
+    let deep = false;
+    let args = [];
+    for (let i = 0; i < originalArgs.length; i++) {
+        if (originalArgs[i] === true) {
+            deep = true;
+        }
+        else if (!originalArgs[i]) {
+            continue;
+        }
+        else if (typeof originalArgs[i] !== "object") {
+            throw new Error(bbn._("Error in extend: all arguments should be object, you have given ") + typeof originalArgs[i]);
+        }
+        else {
+            args.push(originalArgs[i]);
+        }
+    }
+    if (!args.length) {
+        throw new Error("No argument given");
+    }
+    let out = args[0];
+    for (let i = 1; i < args.length; i++) {
+        iterate(args[i], (a, key) => {
+            if (deep) {
+                if (isArray(a)) {
+                    out[key] = isArray(out[key]) ? out[key] : [];
+                    each(a, (b, i) => {
+                        if (b && typeof b === "object") {
+                            let tmp = out[key][i];
+                            if (isArray(b)) {
+                                if (!isArray(tmp)) {
+                                    tmp = [];
+                                }
+                            }
+                            else if (!isObject(tmp)) {
+                                tmp = {};
+                            }
+                            out[key][i] = extend(true, tmp, b);
+                        }
+                        else {
+                            out[key][i] = b;
+                        }
+                    });
+                }
+                else if (isObject(a)) {
+                    out[key] = extend(true, out[key] && typeof out[key] === "object"
+                        ? out[key]
+                        : Object.create(Object.getPrototypeOf(a)), a);
+                }
+                else {
+                    out[key] = a;
+                }
+            }
+            else if (out[key] !== a) {
+                out[key] = a;
+            }
+        });
+        if (args[i].__bbnNoData) {
+            Object.defineProperty(out, "__bbnNoData", {
+                value: true,
+                enumerable: false,
+                configurable: false,
+                writable: false,
+            });
+        }
+    }
+    return out;
+};
+export { extend };

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

@@ -0,0 +1,18 @@
+/**
+ * Returns a new object made of the properties from all the given objects.
+ *
+ * Compared to bbn.fn.extend this still treats the arguments from left to right
+ * but without overwriting existing properties, and returning a new object.
+ *
+ * @method   extendOut
+ * @global
+ * @example
+ * ```javascript
+ * //{field1: 1, field2: 2, field3: 3, items: {item: 0, item1: 1, item2: 2}, field4: 4}
+ * bbn.fn.extendOut({field1: 1, field2: 2, field3: 3, items: {item: 0}}, {field4: 4, items: {item1: 1, item2: 2}});
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Object}
+ */
+declare const extendOut: (...args: object[]) => any;
+export { extendOut };