@bbn/bbn 1.0.12 → 1.0.13

package/dist/fn/callback.js

@@ -0,0 +1,81 @@
+import { bbn } from '../definitions';
+import { error } from './error';
+import { defaultLinkFunction } from './defaultLinkFunction';
+import { insertContent } from './insertContent';
+import { isFunction } from './isFunction';
+import { log } from './log';
+import { defaultPostLinkFunction } from './defaultPostLinkFunction';
+import { defaultAlertFunction } from './defaultAlertFunction';
+const callback = function (url, res, fn, fn2, ele) {
+    let tmp = false;
+    if (res) {
+        tmp = true;
+        let t = typeof res;
+        let isObj = t.toLowerCase() === 'object';
+        let errTitle;
+        if (isObj && res.prescript) {
+            try {
+                eval(res.prescript);
+            }
+            catch (e) {
+                error(e.message || '');
+            }
+        }
+        if (isObj && res.url === undefined) {
+            res.url = url;
+        }
+        if (fn) {
+            tmp = fn(res, ele);
+        }
+        else {
+            tmp = defaultLinkFunction(res, ele);
+        }
+        if (ele && isObj && (res.content !== undefined)) {
+            if (ele.is("input,textarea")) {
+                ele.val(res.content);
+            }
+            else {
+                insertContent(res.content, ele);
+            }
+        }
+        if (tmp && isObj && res.script) {
+            if (isFunction(res.script)) {
+                tmp = res.script(res.data ? res.data : {}, ele ? ele : false);
+            }
+            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);
+            }
+        }
+        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/camelToCss.d.ts

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

package/dist/fn/camelToCss.js

@@ -0,0 +1,2 @@
+const camelToCss = function (str) { return str.replace(/([A-Z])/g, function (st) { return '-' + st.toLowerCase(); }).replace('/^./', function (st) { return st.toLowerCase(); }); };
+export { camelToCss };

package/dist/fn/camelize.d.ts

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

package/dist/fn/camelize.js

@@ -0,0 +1,9 @@
+const camelize = function (str) {
+    return str.replace(/^([A-Z])|[\s-](\w)/g, function (match, p1, p2, offset) {
+        if (p2) {
+            return p2.toUpperCase();
+        }
+        return p1.toLowerCase();
+    });
+};
+export { camelize };

package/dist/fn/canvasToImage.d.ts

@@ -0,0 +1,2 @@
+declare const canvasToImage: (canvas: any) => HTMLImageElement;
+export { canvasToImage };

package/dist/fn/canvasToImage.js

@@ -0,0 +1,2 @@
+const canvasToImage = function (canvas) { let img = new Image(); img.src = canvas.toDataURL("image/png"); return img; };
+export { canvasToImage };

package/dist/fn/center.d.ts

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

package/dist/fn/center.js

@@ -0,0 +1,15 @@
+import { log } from './log';
+const center = function (ele) {
+    let parent = ele.parentNode, w = parent.clientWidth, h = parent.clientHeight;
+    while (parent && (!w || !h)) {
+        parent = ele.parentNode;
+        w = parent.clientWidth;
+        h = parent.clientHeight;
+    }
+    log("BBN_CENTER", w, h);
+    ele.style.position = "absolute";
+    ele.style.top = Math.max(0, ((h - ele.offsetHeight) / 2) + parent.scrollTop) + "px";
+    ele.style.left = Math.max(0, ((h - ele.offsetWidth) / 2) + parent.scrollLeft) + "px";
+    return ele;
+};
+export { center };

package/dist/fn/checkProps.d.ts

@@ -0,0 +1,2 @@
+declare const checkProps: (obj: any, props: any, checkEmpty: any) => boolean;
+export { checkProps };

package/dist/fn/checkProps.js

@@ -0,0 +1,3 @@
+import { checkPropsDetails } from './checkPropsDetails';
+const checkProps = function (obj, props, checkEmpty) { return checkPropsDetails(obj, props, checkEmpty).result; };
+export { checkProps };

package/dist/fn/checkPropsDetails.d.ts

@@ -0,0 +1,5 @@
+declare const checkPropsDetails: (obj: any, props: any, checkEmpty: any) => {
+    error: boolean;
+    result: boolean;
+};
+export { checkPropsDetails };

package/dist/fn/checkPropsDetails.js

@@ -0,0 +1,49 @@
+import { bbn } from '../definitions';
+import { isString } from './isString';
+import { isArray } from './isArray';
+import { isObject } from './isObject';
+import { each } from './each';
+import { substr } from './substr';
+const checkPropsDetails = function (obj, props, checkEmpty) {
+    let res = { error: false, result: true };
+    if (isString(props)) {
+        props = [props];
+    }
+    if (!isArray(props)) {
+        res.error = bbn._("checkProps must receive a string or an array as props argument");
+    }
+    if (!isObject(obj)) {
+        res.error = bbn._("checkProps must receive an object as obj argument");
+    }
+    if (!res.error) {
+        let check;
+        each(props, varName => {
+            varName = varName.trim().split(':');
+            let type = varName[1] || false;
+            varName = varName[0];
+            if (obj[varName] === undefined) {
+                res.error = varName + ' ' + bbn._("is not defined");
+            }
+            else if (type) {
+                check = 'is' + substr(type, 0, 1).toUpperCase() + substr(type, 1).toLowerCase();
+                if (bbn.fn[check] === undefined) {
+                    res.error = type + ' ' + bbn._("is not a valid type");
+                }
+                else if (!bbn.fn[check](obj[varName])) {
+                    res.error = varName + ' ' + bbn._("is not a") + ' ' + type;
+                }
+            }
+            else if (checkEmpty && !obj[varName]) {
+                res.error = varName + ' ' + bbn._("is empty");
+            }
+            if (res.error) {
+                return false;
+            }
+        });
+    }
+    if (res.error) {
+        res.result = false;
+    }
+    return res;
+};
+export { checkPropsDetails };

package/dist/fn/checkPropsOrDie.d.ts

@@ -0,0 +1,2 @@
+declare const checkPropsOrDie: (obj: any, props: any, checkEmpty: any) => boolean;
+export { checkPropsOrDie };

package/dist/fn/checkPropsOrDie.js

@@ -0,0 +1,9 @@
+import { checkPropsDetails } from './checkPropsDetails';
+const checkPropsOrDie = function (obj, props, checkEmpty) {
+    let res = checkPropsDetails(obj, props, checkEmpty);
+    if (res.error) {
+        throw new Error(res.error);
+    }
+    return true;
+};
+export { checkPropsOrDie };

package/dist/fn/checkType.d.ts

@@ -0,0 +1,2 @@
+declare const checkType: (value: any, type: any, msg: any, ...logs: any[]) => void;
+export { checkType };

package/dist/fn/checkType.js

@@ -0,0 +1,61 @@
+import { bbn } from '../definitions';
+import { isArray } from './isArray';
+import { each } from './each';
+import { isFunction } from './isFunction';
+import { isString } from './isString';
+import { correctCase } from './correctCase';
+import { error } from './error';
+import { log } from './log';
+const checkType = function (value, type, msg, ...logs) {
+    let ok = false;
+    if (!isArray(type)) {
+        type = [type];
+    }
+    const typesList = [];
+    each(type, t => {
+        var _a;
+        if (t === String) {
+            t = 'string';
+        }
+        else if (t === Number) {
+            t = 'number';
+        }
+        else if (t === Array) {
+            t = 'array';
+        }
+        else if (t === Boolean) {
+            t = 'boolean';
+        }
+        else if (t === Object) {
+            t = 'object';
+        }
+        else if (t === Function) {
+            t = 'function';
+        }
+        if (isFunction(t)) {
+            typesList.push(t.name || ((_a = t.constructor) === null || _a === void 0 ? void 0 : _a.name) || t.toString());
+            if (value instanceof t) {
+                ok = true;
+                return false;
+            }
+        }
+        else if (!isString(t) || !isFunction(bbn.fn['is' + correctCase(t)])) {
+            error(`The type ${t} is not recognized`);
+        }
+        else if (bbn.fn['is' + correctCase(t)](value)) {
+            ok = true;
+            return false;
+        }
+        else {
+            typesList.push(t);
+        }
+    });
+    if (!ok) {
+        log(["Value given", value, "type", typeof value, "expected", typesList.join(' or ')]);
+        if (logs.length) {
+            log(logs);
+        }
+        throw new Error((msg ? msg + ' - ' : '') + bbn._("The value should be a %s", typesList.join(' ' + bbn._("or a") + ' ')));
+    }
+};
+export { checkType };

package/dist/fn/circularReplacer.d.ts

@@ -0,0 +1,2 @@
+declare const circularReplacer: () => (key: any, value: any) => any;
+export { circularReplacer };

package/dist/fn/circularReplacer.js

@@ -0,0 +1,33 @@
+import { isDom } from './isDom';
+import { isCp } from './isCp';
+import { log } from './log';
+const circularReplacer = function () {
+    const visited = new WeakSet();
+    return (key, value) => {
+        if ((typeof value === "object") && (value !== null)) {
+            if (visited.has(value)) {
+                return;
+            }
+            visited.add(value);
+            if (![undefined, Object, Array, null].includes(value.constructor)) {
+                if (isDom(value)) {
+                    if (value.bbnId) {
+                        value = '__BBN_DOM__' + value.tagName + '/' + value.bbnId + value.bbnHash;
+                    }
+                    else {
+                        value = '__BBN_DOM__' + value.tagName + '/' + value.className;
+                    }
+                }
+                else if (isCp(value)) {
+                    log("IS CP");
+                    value = '__BBN_CP__' + value.$options.name + '/' + value.$cid;
+                }
+                else {
+                    value = value.constructor.toString();
+                }
+            }
+        }
+        return value;
+    };
+};
+export { circularReplacer };

package/dist/fn/clone.d.ts

@@ -0,0 +1,3 @@
+import { clone } from './clone';
+declare const clone: (obj: any) => any;
+export { clone };

package/dist/fn/clone.js

@@ -0,0 +1,14 @@
+import { isArray } from './isArray';
+import { isObject } from './isObject';
+import { extend } from './extend';
+const clone = function (obj) {
+    if (isArray(obj)) {
+        return obj.slice().map((a) => { return typeof (a) === 'object' ? clone(a) : a; });
+    }
+    if (isObject(obj)) {
+        const o = Object.create(Object.getPrototypeOf(obj));
+        return extend(true, o, obj);
+    }
+    return obj;
+};
+export { clone };

package/dist/fn/colorToHex.d.ts

@@ -0,0 +1,2 @@
+declare const colorToHex: (color: any) => string | CanvasGradient | CanvasPattern;
+export { colorToHex };

package/dist/fn/colorToHex.js

@@ -0,0 +1,2 @@
+const colorToHex = function (color) { let canvas = document.createElement("canvas").getContext("2d"); canvas.fillStyle = color; return canvas.fillStyle; };
+export { colorToHex };

package/dist/fn/compare.d.ts

@@ -0,0 +1,2 @@
+declare const compare: (v1: any, v2: any, operator: any) => boolean;
+export { compare };

package/dist/fn/compare.js

@@ -0,0 +1,86 @@
+import { isEmpty } from './isEmpty';
+import { removeAccents } from './removeAccents';
+import { isNull } from './isNull';
+import { isObject } from './isObject';
+import { isSame } from './isSame';
+const compare = function (v1, v2, operator) {
+    switch (operator) {
+        case "===":
+        case "=":
+        case "equal":
+        case "eq":
+        case "is": return v1 === v2;
+        case "!==":
+        case "notequal":
+        case "neq":
+        case "isnot": return v1 !== v2;
+        case "!=":
+        case "different": return v1 != v2;
+        case "contains":
+        case "contain":
+        case "icontains":
+        case "icontain":
+            if (isEmpty(v1) || isEmpty(v2)) {
+                return false;
+            }
+            return removeAccents(v1).toLowerCase().indexOf(removeAccents(v2).toLowerCase()) !== -1;
+        case "doesnotcontain":
+        case "donotcontain":
+            if (isNull(v1) || isNull(v2)) {
+                return true;
+            }
+            return removeAccents(v1.toLowerCase()).indexOf(removeAccents(v2.toLowerCase())) === -1;
+        case "starts":
+        case "start":
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            if ((typeof (v1) !== 'string')) {
+                v1 = v1.toString() || '';
+            }
+            if ((typeof (v2) !== 'string')) {
+                v2 = v2.toString() || '';
+            }
+            return v1.indexOf(v2) === 0;
+        case "startswith":
+        case "startsi":
+        case "starti":
+        case "istarts":
+        case "istart":
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            return removeAccents(v1).toLowerCase().indexOf(removeAccents(v2).toLowerCase()) === 0;
+        case "endswith":
+        case "endsi":
+        case "endi":
+        case "iends":
+        case "iend":
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            return v1.lastIndexOf(v2) === v1.length - v2.length;
+        case "like":
+            if (isNull(v1) || isNull(v2)) {
+                return false;
+            }
+            return removeAccents(v1).toLowerCase() === removeAccents(v2).toLowerCase();
+        case "gt":
+        case ">": return v1 > v2;
+        case "gte":
+        case ">=": return v1 >= v2;
+        case "lt":
+        case "<": return v1 < v2;
+        case "lte":
+        case "<=": return v1 <= v2;
+        case "isnull": return v1 === null;
+        case "isnotnull": return v1 !== null;
+        case "isempty": return v1 === '';
+        case "isnotempty": return v1 !== '';
+        case '==': if (isObject(v1, v2)) {
+            return isSame(v1, v2);
+        }
+        default: return v1 == v2;
+    }
+};
+export { compare };

package/dist/fn/compareConditions.d.ts

@@ -0,0 +1,3 @@
+import { compareConditions } from './compareConditions';
+declare const compareConditions: (data: any, filter: any) => boolean;
+export { compareConditions };

package/dist/fn/compareConditions.js

@@ -0,0 +1,40 @@
+import { isArray } from './isArray';
+import { each } from './each';
+import { getProperty } from './getProperty';
+const compareConditions = function (data, filter) {
+    if (!filter.conditions || !filter.logic || !isArray(filter.conditions)) {
+        throw new Error("Error in compareConditions: the filter should an abject with conditions and logic properties and conditions should be an array of objects");
+    }
+    let ok = filter.logic === 'AND' ? true : false;
+    each(filter.conditions, (a) => {
+        let compare;
+        if (a.conditions && isArray(a.conditions)) {
+            compare = compareConditions(data, a);
+        }
+        else {
+            compare = compare(getProperty(data, a.field), a.value, a.operator);
+            if (compare) {
+                let bits = a.field.split('.');
+                let prop = bits.pop();
+                if (bits.length) {
+                    each(bits, b => data = data[b]);
+                }
+                if ((getProperty(data, prop) === undefined) && (a.value !== undefined)) {
+                    compare = false;
+                }
+            }
+        }
+        if (compare) {
+            if (filter.logic === 'OR') {
+                ok = true;
+                return false;
+            }
+        }
+        else if (filter.logic === 'AND') {
+            ok = false;
+            return false;
+        }
+    });
+    return ok;
+};
+export { compareConditions };

package/dist/fn/copy.d.ts

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

package/dist/fn/copy.js

@@ -0,0 +1,31 @@
+import { isObject } from './isObject';
+import { isFunction } from './isFunction';
+const copy = function (st) {
+    return new Promise(resolve => {
+        if (st) {
+            if (navigator && navigator.clipboard) {
+                if (st instanceof Blob) {
+                    navigator.clipboard.write([new ClipboardItem({ [st.type.toString()]: st })]).then(() => { resolve(); });
+                }
+                else if (isObject(st) && isFunction(st.toBlob)) {
+                    st.toBlob(blob => { navigator.clipboard.write([new ClipboardItem({ [blob.type.toString()]: blob })]).then(() => { resolve(); }); });
+                }
+                else {
+                    navigator.clipboard.writeText(st);
+                    resolve();
+                }
+                return;
+            }
+            let input = document.createElement("textarea");
+            input.style.opacity = 0;
+            input.value = st;
+            document.body.appendChild(input);
+            input.select();
+            document.execCommand('copy');
+            document.body.removeChild(input);
+            resolve();
+        }
+        resolve();
+    });
+};
+export { copy };

package/dist/fn/correctCase.d.ts

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

package/dist/fn/correctCase.js

@@ -0,0 +1,2 @@
+const correctCase = function (str) { return str.replace(/[A-z]{1}/, c => c.toUpperCase()); };
+export { correctCase };

package/dist/fn/count.d.ts

@@ -0,0 +1,2 @@
+declare const count: (arr: any, prop: any, val: any, operator: any) => any;
+export { count };

package/dist/fn/count.js

@@ -0,0 +1,3 @@
+import { filter } from './filter';
+const count = function (arr, prop, val, operator) { return filter(arr, prop, val, operator, false).length || 0; };
+export { count };

package/dist/fn/crc32.d.ts

@@ -0,0 +1,2 @@
+declare const crc32: (str: any) => number;
+export { crc32 };

package/dist/fn/crc32.js

@@ -0,0 +1,9 @@
+const crc32 = function (str) {
+    let crc = 0 ^ (-1);
+    for (let i = 0; i < str.length; i++) {
+        const charCode = str.charCodeAt(i);
+        crc = (crc >>> 8) ^ crc32Table[(crc ^ charCode) & 0xFF];
+    }
+    return (crc ^ (-1)) >>> 0;
+};
+export { crc32 };

package/dist/fn/createObject.d.ts

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

package/dist/fn/createObject.js

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

package/dist/fn/cssExists.d.ts

@@ -0,0 +1,2 @@
+declare const cssExists: (f: any) => boolean;
+export { cssExists };

package/dist/fn/cssExists.js

@@ -0,0 +1,25 @@
+import { escapeRegExp } from './escapeRegExp';
+const cssExists = function (f) {
+    var ok, rules, css = document.styleSheets;
+    for (var sx = 0; sx < css.length; sx++) {
+        ok = 1;
+        try {
+            rules = css[sx].rules || css[sx].cssRules;
+        }
+        catch (e) {
+            ok = false;
+            if (e.name !== 'SecurityError') {
+                throw e;
+            }
+        }
+        if (ok) {
+            for (var cx = 0; cx < rules.length; cx++) {
+                if (new RegExp("(^|\\s)" + escapeRegExp(f) + "(\\{|\\s)", "g").test(rules[cx].selectorText)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export { cssExists };

package/dist/fn/date.d.ts

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

package/dist/fn/date.js

@@ -0,0 +1,28 @@
+import { isNumber } from './isNumber';
+import { substr } from './substr';
+import { isDate } from './isDate';
+const date = function (v) {
+    let d = false, t = typeof (v);
+    if (v === undefined) {
+        return new Date();
+    }
+    if ((t === 'number') || (isNumber(v) && (v !== ''))) {
+        if (v < 10000000000) {
+            v = v * 1000;
+        }
+        return (new Date(v));
+    }
+    if (t === 'string') {
+        if (v.length === 10) {
+            return (new Date(parseInt(substr(v, 0, 4)), parseInt(substr(v, 5, 2)) - 1, parseInt(substr(v, 8, 2)), 12));
+        }
+        else if (v.length === 19) {
+            return (new Date(parseInt(substr(v, 0, 4)), parseInt(substr(v, 5, 2)) - 1, parseInt(substr(v, 8, 2)), parseInt(substr(v, 11, 2)), parseInt(substr(v, 14, 2)), parseInt(substr(v, 17, 2))));
+        }
+    }
+    else if (isDate(v)) {
+        return v;
+    }
+    return d;
+};
+export { date };

package/dist/fn/dateSQL.d.ts

@@ -0,0 +1,2 @@
+declare const dateSQL: (v: any, dayOnly: any) => any;
+export { dateSQL };

package/dist/fn/dateSQL.js

@@ -0,0 +1,4 @@
+const dateSQL = function (v, dayOnly) { let date = date(v); if (date) {
+    return dayjs(date).format("YYYY-MM-DD" + (dayOnly ? '' : ' HH:mm:ss'));
+} };
+export { dateSQL };

package/dist/fn/daysInMonth.d.ts

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

package/dist/fn/daysInMonth.js

@@ -0,0 +1,9 @@
+import { date } from './date';
+const daysInMonth = function (v) {
+    let d = date(v);
+    if (d) {
+        return dayjs(d).daysInMonth();
+    }
+    return false;
+};
+export { daysInMonth };