@bbn/bbn 1.0.12 → 1.0.13

package/dist/fn/_addLoader.d.ts

@@ -0,0 +1,2 @@
+declare const _addLoader: (requestId: any, prom: any, source: any) => number;
+export { _addLoader };

package/dist/fn/_addLoader.js

@@ -0,0 +1,29 @@
+import { bbn } from '../definitions';
+import { substr } from './substr';
+const _addLoader = function (requestId, prom, source) {
+    let tst = new Date().getTime();
+    let url = substr(requestId, 0, requestId.length - 33);
+    let loader = {
+        key: requestId,
+        url: url,
+        loader: prom,
+        source: source,
+        loading: true,
+        error: false,
+        abort: false,
+        errorMessage: false,
+        success: false,
+        start: tst,
+    };
+    bbn.env.loaders.push(loader);
+    bbn.env.loadersHistory.unshift(loader);
+    let idx = bbn.env.loadersHistory.length;
+    while (idx && bbn.env.loadersHistory.length > bbn.env.maxLoadersHistory) {
+        idx--;
+        if (!bbn.env.loadersHistory.loading) {
+            bbn.env.loadersHistory.splice(idx, 1);
+        }
+    }
+    return tst;
+};
+export { _addLoader };

package/dist/fn/_compareValues.d.ts

@@ -0,0 +1,2 @@
+declare const _compareValues: (a: any, b: any, prop: any, dir?: string) => 0 | 1 | -1;
+export { _compareValues };

package/dist/fn/_compareValues.js

@@ -0,0 +1,40 @@
+import { getProperty } from './getProperty';
+import { isString } from './isString';
+import { removeAccents } from './removeAccents';
+import { isDate } from './isDate';
+const _compareValues = function (a, b, prop, dir = 'asc') {
+    let va = getProperty(a, prop), vb = getProperty(b, prop), ta = (typeof va).toLowerCase(), tb = (typeof vb).toLowerCase();
+    if (dir !== 'asc' && isString(dir) && dir.toLowerCase() === 'desc') {
+        dir = 'desc';
+    }
+    if (ta !== tb) {
+        va = ta;
+        vb = tb;
+    }
+    else {
+        switch (ta) {
+            case 'string':
+                va = removeAccents(va).toLowerCase();
+                vb = removeAccents(vb).toLowerCase();
+                break;
+            case 'boolean':
+                va = va ? 1 : 0;
+                vb = vb ? 1 : 0;
+                break;
+            case 'object':
+                if (isDate(va)) {
+                    va = va.getTime();
+                    vb = isDate(vb) ? vb.getTime() : 0;
+                }
+                break;
+        }
+    }
+    if (va < vb) {
+        return dir === 'desc' ? 1 : -1;
+    }
+    if (va > vb) {
+        return dir === 'desc' ? -1 : 1;
+    }
+    return 0;
+};
+export { _compareValues };

package/dist/fn/_deleteLoader.d.ts

@@ -0,0 +1,2 @@
+declare const _deleteLoader: (requestId: any, res: any, isAbort: any) => boolean;
+export { _deleteLoader };

package/dist/fn/_deleteLoader.js

@@ -0,0 +1,26 @@
+import { bbn } from '../definitions';
+import { search } from './search';
+import { getRow } from './getRow';
+import { isObject } from './isObject';
+const _deleteLoader = function (requestId, res, isAbort) {
+    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/abort.d.ts

@@ -0,0 +1,2 @@
+declare const abort: (requestId: any) => void;
+export { abort };

package/dist/fn/abort.js

@@ -0,0 +1,5 @@
+import { getLoader } from './getLoader';
+const abort = function (requestId) { let loader = getLoader(requestId); if (loader && loader.source) {
+    loader.source.cancel('Operation canceled by the user.');
+} };
+export { abort };

package/dist/fn/abortURL.d.ts

@@ -0,0 +1,2 @@
+declare const abortURL: (url: any) => void;
+export { abortURL };

package/dist/fn/abortURL.js

@@ -0,0 +1,14 @@
+import { bbn } from '../definitions';
+import { each } from './each';
+import { filter } from './filter';
+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/addColors.d.ts

@@ -0,0 +1,2 @@
+declare const addColors: (colors: any) => void;
+export { addColors };

package/dist/fn/addColors.js

@@ -0,0 +1,17 @@
+import { bbn } from '../definitions';
+import { numProperties } from './numProperties';
+import { iterate } from './iterate';
+const addColors = function (colors) {
+    let st = '';
+    if (numProperties(colors)) {
+        if (!bbn.var.colors) {
+            bbn.var.colors = {};
+        }
+        let element = document.createElement('style');
+        document.head.appendChild(element);
+        let sheet = element.sheet;
+        let i = 0;
+        iterate(colors, (v, n) => { bbn.var.colors[n] = v; sheet.insertRule('.bbn-' + n + ', .bbn-color-text-' + n + ' {color: ' + v + ' !important;}', i); sheet.insertRule('svg.bbn-' + n + ', .bbn-' + n + ' svg, svg.bbn-color-text-' + n + ', .bbn-color-text-' + n + ' svg {fill: ' + v + ';}', i); sheet.insertRule('.bbn-bg-' + n + ', .bbn-color-bg-' + n + ', .bbn-color-background-' + n + ' {background-color: ' + v + ' !important;}', i); sheet.insertRule('.bbn-border-' + n + ', .bbn-color-border-' + n + ' {border-color: ' + v + ' !important;}', i); sheet.insertRule('.bbn-color-' + n + ' {border-color: ' + v + '; background-color: ' + v + '; color: ' + v + ';}', i); });
+    }
+};
+export { addColors };

package/dist/fn/addInputs.d.ts

@@ -0,0 +1,3 @@
+import { addInputs } from './addInputs';
+declare const addInputs: (form: any, params: any, prefix: any) => void;
+export { addInputs };

package/dist/fn/addInputs.js

@@ -0,0 +1,34 @@
+import { iterate } from './iterate';
+const addInputs = function (form, params, prefix) {
+    if (form && (form.tagName === 'FORM')) {
+        let appendToForm = (name, val) => { let input = document.createElement('input'); input.setAttribute('type', 'hidden'); input.setAttribute('name', name); input.setAttribute('value', val); form.appendChild(input); };
+        params = JSON.parse(JSON.stringify(params || {}));
+        prefix = prefix || '';
+        if (params) {
+            iterate(params, (param, key) => {
+                let name = prefix ? `${prefix}[${key}]` : key;
+                if (param instanceof Date) {
+                    appendToForm(form, name, param.toISOString());
+                }
+                else if (param instanceof Array) {
+                    param.forEach((e, i) => {
+                        const tempName = `${name}[${i}]`;
+                        if (typeof e === 'object') {
+                            addInputs(form, e, tempName);
+                        }
+                        else {
+                            appendToForm(tempName, e.toString());
+                        }
+                    });
+                }
+                else if ((typeof param === 'object') && !(param instanceof File)) {
+                    addInputs(form, param, name);
+                }
+                else {
+                    appendToForm(name, param.toString());
+                }
+            });
+        }
+    }
+};
+export { addInputs };

package/dist/fn/addStyle.d.ts

@@ -0,0 +1,2 @@
+declare const addStyle: (ele: any, o: any) => void;
+export { addStyle };

package/dist/fn/addStyle.js

@@ -0,0 +1,6 @@
+import { isObject } from './isObject';
+import { iterate } from './iterate';
+const addStyle = function (ele, o) { if (isObject(o)) {
+    iterate(o, (v, k) => { ele.style[k] = v; });
+} };
+export { addStyle };

package/dist/fn/adjustHeight.d.ts

@@ -0,0 +1,2 @@
+declare const adjustHeight: () => void;
+export { adjustHeight };

package/dist/fn/adjustHeight.js

@@ -0,0 +1,10 @@
+import { isIterable } from './isIterable';
+import { adjustSize } from './adjustSize';
+const adjustHeight = function () {
+    let args = arguments;
+    if ((args.length === 1) && isIterable(args[0])) {
+        args = args[0];
+    }
+    return adjustSize('height', args);
+};
+export { adjustHeight };

package/dist/fn/adjustSize.d.ts

@@ -0,0 +1,2 @@
+declare const adjustSize: (type: any, eles: any) => void;
+export { adjustSize };

package/dist/fn/adjustSize.js

@@ -0,0 +1,8 @@
+import { each } from './each';
+const adjustSize = function (type, eles) { let max = 0, idx; each(eles, (el) => { el.style[type] = 'auto'; }); each(eles, (el, i) => { let rect = el.getBoundingClientRect(), s = rect[type] % 1 ? (rect[type] - (rect[type] % 1) + 1) : rect[type]; if (s > max) {
+    max = s;
+    idx = i;
+} }); each(eles, (el, i) => { if (max) {
+    el.style[type] = max + 'px';
+} }); };
+export { adjustSize };

package/dist/fn/adjustWidth.d.ts

@@ -0,0 +1,2 @@
+declare const adjustWidth: () => void;
+export { adjustWidth };

package/dist/fn/adjustWidth.js

@@ -0,0 +1,10 @@
+import { isIterable } from './isIterable';
+import { adjustSize } from './adjustSize';
+const adjustWidth = function () {
+    let args = arguments;
+    if ((args.length === 1) && isIterable(args[0])) {
+        args = args[0];
+    }
+    return adjustSize('width', args);
+};
+export { adjustWidth };

package/dist/fn/ajax.d.ts

@@ -0,0 +1,2 @@
+declare const ajax: (url: any, datatype: any, data: any, success: any, failure: any, abort: any) => any;
+export { ajax };

package/dist/fn/ajax.js

@@ -0,0 +1,103 @@
+import { bbn } from '../definitions';
+import { isObject } from './isObject';
+import { replaceAll } from './replaceAll';
+import { getRequestId } from './getRequestId';
+import { getLoader } from './getLoader';
+import { extend } from './extend';
+import { numProperties } from './numProperties';
+import { _deleteLoader } from './_deleteLoader';
+import { defaultEndLoadingFunction } from './defaultEndLoadingFunction';
+import { isFunction } from './isFunction';
+import { defaultAjaxErrorFunction } from './defaultAjaxErrorFunction';
+import { defaultAjaxAbortFunction } from './defaultAjaxAbortFunction';
+import { _addLoader } from './_addLoader';
+import { defaultStartLoadingFunction } from './defaultStartLoadingFunction';
+const ajax = function (url, datatype, data, success, failure, abort) {
+    if ((arguments.length === 1) && isObject(url) && 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) {
+        if (url.indexOf('://') === -1) {
+            url = replaceAll("//", "/", url);
+        }
+        if (!datatype) {
+            datatype = 'json';
+        }
+        let requestId = getRequestId(url, data, datatype);
+        let loaderObj = getLoader(requestId);
+        if (loaderObj && 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);
+        let loader = axios[args.length === 2 ? 'get' : 'post'].apply(axios, 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/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 };

package/dist/fn/analyzeFunction.js

@@ -0,0 +1,132 @@
+import { md5 } from './md5';
+const analyzeFunction = function (fn) {
+    const functionString = fn.toString();
+    let all = functionString.split('');
+    let exp = '';
+    let isArrow = false;
+    let isAsync = false;
+    let hasFunction = false;
+    let name = null;
+    let parOpened = 0;
+    let parClosed = 0;
+    let args = [];
+    let currentArg = {};
+    let body;
+    let currentQuote = '';
+    let escapable = ['"', "'", '`'];
+    let isEscaped = false;
+    let settingDefault = false;
+    for (let i = 0; i < all.length; i++) {
+        if ((all[i] === currentQuote) && !isEscaped && currentQuote) {
+            currentQuote = '';
+            exp += all[i];
+        }
+        else if (currentQuote) {
+            exp += all[i];
+        }
+        else if (escapable.includes(all[i]) && !isEscaped) {
+            currentQuote = all[i];
+            exp += all[i];
+        }
+        else if (all[i] === '(') {
+            parOpened++;
+            if (exp.trim() !== '') {
+                if (exp.trim() === 'function') {
+                    hasFunction = true;
+                }
+                if (exp.trim() !== 'async') {
+                    name = exp.trim();
+                }
+                exp = '';
+            }
+        }
+        else if (all[i] === ')') {
+            if (parOpened === parClosed + 1) {
+                if (settingDefault) {
+                    currentArg.default = exp.trim();
+                    settingDefault = false;
+                }
+                else if (exp) {
+                    currentArg.name = exp.trim();
+                }
+                if (currentArg.name || currentArg.default) {
+                    args.push(currentArg);
+                    currentArg = {};
+                }
+                exp = '';
+            }
+            parClosed++;
+        }
+        else if (all[i] === '=') {
+            if (functionString.substr(i, 2) === '=>') {
+                if (exp.trim() !== "" && parOpened === parClosed) {
+                    currentArg.name = exp.trim();
+                    args.push(currentArg);
+                    currentArg = {};
+                    exp = '';
+                }
+                isArrow = true;
+                i++;
+                continue;
+            }
+            else if (parOpened > parClosed && !settingDefault) {
+                currentArg.name = exp.trim();
+                exp = '';
+                settingDefault = true;
+            }
+            else {
+                exp += all[i];
+            }
+        }
+        else if (all[i] === ',') {
+            if (parOpened > parClosed) {
+                if (settingDefault) {
+                    currentArg.default = exp.trim();
+                    settingDefault = false;
+                }
+                else if (exp) {
+                    currentArg.name = exp.trim();
+                }
+                if (currentArg.name || currentArg.default) {
+                    args.push(currentArg);
+                    currentArg = {};
+                }
+                exp = '';
+            }
+            else {
+                throw Error("Unexpected ',' while parsing function");
+            }
+        }
+        else if (all[i] === '{' || all[i] === '}') {
+            body = functionString.substring(i).trim();
+            break;
+        }
+        else if (isArrow) {
+            body = functionString.substring(functionString.indexOf('=>') + 2).trim();
+            break;
+        }
+        else if (all[i] === ' ') {
+            if (exp.trim() !== '') {
+                if (exp.trim() === 'async') {
+                    isAsync = true;
+                    exp = '';
+                }
+            }
+        }
+        else {
+            exp += all[i];
+        }
+    }
+    if (!body) {
+        if (isArrow) {
+            body = exp;
+        }
+        else {
+            throw Error("Unexpected end of function while parsing function");
+        }
+    }
+    const argString = args.map(arg => arg.name + (arg.default ? ' = ' + arg.default : '')).join(', ');
+    const hash = md5(body + (name ? '-' + name : '') + (argString ? '-' + argString : ''));
+    return { body, args, argString, isArrow, hasFunction, name, isAsync, hash };
+};
+export { analyzeFunction };

package/dist/fn/animateCss.d.ts

@@ -0,0 +1,2 @@
+declare const animateCss: (ele: any, animationName: any, callback: any) => void;
+export { animateCss };

package/dist/fn/animateCss.js

@@ -0,0 +1,13 @@
+const animateCss = function (ele, animationName, callback) {
+    let animationEnd = 'webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend';
+    ele.classList.add('animated');
+    ele.classList.add(animationName);
+    ele.addEventListener(animationEnd, (e) => {
+        e.target.removeEventListener(e.type, arguments.callee);
+        if (typeof callback == 'function') {
+            callback.call(this);
+        }
+        this.classList.remove(animation);
+    });
+};
+export { animateCss };

package/dist/fn/arrayBuffer2String.d.ts

@@ -0,0 +1,2 @@
+declare const arrayBuffer2String: (buf: any) => any;
+export { arrayBuffer2String };

package/dist/fn/arrayBuffer2String.js

@@ -0,0 +1,2 @@
+const arrayBuffer2String = function (buf) { return String.fromCharCode.apply(null, new Uint16Array(buf)); };
+export { arrayBuffer2String };

package/dist/fn/arrayFromProp.d.ts

@@ -0,0 +1,2 @@
+declare const arrayFromProp: (arr: any, prop: any) => any[];
+export { arrayFromProp };

package/dist/fn/arrayFromProp.js

@@ -0,0 +1,4 @@
+import { each } from './each';
+import { getProperty } from './getProperty';
+const arrayFromProp = function (arr, prop) { let r = []; each(arr, (a, i) => { r.push(getProperty(a, prop)); }); return r; };
+export { arrayFromProp };

package/dist/fn/autoExtend.d.ts

@@ -0,0 +1,2 @@
+declare const autoExtend: (namespace: any, obj: any) => void;
+export { autoExtend };

package/dist/fn/autoExtend.js

@@ -0,0 +1,12 @@
+import { bbn } from '../definitions';
+import { extend } from './extend';
+const autoExtend = function (namespace, obj) {
+    if (!bbn[namespace]) {
+        bbn[namespace] = {};
+        extend(bbn[namespace], obj);
+    }
+    else {
+        extend(bbn[namespace], obj);
+    }
+};
+export { autoExtend };

package/dist/fn/baseName.d.ts

@@ -0,0 +1,2 @@
+declare const baseName: (path: any, suffix: any) => any;
+export { baseName };

package/dist/fn/baseName.js

@@ -0,0 +1,17 @@
+import { isString } from './isString';
+import { substr } from './substr';
+const baseName = function (path, suffix) {
+    if (path && isString(path)) {
+        let bits = path.split("/");
+        let res = bits.pop();
+        if (!suffix) {
+            return res;
+        }
+        let len = suffix.length;
+        if (res && substr(res, -len) === suffix) {
+            return substr(res, 0, res.length - len);
+        }
+    }
+    return '';
+};
+export { baseName };

package/dist/fn/br2nl.d.ts

@@ -0,0 +1,2 @@
+declare const br2nl: (st: any) => any;
+export { br2nl };

package/dist/fn/br2nl.js

@@ -0,0 +1,3 @@
+import { replaceAll } from './replaceAll';
+const br2nl = function (st) { return replaceAll("<br />", "\n", replaceAll("<br/>", "\n", replaceAll("<br>", "\n", st))); };
+export { br2nl };

package/dist/fn/calendar.d.ts

@@ -0,0 +1,2 @@
+declare const calendar: (d: any, wrong_result: any) => any;
+export { calendar };

package/dist/fn/calendar.js

@@ -0,0 +1,16 @@
+import { bbn } from '../definitions';
+import { fdate } from './fdate';
+import { date } from './date';
+import { isDate } from './isDate';
+import { isString } from './isString';
+const calendar = function (d, wrong_result) {
+    if (undefined === dayjs) {
+        return fdate(d, wrong_result);
+    }
+    let r = date(d);
+    if (!isDate(r)) {
+        return wrong_result && isString(wrong_result) ? wrong_result : '';
+    }
+    return dayjs(r).calendar(null, { sameDay: '[' + bbn._('Today') + ']', nextDay: '[' + bbn._('Tomorrow') + ']', nextWeek: 'ddd D', lastDay: '[' + bbn._('Yesterday') + ']', lastWeek: 'ddd D', sameElse: 'L' });
+};
+export { calendar };

package/dist/fn/callback.d.ts

@@ -0,0 +1,2 @@
+declare const callback: (url: any, res: any, fn: any, fn2: any, ele: any) => boolean;
+export { callback };