@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/object/extendOut.js

@@ -0,0 +1,40 @@
+import { isObject } from "../type/isObject";
+/**
+ * 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}
+ */
+const extendOut = function (...args) {
+    let r = null;
+    for (let a of args) {
+        if (!isObject(a)) {
+            throw new Error("Each argument for extendOut must be an object, " + typeof a + " given");
+        }
+        if (r === null) {
+            r = a;
+        }
+        else {
+            for (let n in a) {
+                if (isObject(r[n], a[n])) {
+                    extendOut(r[n], a[n]);
+                }
+                else if (r[n] === undefined) {
+                    r[n] = a[n];
+                }
+            }
+        }
+    }
+    return r;
+};
+export { extendOut };

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

@@ -0,0 +1,50 @@
+import { Filter } from './filterToConditions';
+/**
+ * Returns a new array with only the data matching the given filter.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   filter
+ * @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.filter(ar, {director: "Steven Spielberg"});
+ * // [
+ * //   {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ * //   {name: "Jaws", director: "Steven Spielberg", year: 1975, id: 423}
+ * // ]
+ * bbn.fn.filter(ar, "director", "Steven Spielberg");
+ * // Same result as the previous example
+ * bbn.fn.filter(ar, {
+ *   logic: "OR",
+ *   conditions: [
+ *     {
+ *        field: "director",
+ *        value: "Richard Donner"
+ *     }, {
+ *        field: "director",
+ *        value: "George Lucas"
+ *     }
+ *   ]
+ * );
+ * // [
+ * //   {name: "Goonies", director: "Richard Donner", year: 1985, id: 689},
+ * //   {name: "Star wars", director: "George Lucas", year: 1977, id: 256},
+ * // ]
+ * ```
+ *
+ * @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  {Array}                    A new filtered array
+ */
+declare const filter: (arr: any[], prop: string | object | Filter | ((a: any, i: string | number | symbol) => boolean), val?: any, operator?: string) => any[];
+export { filter };

package/dist/fn/object/filter.js

@@ -0,0 +1,94 @@
+import { isArray } from '../type/isArray';
+import { each } from '../loop/each';
+import { filterToConditions } from './filterToConditions';
+import { compareConditions } from './compareConditions';
+/**
+ * Returns a new array with only the data matching the given filter.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   filter
+ * @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.filter(ar, {director: "Steven Spielberg"});
+ * // [
+ * //   {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ * //   {name: "Jaws", director: "Steven Spielberg", year: 1975, id: 423}
+ * // ]
+ * bbn.fn.filter(ar, "director", "Steven Spielberg");
+ * // Same result as the previous example
+ * bbn.fn.filter(ar, {
+ *   logic: "OR",
+ *   conditions: [
+ *     {
+ *        field: "director",
+ *        value: "Richard Donner"
+ *     }, {
+ *        field: "director",
+ *        value: "George Lucas"
+ *     }
+ *   ]
+ * );
+ * // [
+ * //   {name: "Goonies", director: "Richard Donner", year: 1985, id: 689},
+ * //   {name: "Star wars", director: "George Lucas", year: 1977, id: 256},
+ * // ]
+ * ```
+ *
+ * @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  {Array}                    A new filtered array
+ */
+const filter = function (arr, prop, val = null, operator = '=') {
+    if (!isArray(arr)) {
+        bbn.fn.log("NOT ARRAY", arr);
+        throw new Error('Error in filter: The first argument must be an array');
+    }
+    let cfg = {};
+    const res = [];
+    const isFn = typeof (prop) === 'function';
+    if (!prop || !arr.length) {
+        return arr;
+    }
+    if (arr.length) {
+        if (typeof prop === 'object') {
+            operator = val;
+            cfg = prop;
+        }
+        else if (typeof prop === 'string') {
+            cfg[prop] = val;
+        }
+        else if (!isFn) {
+            throw new Error('Search function error: The prop argument should be a string or an object');
+        }
+        if (typeof (prop) === 'function') {
+            each(arr, (a, i) => {
+                if (prop(a, i)) {
+                    res.push(a);
+                }
+            });
+        }
+        else {
+            cfg = filterToConditions(cfg, operator);
+            if (cfg.conditions && cfg.logic) {
+                each(arr, (a) => {
+                    if (compareConditions(a, cfg)) {
+                        res.push(a);
+                    }
+                });
+            }
+        }
+        return res;
+    }
+};
+export { filter };

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

@@ -0,0 +1,48 @@
+interface Condition {
+    field: string;
+    operator?: string;
+    value?: any;
+}
+interface Filter {
+    conditions?: Condition[];
+    logic?: string;
+}
+/**
+ * Converts the given object 'filter' to a valid format of condition.
+ *
+ * The resulting format will comply with bbn.fn.compareConditions and also with
+ * bbn databases functions and complex filters applied to bbn-vue list components.
+ *
+ * @method   filterToConditions
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.filterToConditions({num: 3});
+ * // {
+ * //   logic: "AND",
+ * //   conditions: [{
+ * //     field: "num",
+ * //     operator: "=",
+ * //     value: 3
+ * //   }]
+ * // }
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.filterToConditions({num: 3}, '>');
+ * // {
+ * //   logic: "AND",
+ * //   conditions: [{
+ * //     field: "num",
+ * //     operator: ">",
+ * //     value: 3
+ * //   }]
+ * // }
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} filter
+ * @param    {String} operator
+ * @returns  {Object}
+ */
+declare const filterToConditions: (filter: any, operator?: string) => Filter;
+export { Filter, filterToConditions };

package/dist/fn/object/filterToConditions.js

@@ -0,0 +1,68 @@
+import { isObject } from "../type/isObject";
+import { isArray } from "../type/isArray";
+import { iterate } from "../loop/iterate";
+/**
+ * Converts the given object 'filter' to a valid format of condition.
+ *
+ * The resulting format will comply with bbn.fn.compareConditions and also with
+ * bbn databases functions and complex filters applied to bbn-vue list components.
+ *
+ * @method   filterToConditions
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.filterToConditions({num: 3});
+ * // {
+ * //   logic: "AND",
+ * //   conditions: [{
+ * //     field: "num",
+ * //     operator: "=",
+ * //     value: 3
+ * //   }]
+ * // }
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.filterToConditions({num: 3}, '>');
+ * // {
+ * //   logic: "AND",
+ * //   conditions: [{
+ * //     field: "num",
+ * //     operator: ">",
+ * //     value: 3
+ * //   }]
+ * // }
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} filter
+ * @param    {String} operator
+ * @returns  {Object}
+ */
+const filterToConditions = function (filter, operator = "=") {
+    if (!isObject(filter)) {
+        throw new Error("Error in filterToCondition: filter must be an object");
+    }
+    if (!filter.conditions || !isArray(filter.conditions)) {
+        let tmp = [];
+        iterate(filter, (a, n) => {
+            if (isObject(a) && typeof a.conditions === "object") {
+                tmp.push(filterToConditions(a));
+            }
+            else {
+                tmp.push({
+                    field: n,
+                    operator: operator,
+                    value: a,
+                });
+            }
+        });
+        filter = {
+            conditions: tmp,
+        };
+    }
+    if (!filter.logic) {
+        filter.logic = "AND";
+    }
+    return filter;
+};
+export { filterToConditions };

package/dist/fn/object/findAll.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 findAll: (arr: any, filter: any, deepProperty: any, res?: any[]) => any[];
+export { findAll };

package/dist/fn/object/findAll.js

@@ -0,0 +1,73 @@
+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 findAll = function (arr, filter, deepProperty, res = []) {
+    let idx;
+    let start = 0;
+    while ((idx = search(arr, filter, start)) > -1) {
+        res.push(arr[idx]);
+        start = idx + 1;
+    }
+    each(arr, (it) => {
+        if (isArray(it[deepProperty])) {
+            findAll(it[deepProperty], filter, deepProperty, res);
+        }
+    });
+    return res;
+};
+export { findAll };

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

@@ -0,0 +1,30 @@
+/**
+  * Returns the value of the given field (property) from the first object matching the given filter in an array of objects.
+  *
+  * The filtering arguments follow the same scheme as bbn.fn.search.
+  *
+  * @method   getField
+  * @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.getField(ar, "name", {id: 256});
+  * // Star wars
+  * bbn.fn.getField(ar, "name", "id", 689);
+  * // Goonies
+  * ```
+  * @memberof bbn.fn
+  * @param    {Array}                    arr       The subject array
+  * @param    {String}                   field     The property from which the value is returned
+  * @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  {*}
+  */
+declare const getField: (arr: any[], field: string, prop?: object | string, val?: any, operator?: string) => any;
+export { getField };

package/dist/fn/object/getField.js

@@ -0,0 +1,37 @@
+import { getRow } from './getRow';
+/**
+  * Returns the value of the given field (property) from the first object matching the given filter in an array of objects.
+  *
+  * The filtering arguments follow the same scheme as bbn.fn.search.
+  *
+  * @method   getField
+  * @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.getField(ar, "name", {id: 256});
+  * // Star wars
+  * bbn.fn.getField(ar, "name", "id", 689);
+  * // Goonies
+  * ```
+  * @memberof bbn.fn
+  * @param    {Array}                    arr       The subject array
+  * @param    {String}                   field     The property from which the value is returned
+  * @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  {*}
+  */
+const getField = function (arr, field, prop = '', val = null, operator = '=') {
+    let r;
+    if (field && (r = getRow(arr, prop, val, operator))) {
+        return r[field];
+    }
+    return undefined;
+};
+export { getField };

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

@@ -0,0 +1,30 @@
+/**
+ * Returns all the unique values of the given field (property) from the first object matching the given filter in an array.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   getFieldValues
+ * @global
+ * @example
+ * ```javascript
+ * let ar = [
+ *   {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ *   {name: "Star wars", director: "George Lucas", year: 1977, id: 256},
+ *   {name: "Jaws", director: "Steven Spielberg", year: 1975, id: 423}
+ *   {name: "Barry Lindon", director: "Stanley Kubrick", year: 1975, id: 802}
+ * ];
+ * bbn.fn.getFieldValues(ar, "director");
+ * // ["Steven Spielberg", "George Lucas", "Stanley Kubrick"]
+ * bbn.fn.getFieldValues(ar, "name", {year: 1975});
+ * // ["Jaws", "Barry Lindon"]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}                    arr       The subject array
+ * @param    {String}                   field     The property from which the values are returned
+ * @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  {*}
+ */
+declare const getFieldValues: (arr: object[], field: string, prop: any, val: any, operator: any) => any[];
+export { getFieldValues };

package/dist/fn/object/getFieldValues.js

@@ -0,0 +1,41 @@
+import { checkType } from '../type/checkType';
+import { filter } from './filter';
+import { each } from '../loop/each';
+/**
+ * Returns all the unique values of the given field (property) from the first object matching the given filter in an array.
+ *
+ * The filtering arguments follow the same scheme as bbn.fn.search.
+ *
+ * @method   getFieldValues
+ * @global
+ * @example
+ * ```javascript
+ * let ar = [
+ *   {name: "Raiders of the lost ark", director: "Steven Spielberg", year: 1981, id: 589},
+ *   {name: "Star wars", director: "George Lucas", year: 1977, id: 256},
+ *   {name: "Jaws", director: "Steven Spielberg", year: 1975, id: 423}
+ *   {name: "Barry Lindon", director: "Stanley Kubrick", year: 1975, id: 802}
+ * ];
+ * bbn.fn.getFieldValues(ar, "director");
+ * // ["Steven Spielberg", "George Lucas", "Stanley Kubrick"]
+ * bbn.fn.getFieldValues(ar, "name", {year: 1975});
+ * // ["Jaws", "Barry Lindon"]
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}                    arr       The subject array
+ * @param    {String}                   field     The property from which the values are returned
+ * @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  {*}
+ */
+const getFieldValues = function (arr, field, prop, val, operator) {
+    checkType(field, 'string');
+    if (prop) {
+        arr = filter(arr, prop, val, operator);
+    }
+    let res = [];
+    each(arr, (a) => (res.indexOf(a[field]) === -1 ? res.push(a[field]) : null));
+    return res;
+};
+export { getFieldValues };

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

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

package/dist/fn/object/getProp.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 getProp = 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"));
+    return obj[prop];
+};
+export { getProp };

package/dist/fn/object/getProperty.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 getProperty: (obj: any, prop: any) => any;
+export { getProperty };

package/dist/fn/object/getProperty.js

@@ -0,0 +1,39 @@
+/**
+ * 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 getProperty = function (obj, prop) {
+    if (typeof obj === 'object' && typeof prop === 'string') {
+        return prop.split('.').reduce((o, i) => {
+            if (o) {
+                return o[i];
+            }
+            return undefined;
+        }, obj);
+    }
+};
+export { getProperty };