@bbn/bbn 1.0.12 → 1.0.13

package/dist/fn/fieldValue.js

@@ -0,0 +1,24 @@
+const fieldValue = function (field) {
+    let v;
+    if (field.type === "checkbox") {
+        if (field.checked) {
+            v = field.value;
+            if (!v) {
+                v = 1;
+            }
+        }
+        else {
+            v = 0;
+        }
+    }
+    else if (field.type === "radio") {
+        if (field.checked) {
+            v = field.value;
+        }
+    }
+    else {
+        v = field.value;
+    }
+    return v;
+};
+export { fieldValue };

package/dist/fn/fileExt.d.ts

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

package/dist/fn/fileExt.js

@@ -0,0 +1,11 @@
+import { isString } from './isString';
+const fileExt = function (filename) {
+    if (filename && isString(filename)) {
+        let bits = filename.split('.');
+        if (bits[0] && (bits.length > 1)) {
+            return bits[bits.length - 1].toLowerCase();
+        }
+    }
+    return '';
+};
+export { fileExt };

package/dist/fn/filter.d.ts

@@ -0,0 +1,3 @@
+import { filter } from './filter';
+declare const filter: (arr: any, prop: any, val: any, operator: any) => any;
+export { filter };

package/dist/fn/filter.js

@@ -0,0 +1,42 @@
+import { isArray } from './isArray';
+import { isFunction } from './isFunction';
+import { isObject } from './isObject';
+import { each } from './each';
+import { filterToConditions } from './filterToConditions';
+import { compareConditions } from './compareConditions';
+const filter = function (arr, prop, val, operator) {
+    if (!isArray(arr)) {
+        throw new Error("Error in filter: The first argument must be an array");
+    }
+    var filter = {}, res = [], isFn = isFunction(prop), isObj = isObject(prop);
+    if (!prop || !arr.length) {
+        return arr;
+    }
+    if (arr.length) {
+        if (isObj || isFn) {
+            operator = val;
+            filter = prop;
+        }
+        else if (typeof (prop) === 'string') {
+            filter[prop] = val;
+        }
+        else {
+            throw new Error("Search function error: The prop argument should be a string or an object");
+        }
+        if (isFn) {
+            each(arr, (a, i) => { if (filter(a, i)) {
+                res.push(a);
+            } });
+        }
+        else {
+            filter = filterToConditions(filter, operator);
+            if (filter.conditions && filter.logic) {
+                each(arr, (a) => { if (compareConditions(a, filter)) {
+                    res.push(a);
+                } });
+            }
+        }
+        return res;
+    }
+};
+export { filter };

package/dist/fn/filterToConditions.d.ts

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

package/dist/fn/filterToConditions.js

@@ -0,0 +1,25 @@
+import { isObject } from './isObject';
+import { isArray } from './isArray';
+import { iterate } from './iterate';
+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/findAll.d.ts

@@ -0,0 +1,3 @@
+import { findAll } from './findAll';
+declare const findAll: (arr: any, filter: any, deepProperty: any, res?: any[]) => any[];
+export { findAll };

package/dist/fn/findAll.js

@@ -0,0 +1,16 @@
+import { search } from './search';
+import { each } from './each';
+import { isArray } from './isArray';
+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/fori.d.ts

@@ -0,0 +1,2 @@
+declare const fori: (arr: any, fn: any, max?: number, min?: number) => void;
+export { fori };

package/dist/fn/fori.js

@@ -0,0 +1,19 @@
+import { isArray } from './isArray';
+import { isNumber } from './isNumber';
+const fori = function (arr, fn, max = arr.length - 1, min = 0) {
+    if (isArray(arr)) {
+        let realMax = arr.length - 1;
+        if (!isNumber(max) || !(0 < max <= realMax)) {
+            max = realMax;
+        }
+        if (!isNumber(min) || !(0 <= 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/forir.d.ts

@@ -0,0 +1,2 @@
+declare const forir: (arr: any, fn: any, max?: number, min?: number) => void;
+export { forir };

package/dist/fn/forir.js

@@ -0,0 +1,19 @@
+import { isArray } from './isArray';
+import { isNumber } from './isNumber';
+const forir = function (arr, fn, max = arr.length - 1, min = 0) {
+    if (isArray(arr)) {
+        let realMax = arr.length - 1;
+        if (!isNumber(max) || !(0 < max <= realMax)) {
+            max = realMax;
+        }
+        if (!isNumber(min) || !(0 <= 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/format.d.ts

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

package/dist/fn/format.js

@@ -0,0 +1,11 @@
+import { bbn } from '../definitions';
+import { checkType } from './checkType';
+const format = function (str) {
+    let args = Array.prototype.slice.call(arguments, 1);
+    if (args.length) {
+        let i = 0;
+        return str.replace(/\%([d|s])/g, (match, type) => { let tmp = args[i++]; checkType(tmp, type === 'd' ? 'number' : 'string', bbn._("The value doesn't correspond to the format")); return tmp; });
+    }
+    return str;
+};
+export { format };

package/dist/fn/formatBytes.d.ts

@@ -0,0 +1,2 @@
+declare const formatBytes: (bytes: any, decimals?: number) => string;
+export { formatBytes };

package/dist/fn/formatBytes.js

@@ -0,0 +1,8 @@
+const formatBytes = function (bytes, decimals = 2) {
+    if (!bytes) {
+        return '0 B';
+    }
+    const k = 1024, s = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(decimals < 0 ? 0 : decimals)) + ' ' + s[i];
+};
+export { formatBytes };

package/dist/fn/formatDate.d.ts

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

package/dist/fn/formatDate.js

@@ -0,0 +1,2 @@
+const formatDate = function (date, format) { return dayjs(date).format(format); };
+export { formatDate };

package/dist/fn/formatSize.d.ts

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

package/dist/fn/formatSize.js

@@ -0,0 +1,12 @@
+import { isNumber } from './isNumber';
+import { isString } from './isString';
+const formatSize = function (st, noValid) {
+    if (isNumber(st)) {
+        return st + 'px';
+    }
+    if (isString(st)) {
+        return st;
+    }
+    return noValid ? false : 'auto';
+};
+export { formatSize };

package/dist/fn/formdata.d.ts

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

package/dist/fn/formdata.js

@@ -0,0 +1,48 @@
+import { each } from './each';
+import { fieldValue } from './fieldValue';
+import { replaceAll } from './replaceAll';
+import { substr } from './substr';
+const formdata = function (form) {
+    let $inputs = form.querySelectorAll('input[name],select[name],textarea[name],button[name]');
+    let res = {};
+    let n;
+    let v;
+    each($inputs, (input, i) => {
+        v = fieldValue(input);
+        if ((v !== undefined) && !input.disabled) {
+            let name = input.name;
+            if ((name.indexOf("[]") === -1) && (name.indexOf("[") > -1) && (name.indexOf("]") > -1) && (name.lastIndexOf("]") === name.length - 1)) {
+                name = replaceAll("][", ".", name);
+                name = replaceAll("[", ".", name);
+                name = replaceAll("]", "", name);
+            }
+            if ((name.length > 2) && (name.indexOf("[]") === (name.length - 2))) {
+                n = substr(name, 0, name.length - 2);
+                if (res[n] === undefined) {
+                    res[n] = [];
+                }
+                res[n].push(v);
+            }
+            else if (name.indexOf(".") > -1) {
+                let tmp, parts = name.split(".");
+                tmp = res;
+                for (let i = 0; i < parts.length; i++) {
+                    if (res[parts[i]] === undefined) {
+                        if (i < (parts.length - 1)) {
+                            tmp[parts[i]] = {};
+                        }
+                        else {
+                            tmp[parts[i]] = v;
+                        }
+                    }
+                    tmp = tmp[parts[i]];
+                }
+            }
+            else {
+                res[name] = v;
+            }
+        }
+    });
+    return res;
+};
+export { formdata };

package/dist/fn/fromXml.d.ts

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

package/dist/fn/fromXml.js

@@ -0,0 +1,44 @@
+const fromXml = function (xml, arrayTags) {
+    let dom = null;
+    if (window.DOMParser)
+        dom = (new DOMParser()).parseFromString(xml, "text/xml");
+    else if (window.ActiveXObject) {
+        dom = new ActiveXObject('Microsoft.XMLDOM');
+        dom.async = false;
+        if (!dom.loadXML(xml))
+            throw dom.parseError.reason + " " + dom.parseError.srcText;
+    }
+    else
+        throw new Error("cannot parse xml string!");
+    function parseNode(xmlNode, result) {
+        if (xmlNode.nodeName == "#text") {
+            let v = xmlNode.nodeValue;
+            if (v.trim())
+                result['#text'] = v;
+            return;
+        }
+        let jsonNode = {}, existing = result[xmlNode.nodeName];
+        if (existing) {
+            if (!Array.isArray(existing))
+                result[xmlNode.nodeName] = [existing, jsonNode];
+            else
+                result[xmlNode.nodeName].push(jsonNode);
+        }
+        else {
+            if (arrayTags && arrayTags.indexOf(xmlNode.nodeName) != -1)
+                result[xmlNode.nodeName] = [jsonNode];
+            else
+                result[xmlNode.nodeName] = jsonNode;
+        }
+        if (xmlNode.attributes)
+            for (let attribute of xmlNode.attributes)
+                jsonNode[attribute.nodeName] = attribute.nodeValue;
+        for (let node of xmlNode.childNodes)
+            parseNode(node, jsonNode);
+    }
+    let result = {};
+    for (let node of dom.childNodes)
+        parseNode(node, result);
+    return result;
+};
+export { fromXml };

package/dist/fn/ftime.d.ts

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

package/dist/fn/ftime.js

@@ -0,0 +1,14 @@
+import { date } from './date';
+import { isDate } from './isDate';
+import { isString } from './isString';
+const ftime = function (d, wrong_result) {
+    let r = date(d);
+    if (!isDate(r)) {
+        return wrong_result && isString(wrong_result) ? wrong_result : '';
+    }
+    if (undefined !== dayjs) {
+        return dayjs(r).calendar({ sameElse: 'D/M/YY HH:mm' });
+    }
+    return r.toLocaleDateString();
+};
+export { ftime };

package/dist/fn/getAllTags.d.ts

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

package/dist/fn/getAllTags.js

@@ -0,0 +1,3 @@
+import { unique } from './unique';
+const getAllTags = function () { return unique(Array.prototype.map.apply(document.all, [a => a.tagName.toLowerCase()])); };
+export { getAllTags };

package/dist/fn/getAncestors.d.ts

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

package/dist/fn/getAncestors.js

@@ -0,0 +1,26 @@
+import { isString } from './isString';
+const getAncestors = function (ele, sel) {
+    let r = [];
+    if (isString(ele)) {
+        ele = document.querySelector(ele);
+    }
+    if (ele instanceof HTMLElement) {
+        if (ele.parentNode) {
+            if (typeof (sel) === 'string') {
+                while (ele = ele.parentNode.closest(sel)) {
+                    r.push(ele);
+                }
+            }
+            else {
+                if (sel === true) {
+                    r.push(ele);
+                }
+                while (ele = ele.parentNode) {
+                    r.push(ele);
+                }
+            }
+        }
+    }
+    return r;
+};
+export { getAncestors };

package/dist/fn/getAttributes.d.ts

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

package/dist/fn/getAttributes.js

@@ -0,0 +1,10 @@
+import { error } from './error';
+const getAttributes = function (ele) {
+    if (!ele.getAttributeNames) {
+        error("The element is not a proper HTML Element");
+    }
+    let res = Object.create(null);
+    ele.getAttributeNames().forEach(name => { res[name] = ele.getAttribute(name); });
+    return res;
+};
+export { getAttributes };

package/dist/fn/getBrowserName.d.ts

@@ -0,0 +1,2 @@
+declare const getBrowserName: () => "Edge" | "Opera" | "Chrome" | "Internet Explorer" | "Firefox" | "Safari" | "Other";
+export { getBrowserName };

package/dist/fn/getBrowserName.js

@@ -0,0 +1,11 @@
+const getBrowserName = function () { const userAgent = navigator.userAgent.toLowerCase(); switch (true) {
+    case userAgent.includes('edge'):
+    case userAgent.includes('edg/'): return "Edge";
+    case userAgent.includes('opr') && !!window.opr: return "Opera";
+    case userAgent.includes('chrome') && !!window.chrome: return "Chrome";
+    case userAgent.includes('trident'): return "Internet Explorer";
+    case userAgent.includes('firefox'): return "Firefox";
+    case userAgent.includes('safari'): return "Safari";
+    default: return "Other";
+} };
+export { getBrowserName };

package/dist/fn/getBrowserVersion.d.ts

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

package/dist/fn/getBrowserVersion.js

@@ -0,0 +1,11 @@
+const getBrowserVersion = function () { const userAgent = navigator.userAgent.toLowerCase(); switch (true) {
+    case userAgent.includes('edge/'): return userAgent.split('edge/')[1].split(' ')[0];
+    case userAgent.includes('edg/'): return userAgent.split('edg/')[1].split(' ')[0];
+    case userAgent.includes('opr/') && !!window.opr: return userAgent.split('opr/')[1].split(' ')[0];
+    case userAgent.includes('chrome/') && !!window.chrome: return userAgent.split('chrome/')[1].split(' ')[0];
+    case userAgent.includes('trident/'): return userAgent.split('trident/')[1].split(' ')[0];
+    case userAgent.includes('firefox/'): return userAgent.split('firefox/')[1].split(' ')[0];
+    case userAgent.includes('safari/'): return userAgent.split('version/')[1].split(' ')[0];
+    default: return '';
+} };
+export { getBrowserVersion };

package/dist/fn/getCookie.d.ts

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

package/dist/fn/getCookie.js

@@ -0,0 +1,18 @@
+const getCookie = function (name) {
+    let nameEqual = name + "=";
+    let ca = document.cookie.split(';');
+    for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) == ' ') {
+            c = c.substring(1, c.length);
+        }
+        if (c.indexOf(nameEqual) == 0) {
+            let st = c.substring(nameEqual.length, c.length);
+            if (st) {
+                return JSON.parse(unescape(st)).value;
+            }
+        }
+    }
+    return null;
+};
+export { getCookie };

package/dist/fn/getCssVar.d.ts

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

package/dist/fn/getCssVar.js

@@ -0,0 +1,7 @@
+const getCssVar = function (varname) {
+    if (varname.indexOf('--') !== 0) {
+        varname = '--' + varname;
+    }
+    return getComputedStyle(document.documentElement).getPropertyValue(varname);
+};
+export { getCssVar };

package/dist/fn/getDay.d.ts

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

package/dist/fn/getDay.js

@@ -0,0 +1,17 @@
+import { date } from './date';
+const getDay = function (v) {
+    const biss = 1972;
+    let d = date(v);
+    if (d) {
+        let t = d.getTime(), y = d.getYear(), m = d.getMonth(), days = (y - 1970) * 365;
+        if (m < 2) {
+            y--;
+        }
+        for (var i = biss; i <= y; i += 4) {
+            days++;
+        }
+        return days + Math.floor(t / (24 * 3600000));
+    }
+    return false;
+};
+export { getDay };

package/dist/fn/getDeviceType.d.ts

@@ -0,0 +1,2 @@
+declare const getDeviceType: () => "mobile" | "tablet" | "desktop";
+export { getDeviceType };

package/dist/fn/getDeviceType.js

@@ -0,0 +1,11 @@
+const getDeviceType = function () {
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (/iPhone|Android/i.test(navigator.userAgent)) {
+        return "mobile";
+    }
+    if (/(ipad|tablet|(android(?!.*mobile))|(windows(?!.*phone)(.*touch))|kindle|playbook|silk|(puffin(?!.*(IP|AP|WP))))/.test(userAgent)) {
+        return "tablet";
+    }
+    return "desktop";
+};
+export { getDeviceType };

package/dist/fn/getEventData.d.ts

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

package/dist/fn/getEventData.js

@@ -0,0 +1,80 @@
+import { bbn } from '../definitions';
+import { getHTMLOfSelection } from './getHTMLOfSelection';
+import { each } from './each';
+const getEventData = function (e) {
+    let dt = e.dataTransfer || e.clipboardData;
+    let t = dt.getData('Text');
+    let res = { raw: t, files: [], str: [] };
+    let p = new Promise((ok, err) => {
+        let done = !(dt instanceof DataTransfer);
+        if (!t && e.type === 'copy') {
+            let sel = window.getSelection();
+            res.raw = sel.toString();
+            let html = getHTMLOfSelection();
+            res.str.push({ type: 'text/plain', data: res.raw });
+            if (html !== res.raw) {
+                res.str.push({ type: 'text/html', data: html });
+            }
+            else if (res.raw.trim().indexOf('<') === 0) {
+                res.str.push({ type: 'text/html', data: "<meta charset='utf-8'><code style=\"white-space: pre; font-family: 'Courier New', sans-serif\">\n" + res.raw + "\n</code>" });
+            }
+            done = true;
+            ok(res);
+        }
+        if (!done) {
+            let strings = [];
+            let num = dt.items.length;
+            each(dt.items, (item, idx) => {
+                let kind = item.kind;
+                let type = item.type;
+                if (kind === 'file') {
+                    let cp = dt.files[idx];
+                    if (!type && cp.name) {
+                        let bits = cp.name.split('.');
+                        type = bits[bits.length - 1];
+                    }
+                    let name = cp ? cp.name : bbn._('untitled');
+                    let size = cp ? cp.size : null;
+                    let lastModified = cp ? cp.lastModified : null;
+                    let blob = item.getAsFile();
+                    if (blob) {
+                        done = true;
+                        num--;
+                        res.files.push({ type: type, data: blob, name: name, size: size, mdate: lastModified });
+                        strings.push(name);
+                        if (!num) {
+                            if (!res.raw) {
+                                res.raw = strings.join(", ");
+                            }
+                            ok(res);
+                        }
+                    }
+                    else {
+                        appui.error(bbn._("Impossible to read the file") + ' ' + name);
+                    }
+                }
+                else {
+                    done = true;
+                    item.getAsString((data) => {
+                        num--;
+                        res.str.push({ type: type, data: data });
+                        if (type === 'text/plain') {
+                            strings.push(name);
+                        }
+                        if (!num) {
+                            if (!res.raw) {
+                                res.raw = strings.join(", ");
+                            }
+                            ok(res);
+                        }
+                    });
+                }
+            });
+        }
+        if (!done) {
+            setTimeout(() => { ok(res); });
+        }
+    });
+    return p;
+};
+export { getEventData };

package/dist/fn/getField.d.ts

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

package/dist/fn/getField.js

@@ -0,0 +1,9 @@
+import { getRow } from './getRow';
+const getField = function (arr, field, prop, val, operator) {
+    var r;
+    if (field && (r = getRow(arr, prop, val, operator))) {
+        return r[field];
+    }
+    return undefined;
+};
+export { getField };

package/dist/fn/getFieldValues.d.ts

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