@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/html/makeReactive.js

@@ -0,0 +1,185 @@
+import { log } from '../browser/log';
+import { createObject } from '../object/createObject';
+import { isSymbol } from '../type/isSymbol';
+import { isNumber } from '../type/isNumber';
+import { isArray } from '../type/isArray';
+import { warning } from '../browser/warning';
+import { isFunction } from '../type/isFunction';
+import { isSame } from '../type/isSame';
+const makeReactive = function (obj, onSet, parent, parentProp) {
+    const parentString = parent?.$cid || '';
+    const prefix = '__bbn_' + (parentString ? parentString + '_' : '');
+    if (obj && typeof obj === 'object' && [undefined, Object, Array].includes(obj.constructor)) {
+        if (obj.__bbnIsProxy && obj.__bbnParent === parent) {
+            return obj;
+        }
+        if (parent && parent.$options && parent.$options.name === 'bbn-loadbar') {
+            log(['MAKING bbn-loadbar', obj]);
+        }
+        if (!obj.__bbnWatchers) {
+            Reflect.defineProperty(obj, '__bbnWatchers', {
+                value: createObject(),
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            });
+        }
+        const handler = {
+            get(target, key) {
+                const realValue = Reflect.get(target, key);
+                const realTarget = target.__bbnRoot || target;
+                if (isSymbol(key)) {
+                    return Reflect.get(realTarget, key);
+                }
+                const propName = parentProp ? parentProp + '.' + key : key;
+                const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                if (['fill', 'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'].includes(key) &&
+                    isArray(target)) {
+                    return function (...args) {
+                        let res = realTarget[key](...args);
+                        warning('DOING ARRAY STUFF');
+                        log(target.__bbnParent);
+                        onSet(target, 'length', parent);
+                        return res;
+                    };
+                }
+                if (isFunction(realValue)) {
+                    return realValue;
+                }
+                if (key === '__bbnRoot') {
+                    let root = obj;
+                    while (root && root?.__bbnTarget) {
+                        root = root.__bbnTarget;
+                    }
+                    return root;
+                }
+                if (key === '__bbnIsProxy') {
+                    return true;
+                }
+                if (key === '__bbnTarget') {
+                    return target;
+                }
+                if (key === '__bbnParent') {
+                    return parent;
+                }
+                if (key === '__bbnWatchers') {
+                    return target.__bbnWatchers;
+                }
+                if (key.indexOf('__bbn_') === 0) {
+                    return Reflect.get(target, key);
+                }
+                if (key === 'length' && isArray(target.__bbnRoot || target)) {
+                    return realTarget.length;
+                }
+                if (!(key in target)) {
+                    return realValue;
+                }
+                if (realValue &&
+                    typeof realValue === 'object' &&
+                    [undefined, Object, Array].includes(realValue.constructor)) {
+                    if (realValue.__bbnIsProxy && realValue.__bbnParent === parent) {
+                        return realTarget[hiddenKey];
+                    }
+                    if (!(hiddenKey in realTarget)) {
+                        Reflect.defineProperty(realTarget, hiddenKey, {
+                            value: makeReactive(realValue, onSet, parent, propName),
+                            writable: true,
+                            configurable: true,
+                            enumerable: false,
+                        });
+                    }
+                    if (realTarget[hiddenKey].__bbnIsProxy && !realTarget.__bbnWatchers[parentString]) {
+                        realTarget.__bbnWatchers[parentString] = propName;
+                    }
+                    return realTarget[hiddenKey];
+                }
+                return realValue;
+            },
+            set(target, key, value) {
+                if (isSymbol(key)) {
+                    return Reflect.get(target, key, value);
+                }
+                const realTarget = target.__bbnRoot || target;
+                const propName = parentProp ? parentProp + '.' + key : key;
+                if (isSymbol(key)) {
+                    return Reflect.get(target, key);
+                }
+                if (parent && parent.$options && parent.$options.name === 'bbn-loadbar') {
+                    log(['Setting proxy prop in ' + parent.$options.name, target, key, value]);
+                }
+                if (!isSame(realTarget[key], value)) {
+                    if (key.indexOf('__bbn_') === 0) {
+                        Reflect.defineProperty(realTarget, key, {
+                            value: makeReactive(value, onSet, parent, propName),
+                            writable: true,
+                            configurable: true,
+                            enumerable: false,
+                        });
+                    }
+                    else {
+                        if (value &&
+                            typeof value === 'object' &&
+                            [undefined, Object, Array].includes(value.constructor)) {
+                            const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                            Reflect.defineProperty(realTarget, hiddenKey, {
+                                value: makeReactive(value, onSet, parent, propName),
+                                writable: true,
+                                configurable: true,
+                                enumerable: false,
+                            });
+                            if (realTarget[hiddenKey].__bbnIsProxy && !realTarget.__bbnWatchers[parentString]) {
+                                realTarget.__bbnWatchers[parentString] = propName;
+                            }
+                        }
+                    }
+                    if (parent && parent.$options && parent.$options.name === 'bbn-loadbar') {
+                        log([
+                            'Setting proxy prop in ' +
+                                parent.$options.name +
+                                ' ' +
+                                (isNumber(key) ? key.toString() : key),
+                            value,
+                            target,
+                        ]);
+                    }
+                    Reflect.set(realTarget, key, value);
+                    onSet(target, key, parent);
+                }
+                return true;
+            },
+            defineProperty(target, key, description) {
+                const realTarget = target;
+                const propName = parentProp ? parentProp + '.' + key : key;
+                if (key === '__bbnWatchers' || isSymbol(key) || key.indexOf('__bbn_') === 0) {
+                    Reflect.defineProperty(realTarget, key, description);
+                }
+                else {
+                    const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                    Reflect.defineProperty(realTarget, hiddenKey, {
+                        value: makeReactive(description.value, onSet, parent, propName),
+                        writable: true,
+                        configurable: true,
+                        enumerable: false,
+                    });
+                }
+                onSet(target, key, parent);
+                return true;
+            },
+            deleteProperty(target, key) {
+                const realTarget = target;
+                if (key.indexOf('__bbn_') === 0) {
+                    Reflect.deleteProperty(realTarget, key);
+                }
+                else {
+                    const hiddenKey = prefix + (isNumber(key) ? key.toString() : key);
+                    Reflect.deleteProperty(realTarget, hiddenKey);
+                    Reflect.deleteProperty(target, key);
+                }
+                return true;
+            },
+        };
+        return new Proxy(obj, handler);
+    }
+    return obj;
+};
+export { makeReactive };

package/dist/fn/html/selector.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @ignore
+ * @method   selector
+ * @todo     Add method description for selector
+ * @global
+ * @memberof bbn.fn
+ * @returns  {*}
+ */
+declare const selector: (ele: string | HTMLElement) => HTMLElement | undefined;
+export { selector };

package/dist/fn/html/selector.js

@@ -0,0 +1,12 @@
+/**
+ * @ignore
+ * @method   selector
+ * @todo     Add method description for selector
+ * @global
+ * @memberof bbn.fn
+ * @returns  {*}
+ */
+const selector = function (ele) {
+    return typeof ele === "string" ? document.querySelector(ele) : ele;
+};
+export { selector };

package/dist/fn/init.d.ts

@@ -1,2 +1,15 @@
+/**
+ * Initializes the library bbn basing on the given configuration object.
+ * - Gives to the environment the dimension of the window.innerWidth and window.innerHeight
+ * - Defines the server's path (difference between the host and the current dir)
+ * - Adds the colors contained in bbn.var.colors to define the css classes for background and colors.
+ * - Adds the event listener to the document
+ * - Activates the history
+ * @method   init
+ * @global
+ * @memberof bbn.fn
+ * @param    {Object} cfg
+ * @returns
+ */
 declare const init: (cfg: any, force: any) => void;
 export { init };

package/dist/fn/init.js

@@ -1,15 +1,28 @@
-import { substr } from './substr';
-import { each } from './each';
-import { extend } from './extend';
-import { addColors } from './addColors';
-import { link } from './link';
-import { submit } from './submit';
-import { resize } from './resize';
-import { isMobile } from './isMobile';
-import { isTabletDevice } from './isTabletDevice';
-import { defaultHistoryFunction } from './defaultHistoryFunction';
-import { isFunction } from './isFunction';
-import { log } from './log';
+import { substr } from './string/substr';
+import { each } from './loop/each';
+import { extend } from './object/extend';
+import { addColors } from './style/addColors';
+import { link } from './ajax/link';
+import { submit } from './form/submit';
+import { resize } from './style/resize';
+import { isMobile } from './browser/isMobile';
+import { isTabletDevice } from './browser/isTabletDevice';
+import { defaultHistoryFunction } from './default/defaultHistoryFunction';
+import { isFunction } from './type/isFunction';
+import { log } from './browser/log';
+/**
+ * Initializes the library bbn basing on the given configuration object.
+ * - Gives to the environment the dimension of the window.innerWidth and window.innerHeight
+ * - Defines the server's path (difference between the host and the current dir)
+ * - Adds the colors contained in bbn.var.colors to define the css classes for background and colors.
+ * - Adds the event listener to the document
+ * - Activates the history
+ * @method   init
+ * @global
+ * @memberof bbn.fn
+ * @param    {Object} cfg
+ * @returns
+ */
 const init = function (cfg, force) {
     let parts;
     if (!bbn.env.isInit || force) {

package/dist/fn/loop/each.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Executes the provided function on each element of the given array.
+ *
+ * Returning false will stop the loop.
+ *
+ * @method   each
+ * @global
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.each([4, 5, 5, 10, 1, 2], d => {
+ *   res += d;
+ * });
+ * // res = 27
+ * ```
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.each([4, 5, 5, 10, 1, 2], d => {
+ *   if (res >= 20) {
+ *     return false;
+ *   }
+ *   res += d;
+ * });
+ * // res = 24
+ * ```
+ * @memberof bbn.fn
+ * @param    {*}     arr The array to loop on
+ * @param    {Function}  fn  The function, gets the array's element and the index as arguments
+ * @returns  {[Array, Object, void]}
+ */
+declare const each: (arr: any, fn: any) => any;
+export { each };

package/dist/fn/loop/each.js

@@ -0,0 +1,54 @@
+import { isNumber } from "../type/isNumber";
+import { isIterable } from "../type/isIterable";
+import { iterate } from "./iterate";
+/**
+ * Executes the provided function on each element of the given array.
+ *
+ * Returning false will stop the loop.
+ *
+ * @method   each
+ * @global
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.each([4, 5, 5, 10, 1, 2], d => {
+ *   res += d;
+ * });
+ * // res = 27
+ * ```
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.each([4, 5, 5, 10, 1, 2], d => {
+ *   if (res >= 20) {
+ *     return false;
+ *   }
+ *   res += d;
+ * });
+ * // res = 24
+ * ```
+ * @memberof bbn.fn
+ * @param    {*}     arr The array to loop on
+ * @param    {Function}  fn  The function, gets the array's element and the index as arguments
+ * @returns  {[Array, Object, void]}
+ */
+const each = function (arr, fn) {
+    if (isNumber(arr) && arr > 0) {
+        for (let i = 0; i < arr; i++) {
+            if (fn(i, i) === false) {
+                return;
+            }
+        }
+        return;
+    }
+    if (isIterable(arr)) {
+        for (let i = 0; i < arr.length; i++) {
+            if (fn(arr[i], i) === false) {
+                return;
+            }
+        }
+        return arr;
+    }
+    return iterate(arr, fn);
+};
+export { each };

package/dist/fn/loop/fori.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Executes the provided function on each element of the given array.
+ *
+ * A minimum and a maximum value can be provided, within the boundaries of the
+ * array's indexes. Returning false will stop the loop.
+ *
+ * @method   fori
+ * @global
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.fori([4, 5, 5, 10, 1, 2], d => {
+ *   res += d;
+ * }, 3);
+ * // res = 24
+ * ```
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.fori([4, 5, 5, 10, 1, 2], d => {
+ *   if (res >= 20) {
+ *     return false;
+ *   }
+ *   res += d;
+ * }, 4, 1);
+ * // res = 20
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}     arr The array to loop on
+ * @param    {Function}  fn  The function, gets the array's element and the index as arguments
+ * @param    {Number}    max The index to which the loop will stop
+ * @param    {Number}    min The index at which the loop will start
+ * @returns  {undefined}
+ */
+declare const fori: (arr: any[], fn: (a: any, i: number) => any, max?: number, min?: number) => void;
+export { fori };

package/dist/fn/loop/fori.js

@@ -0,0 +1,53 @@
+import { isArray } from "../type/isArray";
+import { isNumber } from "../type/isNumber";
+/**
+ * Executes the provided function on each element of the given array.
+ *
+ * A minimum and a maximum value can be provided, within the boundaries of the
+ * array's indexes. Returning false will stop the loop.
+ *
+ * @method   fori
+ * @global
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.fori([4, 5, 5, 10, 1, 2], d => {
+ *   res += d;
+ * }, 3);
+ * // res = 24
+ * ```
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.fori([4, 5, 5, 10, 1, 2], d => {
+ *   if (res >= 20) {
+ *     return false;
+ *   }
+ *   res += d;
+ * }, 4, 1);
+ * // res = 20
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}     arr The array to loop on
+ * @param    {Function}  fn  The function, gets the array's element and the index as arguments
+ * @param    {Number}    max The index to which the loop will stop
+ * @param    {Number}    min The index at which the loop will start
+ * @returns  {undefined}
+ */
+const fori = function (arr, fn, max = arr.length - 1, min = 0) {
+    if (isArray(arr)) {
+        let realMax = arr.length - 1;
+        if (!isNumber(max) || !(0 < max && max <= realMax)) {
+            max = realMax;
+        }
+        if (!isNumber(min) || !(0 <= min && min < realMax) || min > max) {
+            min = 0;
+        }
+        for (let i = min; i <= max; i++) {
+            if (fn(arr[i], i) === false) {
+                return;
+            }
+        }
+    }
+};
+export { fori };

package/dist/fn/loop/forir.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Executes the provided function on each element of the given array, going backward.
+ *
+ * A maximum and a minimum value can be provided, within the boundaries of the
+ * array's indexes. Returning false will stop the loop.
+ *
+ * @method   forir
+ * @global
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.forir([4, 5, 5, 10, 1, 2], d => {
+ *   res += d;
+ * }, 4, 2);
+ * // res = 16
+ * ```
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.forir([4, 5, 5, 10, 1, 2], d => {
+ *   if (res >= 20) {
+ *     return false;
+ *   }
+ *   res += d;
+ * });
+ * // res = 23
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}     arr The array to loop on
+ * @param    {Function}  fn  The function, gets the array's element and the index as arguments
+ * @param    {Number}    max The index to which the loop will stop
+ * @param    {Number}    min The index at which the loop will start
+ * @returns  {undefined}
+ */
+declare const forir: (arr: any[], fn: (a: any, b: number) => any, max?: number, min?: number) => void;
+export { forir };

package/dist/fn/loop/forir.js

@@ -0,0 +1,53 @@
+import { isArray } from "../type/isArray";
+import { isNumber } from "../type/isNumber";
+/**
+ * Executes the provided function on each element of the given array, going backward.
+ *
+ * A maximum and a minimum value can be provided, within the boundaries of the
+ * array's indexes. Returning false will stop the loop.
+ *
+ * @method   forir
+ * @global
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.forir([4, 5, 5, 10, 1, 2], d => {
+ *   res += d;
+ * }, 4, 2);
+ * // res = 16
+ * ```
+ * @example
+ * ```javascript
+ * let res = 0;
+ * bbn.fn.forir([4, 5, 5, 10, 1, 2], d => {
+ *   if (res >= 20) {
+ *     return false;
+ *   }
+ *   res += d;
+ * });
+ * // res = 23
+ * ```
+ * @memberof bbn.fn
+ * @param    {Array}     arr The array to loop on
+ * @param    {Function}  fn  The function, gets the array's element and the index as arguments
+ * @param    {Number}    max The index to which the loop will stop
+ * @param    {Number}    min The index at which the loop will start
+ * @returns  {undefined}
+ */
+const forir = function (arr, fn, max = arr.length - 1, min = 0) {
+    if (isArray(arr)) {
+        let realMax = arr.length - 1;
+        if (!isNumber(max) || !(0 < max && max <= realMax)) {
+            max = realMax;
+        }
+        if (!isNumber(min) || !(0 <= min && min < realMax) || min > max) {
+            min = 0;
+        }
+        for (let i = max; i >= min; i--) {
+            if (fn(arr[i], i) === false) {
+                return;
+            }
+        }
+    }
+};
+export { forir };

package/dist/fn/loop/iterate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Executes the provided function on each property of the given object.
+ *
+ * @method   iterate
+ * @global
+ * @example
+ * ```javascript
+ * //["value1", 2]
+ * let arr = [];
+ * bbn.fn.iterate({field1: "value1", field2: 2}, (val, idx) => {
+ *   arr.push(value);
+ * });
+ * ```
+ * @memberof bbn.fn
+ * @param    {(Object|Number)} obj       The object to loop on
+ * @param    {Function}        fn        The function, gets the array's element and the index as arguments
+ * @param    {Boolean}         noPrivate If set to true the _private_ properties won't be included
+ * @param    {Boolean}         reverse   If set to true the order of the keys will be reversed
+ * @returns  {Object}
+ */
+declare const iterate: (obj: object, fn: (a: any, b: string) => any, noPrivate?: boolean, reverse?: boolean) => object;
+export { iterate };

package/dist/fn/loop/iterate.js

@@ -0,0 +1,36 @@
+import { removePrivateProp } from "../object/removePrivateProp";
+/**
+ * Executes the provided function on each property of the given object.
+ *
+ * @method   iterate
+ * @global
+ * @example
+ * ```javascript
+ * //["value1", 2]
+ * let arr = [];
+ * bbn.fn.iterate({field1: "value1", field2: 2}, (val, idx) => {
+ *   arr.push(value);
+ * });
+ * ```
+ * @memberof bbn.fn
+ * @param    {(Object|Number)} obj       The object to loop on
+ * @param    {Function}        fn        The function, gets the array's element and the index as arguments
+ * @param    {Boolean}         noPrivate If set to true the _private_ properties won't be included
+ * @param    {Boolean}         reverse   If set to true the order of the keys will be reversed
+ * @returns  {Object}
+ */
+const iterate = function (obj, fn, noPrivate = false, reverse = false) {
+    if (obj !== null && typeof obj === "object") {
+        let iter = Object.keys(noPrivate ? removePrivateProp(obj) : obj);
+        if (reverse) {
+            iter.reverse();
+        }
+        for (let prop of iter) {
+            if (fn(obj[prop], prop) === false) {
+                break;
+            }
+        }
+    }
+    return obj;
+};
+export { iterate };

package/dist/fn/loop/riterate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Executes the provided function on each property of the given object.
+ *
+ * @method   riterate
+ * @global
+ * @example
+ * ```javascript
+ * //["value1", 2]
+ * let arr = [];
+ * bbn.fn.iterate({field1: "value1", field2: 2}, (val, idx) => {
+ *   arr.push(value);
+ * });
+ * ```
+ * @memberof bbn.fn
+ * @param    {(Object|Number)} obj       The object to loop on
+ * @param    {Function}        fn        The function, gets the array's element and the index as arguments
+ * @param    {Boolean}         noPrivate If set to true the _private_ properties won't be included
+ * @returns  {Object}
+ */
+declare const riterate: (obj: object, fn: (a: any, b: string) => any, noPrivate?: boolean) => object;
+export { riterate };

package/dist/fn/loop/riterate.js

@@ -0,0 +1,24 @@
+import { iterate } from "./iterate";
+/**
+ * Executes the provided function on each property of the given object.
+ *
+ * @method   riterate
+ * @global
+ * @example
+ * ```javascript
+ * //["value1", 2]
+ * let arr = [];
+ * bbn.fn.iterate({field1: "value1", field2: 2}, (val, idx) => {
+ *   arr.push(value);
+ * });
+ * ```
+ * @memberof bbn.fn
+ * @param    {(Object|Number)} obj       The object to loop on
+ * @param    {Function}        fn        The function, gets the array's element and the index as arguments
+ * @param    {Boolean}         noPrivate If set to true the _private_ properties won't be included
+ * @returns  {Object}
+ */
+const riterate = function (obj, fn, noPrivate) {
+    return iterate(obj, fn, noPrivate, true);
+};
+export { riterate };

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

@@ -0,0 +1,11 @@
+declare const analyzeFunction: (fn: any) => {
+    body: any;
+    args: any[];
+    argString: string;
+    isArrow: boolean;
+    hasFunction: boolean;
+    name: any;
+    isAsync: boolean;
+    hash: string;
+};
+export { analyzeFunction };