@bbn/bbn 1.0.58 → 1.0.60

package/dist/db.js

@@ -1,7 +1,7 @@
 import { _ } from './_';
-import { each } from './fn/each';
-import { iterate } from './fn/iterate';
-import { log } from './fn/log';
+import { each } from './fn/loop/each';
+import { iterate } from './fn/loop/iterate';
+import { log } from './fn/browser/log';
 const idb = indexedDB || window['webkitIndexedDB'] || window['mozIndexedDB'] || window['OIndexedDB'] || window['msIndexedDB'];
 const dbObject = function (dbName) {
     const conn = db._connections[dbName];

package/dist/fn/ajax/_addLoader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates and adds a "loader" object to the property bbn.env.loaders.
+ *
+ * @method   _addLoader
+ * @global
+ * @ignore
+ * @memberof bbn.fn
+ *
+ * @param    {String}  requestId
+ * @param    {Promise} prom
+ * @param    {Object}  source
+ *
+ * @returns  {Number}  The timestamp (in ms)
+ */
+declare const _addLoader: (requestId: any, prom: any, source: any) => number;
+export { _addLoader };

package/dist/fn/ajax/_addLoader.js

@@ -0,0 +1,51 @@
+import { substr } from "../string/substr";
+/**
+ * Creates and adds a "loader" object to the property bbn.env.loaders.
+ *
+ * @method   _addLoader
+ * @global
+ * @ignore
+ * @memberof bbn.fn
+ *
+ * @param    {String}  requestId
+ * @param    {Promise} prom
+ * @param    {Object}  source
+ *
+ * @returns  {Number}  The timestamp (in ms)
+ */
+const _addLoader = function (requestId, prom, source) {
+    /** @var {Number} tst Current timestamp */
+    let tst = new Date().getTime();
+    /** @var {String} url The original URL (part of requestId before : and md5) */
+    let url = substr(requestId, 0, requestId.length - 33);
+    /** @var {Object} loader The loader object */
+    let loader = {
+        key: requestId,
+        url: url,
+        loader: prom,
+        source: source,
+        loading: true,
+        error: false,
+        abort: false,
+        errorMessage: false,
+        success: false,
+        start: tst,
+    };
+    // Adding the loader in bbn.env.loaders
+    bbn.env.loaders.push(loader);
+    // Adding an object with this loader info in bbn.env.loadersHistory
+    bbn.env.loadersHistory.unshift(loader);
+    /** @var {Number} idx A pointer starting at the end of  array loadersHistory */
+    let idx = bbn.env.loadersHistory.length;
+    // Removing elements from the loadersHistory object if their number is higher
+    // than bbn.env.maxLoadersHistory
+    while (idx && bbn.env.loadersHistory.length > bbn.env.maxLoadersHistory) {
+        idx--;
+        // Not removing the ones still loading
+        if (!bbn.env.loading) {
+            bbn.env.loadersHistory.splice(idx, 1);
+        }
+    }
+    return tst;
+};
+export { _addLoader };

package/dist/fn/ajax/_deleteLoader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deletes a loader and changes its history state after the promise is fullfilled.
+ *
+ * @method   _deleteLoader
+ * @global
+ * @ignore
+ * @memberof bbn.fn
+ *
+ * @param    {String}  requestId   The unique ID of the request sent
+ * @param    {*}       res     The result of the request
+ * @param    {Boolean} isAbort True if the deletion comes from abortion
+ *
+ * @returns  {Boolean} True if the loader was found
+ */
+declare const _deleteLoader: (requestId: string, res?: any, isAbort?: boolean) => boolean;
+export { _deleteLoader };

package/dist/fn/ajax/_deleteLoader.js

@@ -0,0 +1,39 @@
+import { search } from '../object/search';
+import { getRow } from '../object/getRow';
+import { isObject } from '../type/isObject';
+/**
+ * Deletes a loader and changes its history state after the promise is fullfilled.
+ *
+ * @method   _deleteLoader
+ * @global
+ * @ignore
+ * @memberof bbn.fn
+ *
+ * @param    {String}  requestId   The unique ID of the request sent
+ * @param    {*}       res     The result of the request
+ * @param    {Boolean} isAbort True if the deletion comes from abortion
+ *
+ * @returns  {Boolean} True if the loader was found
+ */
+const _deleteLoader = function (requestId, res = null, isAbort = false) {
+    let idx = search(bbn.env.loaders, { key: requestId });
+    if (idx > -1) {
+        let loader = bbn.env.loaders.splice(idx, 1)[0];
+        let history = getRow(bbn.env.loadersHistory, { key: requestId, start: loader.start });
+        if (history) {
+            history.loading = false;
+            history.duration = new Date().getTime() - loader.start;
+            if (typeof res === 'string') {
+                history.errorMessage = res;
+                history.error = !isAbort;
+                history.abort = isAbort;
+            }
+            else if (isObject(res)) {
+                history.success = true;
+            }
+        }
+        return true;
+    }
+    return false;
+};
+export { _deleteLoader };

package/dist/fn/ajax/abort.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Aborts (client side) the XHR corresponding to the given ID if it still exists.
+ *
+ * This will throw an error if the loader can't be found.
+ *
+ * @method   abort
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('my/script', {a: 1, b: 2});
+ * let requestId = bbn.fn.getRequestId('my/script', {a: 1, b: 2});
+ * if (requestId) {
+ *   bbn.fn.abort(requestId);
+ * }
+ * ```
+ *
+ * @param    {String} requestId An ID generated by getRequestId
+ *
+ * @returns  {undefined}
+ */
+declare const abort: (requestId: any) => void;
+export { abort };

package/dist/fn/ajax/abort.js

@@ -0,0 +1,36 @@
+import { getLoader } from './getLoader';
+/**
+ * Aborts (client side) the XHR corresponding to the given ID if it still exists.
+ *
+ * This will throw an error if the loader can't be found.
+ *
+ * @method   abort
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('my/script', {a: 1, b: 2});
+ * let requestId = bbn.fn.getRequestId('my/script', {a: 1, b: 2});
+ * if (requestId) {
+ *   bbn.fn.abort(requestId);
+ * }
+ * ```
+ *
+ * @param    {String} requestId An ID generated by getRequestId
+ *
+ * @returns  {undefined}
+ */
+const abort = function (requestId) {
+    let loader = getLoader(requestId);
+    if (loader && loader.source) {
+        //_deleteLoader(requestId);
+        loader.source.cancel('Operation canceled by the user.');
+    }
+    /*
+      else {
+        throw new Error("Impossible to find the loader " + requestId);
+      }
+      */
+};
+export { abort };

package/dist/fn/ajax/abortURL.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Aborts (client side) all the XHR using the given URL if it still exists.
+ *
+ * This will throw an error if the loader can't be found.
+ *
+ * @method   abortURL
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('my/script', {a: 1, b: 2});
+ * bbn.fn.post('my/script', {c: 1, d: 2});
+ * bbn.fn.abortURL('my/script');
+ * ```
+ *
+ * @param    {String} requestId An ID generated by getRequestId
+ *
+ * @returns  {undefined}
+ */
+declare const abortURL: (url: any) => void;
+export { abortURL };

package/dist/fn/ajax/abortURL.js

@@ -0,0 +1,33 @@
+import { each } from '../loop/each';
+import { filter } from '../object/filter';
+/**
+ * Aborts (client side) all the XHR using the given URL if it still exists.
+ *
+ * This will throw an error if the loader can't be found.
+ *
+ * @method   abortURL
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.post('my/script', {a: 1, b: 2});
+ * bbn.fn.post('my/script', {c: 1, d: 2});
+ * bbn.fn.abortURL('my/script');
+ * ```
+ *
+ * @param    {String} requestId An ID generated by getRequestId
+ *
+ * @returns  {undefined}
+ */
+const abortURL = function (url) {
+    each(filter(bbn.env.loaders, { url: url }), (a) => {
+        if (a && a.source) {
+            a.source.cancel('Operation canceled by the user.');
+        }
+        else {
+            throw new Error('Impossible to find the loader with URL ' + url);
+        }
+    });
+};
+export { abortURL };

package/dist/fn/ajax/ajax.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Creates an XHR object and returns the Promise.
+ *
+ * Checks the URL, makes an ID, creates a loader, sets the general callbacks,
+ * makes a POST if data is given a GET otherwise (GET data should be added
+ * directly in the URL), and returns the Promise.
+ *
+ * @method   ajax
+ * @global
+ * @memberof bbn.fn
+ * @example
+ * ```javascript
+ * // Promise
+ * bbn.fn.ajax(
+ *   'my/location',
+ *   'json',
+ *   {id: 7},
+ *   d => {
+ *     console.log(d);
+ *     alert("Success!");
+ *   },
+ *   err => {
+ *     console.log(err);
+ *     alert("Failure!");
+ *   },
+ *   () => {
+ *     alert("Request aborted!");
+ *   }
+ * )
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Promise
+ * bbn.fn.ajax('my/location')
+ *   .then(
+ *     d => {
+ *       console.log(d);
+ *       alert("Success!");
+ *     }
+ *   )
+ *   .catch(
+ *     err => {
+ *     }
+ *   )
+ * ```
+ *
+ * @param    {String}   url      The URL to be requested by XHR
+ * @param    {String}   datatype The type of data expected
+ * @param    {Object}   data     The data to send through POST
+ * @param    {Function} success  The function to execute if the request goes well (200)
+ * @param    {Function} failure  The function to execute if the request goes bad
+ * @param    {Function} abort    The function to execute if the request is aborted
+ *
+ * @returns  {Promise}  The Promise created by the generated XHR.
+ */
+declare const ajax: (url: any, datatype: string, data: any, success?: (data: object, headers?: object) => any, failure?: (url: string, o?: object) => any, abort?: (message: string, url: string) => any) => any;
+export { ajax };

package/dist/fn/ajax/ajax.js

@@ -0,0 +1,170 @@
+import { isObject } from '../type/isObject';
+import { replaceAll } from '../string/replaceAll';
+import { getRequestId } from './getRequestId';
+import { getLoader } from './getLoader';
+import { extend } from '../object/extend';
+import { numProperties } from '../object/numProperties';
+import { _deleteLoader } from './_deleteLoader';
+import { defaultEndLoadingFunction } from '../default/defaultEndLoadingFunction';
+import { isFunction } from '../type/isFunction';
+import { defaultAjaxErrorFunction } from '../default/defaultAjaxErrorFunction';
+import { defaultAjaxAbortFunction } from '../default/defaultAjaxAbortFunction';
+import { _addLoader } from './_addLoader';
+import { defaultStartLoadingFunction } from '../default/defaultStartLoadingFunction';
+/**
+ * Creates an XHR object and returns the Promise.
+ *
+ * Checks the URL, makes an ID, creates a loader, sets the general callbacks,
+ * makes a POST if data is given a GET otherwise (GET data should be added
+ * directly in the URL), and returns the Promise.
+ *
+ * @method   ajax
+ * @global
+ * @memberof bbn.fn
+ * @example
+ * ```javascript
+ * // Promise
+ * bbn.fn.ajax(
+ *   'my/location',
+ *   'json',
+ *   {id: 7},
+ *   d => {
+ *     console.log(d);
+ *     alert("Success!");
+ *   },
+ *   err => {
+ *     console.log(err);
+ *     alert("Failure!");
+ *   },
+ *   () => {
+ *     alert("Request aborted!");
+ *   }
+ * )
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Promise
+ * bbn.fn.ajax('my/location')
+ *   .then(
+ *     d => {
+ *       console.log(d);
+ *       alert("Success!");
+ *     }
+ *   )
+ *   .catch(
+ *     err => {
+ *     }
+ *   )
+ * ```
+ *
+ * @param    {String}   url      The URL to be requested by XHR
+ * @param    {String}   datatype The type of data expected
+ * @param    {Object}   data     The data to send through POST
+ * @param    {Function} success  The function to execute if the request goes well (200)
+ * @param    {Function} failure  The function to execute if the request goes bad
+ * @param    {Function} abort    The function to execute if the request is aborted
+ *
+ * @returns  {Promise}  The Promise created by the generated XHR.
+ */
+const ajax = function (url, datatype, data, success, failure, abort) {
+    if (arguments.length === 1 && url && typeof url === 'object' && url.url) {
+        if (url.abort) {
+            abort = url.abort;
+        }
+        if (url.failure) {
+            failure = url.failure;
+        }
+        if (url.success) {
+            success = url.success;
+        }
+        if (url.data) {
+            data = url.data;
+        }
+        if (url.datatype) {
+            datatype = url.datatype;
+        }
+        url = url.url;
+    }
+    if (!url) {
+        return;
+    }
+    if (url && typeof url === 'string') {
+        if (url.indexOf('://') === -1) {
+            // Prevent protocol mismatch by Axios
+            url = replaceAll('//', '/', url);
+        }
+        if (!datatype) {
+            datatype = 'json';
+        }
+        let requestId = getRequestId(url, data, datatype);
+        let loaderObj = getLoader(requestId);
+        //log("IN AJAX", loaderObj? loaderObj.loader : "NO LOADER")
+        if (loaderObj?.loader) {
+            return loaderObj.loader;
+        }
+        if (bbn.env.token) {
+            extend(data || {}, { _bbn_token: bbn.env.token });
+        }
+        let cancelToken = axios.CancelToken;
+        let source = cancelToken.source();
+        let options = {
+            responseType: datatype,
+            cancelToken: source.token,
+        };
+        if (datatype === 'text') {
+            options.headers = {
+                accept: 'text/javascript',
+                'Content-Type': 'text/javascript',
+            };
+        }
+        let args = [url];
+        if (isObject(data) && numProperties(data) > 0) {
+            args.push(data);
+        }
+        args.push(options);
+        const axiosMethod = args.length === 2 ? 'get' : 'post';
+        let loader = axios[axiosMethod].apply(null, args)
+            .then(res => {
+            _deleteLoader(requestId, res);
+            defaultEndLoadingFunction(url, tst, data, res);
+            switch (res.status) {
+                case 200:
+                    if (isFunction(success)) {
+                        success(res.data, res.headers);
+                    }
+                    break;
+                default:
+                    defaultAjaxErrorFunction(loader, res);
+            }
+            return res;
+        })
+            .catch((err) => {
+            let isAbort = axios.isCancel(err);
+            _deleteLoader(requestId, err.message || err.response.data, isAbort);
+            defaultEndLoadingFunction(url, tst, data, err);
+            if (isAbort) {
+                let ok = 1;
+                if (isFunction(abort)) {
+                    ok = abort(err.message, url);
+                }
+                if (ok) {
+                    defaultAjaxAbortFunction(err.message, url);
+                }
+            }
+            else {
+                let ok = 1;
+                if (isFunction(failure)) {
+                    ok = failure(err.request, err);
+                }
+                if (ok) {
+                    defaultAjaxErrorFunction(err.request, err.response ? err.response.data : '', err.response ? err.response.status : err);
+                }
+            }
+        });
+        let tst = _addLoader(requestId, loader, source);
+        defaultStartLoadingFunction(url, tst, data, requestId);
+        return loader;
+    }
+};
+export { ajax };

package/dist/fn/ajax/callback.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Executes a serie of predefined actions once an Ajax request has been done.
+ *
+ * Used to treat all the requests functions results, it expects at least url and res to be defined;
+ * The following properties from the object res have direct effects:
+ * - __url__ {String}: if not given it will be automatically defined by the url parameter;
+ *   __the given URL will be passed to location.href (without reloading)__
+ * - __prescript__ {String}: if defined it will attempt to evaluate the code contained in the property
+ * - __content__ {String}: if defined and ele is defined too, the string will be inserted as content in the element
+ * - __script__ {String}: if defined it will be evaluated, executed, and its result will be returned
+ * - __data__ {Object}:
+ * - __postscript__ {String}: if defined it will be evaluated and executed
+ * - __error__ {String}: if defined it will be trigger bbn.fn.defaultAlertFunction
+ *
+ * If fn is defined it will be executed after prescript, otherwise it will be bbn.fn.defaultLinkFunction.
+ *
+ * The rest of the function comes executed if either of these results is not empty.
+ *
+ * If fn2 is defined it will be executed after script, otherwise it will be bbn.fn.defaultPostLinkFunction.
+ *
+ * Although not private this function should only be used internally.
+ *
+ * @method   callback
+ * @todo     Add method description for callback
+ * @global
+ * @memberof bbn.fn
+ *
+ * @param    {String}      url The URL that has been called
+ * @param    {Object}      res The object returned by the request
+ * @param    {Function}    fn  A first callback function to execute
+ * @param    {Function}    fn2 A second callback function to execute
+ * @param    {HTMLElement} ele A DOM element where the content will be inserted
+ *
+ * @returns  {*} The result of the main callback function: res.script, fn, or bbn.fn.defaultLinkFunction
+ */
+declare const callback: (url: string, res?: BbnAjaxResult, fn?: (a: BbnAjaxResult, b?: HTMLElement) => any, fn2?: (a: BbnAjaxResult) => any, ele?: HTMLElement | HTMLInputElement | HTMLTextAreaElement) => boolean;
+export { callback };

package/dist/fn/ajax/callback.js

@@ -0,0 +1,117 @@
+import { error } from '../browser/error';
+import { defaultLinkFunction } from '../default/defaultLinkFunction';
+import { isFunction } from '../type/isFunction';
+import { log } from '../browser/log';
+import { defaultPostLinkFunction } from '../default/defaultPostLinkFunction';
+import { defaultAlertFunction } from '../default/defaultAlertFunction';
+/**
+ * Executes a serie of predefined actions once an Ajax request has been done.
+ *
+ * Used to treat all the requests functions results, it expects at least url and res to be defined;
+ * The following properties from the object res have direct effects:
+ * - __url__ {String}: if not given it will be automatically defined by the url parameter;
+ *   __the given URL will be passed to location.href (without reloading)__
+ * - __prescript__ {String}: if defined it will attempt to evaluate the code contained in the property
+ * - __content__ {String}: if defined and ele is defined too, the string will be inserted as content in the element
+ * - __script__ {String}: if defined it will be evaluated, executed, and its result will be returned
+ * - __data__ {Object}:
+ * - __postscript__ {String}: if defined it will be evaluated and executed
+ * - __error__ {String}: if defined it will be trigger bbn.fn.defaultAlertFunction
+ *
+ * If fn is defined it will be executed after prescript, otherwise it will be bbn.fn.defaultLinkFunction.
+ *
+ * The rest of the function comes executed if either of these results is not empty.
+ *
+ * If fn2 is defined it will be executed after script, otherwise it will be bbn.fn.defaultPostLinkFunction.
+ *
+ * Although not private this function should only be used internally.
+ *
+ * @method   callback
+ * @todo     Add method description for callback
+ * @global
+ * @memberof bbn.fn
+ *
+ * @param    {String}      url The URL that has been called
+ * @param    {Object}      res The object returned by the request
+ * @param    {Function}    fn  A first callback function to execute
+ * @param    {Function}    fn2 A second callback function to execute
+ * @param    {HTMLElement} ele A DOM element where the content will be inserted
+ *
+ * @returns  {*} The result of the main callback function: res.script, fn, or bbn.fn.defaultLinkFunction
+ */
+const callback = function (url, res = null, fn = null, fn2 = null, ele = null) {
+    let tmp = false;
+    if (res) {
+        tmp = true;
+        let t = typeof res;
+        let isObj = t.toLowerCase() === 'object';
+        let errTitle;
+        if (isObj && res.prescript) {
+            /* var ok can be changed to false in prescript execution */
+            try {
+                eval(res.prescript);
+            }
+            catch (e) {
+                error(e.message || '');
+            }
+        }
+        if (isObj && res.url === undefined) {
+            res.url = url;
+        }
+        /* Case where a callback is defined */
+        if (fn) {
+            tmp = fn(res, ele);
+        }
+        else {
+            tmp = defaultLinkFunction(res, ele);
+        }
+        if (ele && isObj && (res.content !== undefined)) {
+            if ('value' in ele) {
+                ele.value = res.content;
+            }
+            else {
+                ele.innerHTML = res.content;
+            }
+        }
+        if (tmp && isObj && res.script) {
+            if (typeof (res.script) === 'function') {
+                tmp = res.script(res.data ? res.data : {}, ele || null);
+            }
+            else {
+                tmp = ((data, ele) => {
+                    let r = null;
+                    try {
+                        r = eval(res.script);
+                        if (isFunction(r)) {
+                            r = r(data, ele);
+                        }
+                    }
+                    catch (e) {
+                        log(e, res);
+                        error(isFunction(e.getMessage) ? e.getMessage() : null);
+                    }
+                    return r;
+                })(res.data ? res.data : {}, ele ? ele : false);
+            }
+        }
+        /* Case where a callback is defined */
+        if (tmp && fn2) {
+            fn2(res);
+        }
+        else if (isObj && defaultPostLinkFunction) {
+            defaultPostLinkFunction(res, ele);
+        }
+        if (tmp && isObj && res.postscript) {
+            eval(res.postscript);
+        }
+        if (isObj && res.error) {
+            errTitle = res.errorTitle || bbn.lng.server_response;
+            defaultAlertFunction(res.error, errTitle);
+        }
+    }
+    else {
+        defaultAlertFunction(bbn.lng.errorText, bbn.lng.error);
+    }
+    return tmp;
+};
+export { callback };

package/dist/fn/ajax/download.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Downloads a file with given filename from a URL.
+ *
+ * Gets the file's content as Blob through XHR, then sends it to bbn.fn.downloadContent.
+ * __Attention__ The CORS policy applies
+ *
+ * @method   download
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * // Forcing the download of an image
+ * bbn.fn.download('/bbn/js-title-black.png');
+ *
+ * // Forcing the download of a PDF
+ * bbn.fn.download('/files/my-document.pdf');
+ *
+ * // Changing the name as it is downloaded
+ * bbn.fn.download('/files/f4b1092d71aefd96458feaa71d170f69.pdf', 'myDocument_' + bbn.fn.dateSQL() + '.pdf');
+ * ```
+ *
+ * @param    {String} url      The URL from which the file will be requested
+ * @param    {String} filename The name for the downloaded file (otherwise it will take the basename of the url)
+ * @param    {Object} params   A data object to send with the request
+ *
+ * @returns  {undefined}
+ */
+declare const download: (url: string, filename?: string | object, params?: object) => any;
+export { download };