@bbn/bbn 1.0.12 → 1.0.14

package/dist/fn/removeAccents.d.ts

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

package/dist/fn/removeAccents.js

@@ -0,0 +1,16 @@
+import { bbn } from '../definitions';
+import { isString } from './isString';
+import { log } from './log';
+const removeAccents = function (st) {
+    if (!isString(st)) {
+        if (st.toString) {
+            st = st.toString();
+        }
+        else {
+            log(st);
+            throw new Error(bbn._("removeAccent expects a string"));
+        }
+    }
+    return st.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+};
+export { removeAccents };

package/dist/fn/removeEmpty.d.ts

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

package/dist/fn/removeEmpty.js

@@ -0,0 +1,31 @@
+import { isArray } from './isArray';
+import { isObject } from './isObject';
+import { numProperties } from './numProperties';
+const removeEmpty = function (arr) {
+    var tmp = [];
+    if (isArray(arr)) {
+        for (let i = 0; i < arr.length; i++) {
+            let ok = false;
+            if (arr[i]) {
+                if (isArray(arr[i])) {
+                    if (arr[i].length) {
+                        ok = true;
+                    }
+                }
+                else if (isObject(arr[i])) {
+                    if (numProperties(arr[i])) {
+                        ok = true;
+                    }
+                }
+                else {
+                    ok = true;
+                }
+            }
+            if (ok) {
+                tmp.push(arr[i]);
+            }
+        }
+    }
+    return tmp;
+};
+export { removeEmpty };

package/dist/fn/removeExtraSpaces.d.ts

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

package/dist/fn/removeExtraSpaces.js

@@ -0,0 +1,2 @@
+const removeExtraSpaces = function (str) { return str.replace(/\s+/g, ' ').trim(); };
+export { removeExtraSpaces };

package/dist/fn/removeHtmlComments.d.ts

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

package/dist/fn/removeHtmlComments.js

@@ -0,0 +1,8 @@
+import { isString } from './isString';
+const removeHtmlComments = function (str) {
+    if (!isString(str)) {
+        return str;
+    }
+    return str.replace(/<!--[\s\S]*?-->/g, '');
+};
+export { removeHtmlComments };

package/dist/fn/removePrivateProp.d.ts

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

package/dist/fn/removePrivateProp.js

@@ -0,0 +1,19 @@
+import { substr } from './substr';
+const removePrivateProp = function (obj, deep) {
+    var r = false;
+    if (typeof (obj) === "object") {
+        r = {};
+        for (var n in obj) {
+            if (substr(n, 0, 1).match(/^[A-z0-9]$/) && Object.hasOwn(obj, n)) {
+                if (deep && (typeof (obj[n]) === "object")) {
+                    r[n] = removePrivateProp(obj[n], true);
+                }
+                else {
+                    r[n] = obj[n];
+                }
+            }
+        }
+    }
+    return r;
+};
+export { removePrivateProp };

package/dist/fn/removeTrailingChars.d.ts

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

package/dist/fn/removeTrailingChars.js

@@ -0,0 +1,16 @@
+import { substr } from './substr';
+const removeTrailingChars = function (st, char) {
+    if (!char) {
+        char = ' ';
+    }
+    if (char.length) {
+        while (substr(st, -char.length) === char) {
+            st = substr(st, 0, st.length - char.length);
+        }
+        while (substr(st, 0, char.length) === char) {
+            st = substr(st, char.length);
+        }
+    }
+    return st;
+};
+export { removeTrailingChars };

package/dist/fn/repeat.d.ts

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

package/dist/fn/repeat.js

@@ -0,0 +1,3 @@
+import { iterate } from './iterate';
+const repeat = function (st, num) { let res = ''; iterate(num, () => { res += st; }); return res; };
+export { repeat };

package/dist/fn/replaceAll.d.ts

@@ -0,0 +1,2 @@
+declare const replaceAll: (find: any, replace: any, str: any, flags?: string) => any;
+export { replaceAll };

package/dist/fn/replaceAll.js

@@ -0,0 +1,9 @@
+import { isObject } from './isObject';
+import { escapeRegExp } from './escapeRegExp';
+const replaceAll = function (find, replace, str, flags = '') {
+    if (str !== undefined) {
+        return str.toString().replace(isObject(find) ? find : new RegExp(escapeRegExp(find), 'g' + flags), replace);
+    }
+    return false;
+};
+export { replaceAll };

package/dist/fn/replaceSelection.d.ts

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

package/dist/fn/replaceSelection.js

@@ -0,0 +1,36 @@
+const replaceSelection = function (html, selectInserted) {
+    let sel, range, fragment;
+    sel = window.getSelection();
+    if (sel.getRangeAt && sel.rangeCount) {
+        range = window.getSelection().getRangeAt(0);
+        range.deleteContents();
+        if (range.createContextualFragment) {
+            fragment = range.createContextualFragment(html);
+        }
+        else {
+            const div = document.createElement("div");
+            let child;
+            div.innerHTML = html;
+            fragment = document.createDocumentFragment();
+            while ((child = div.firstChild)) {
+                fragment.appendChild(child);
+            }
+        }
+        const firstInsertedNode = fragment.firstChild;
+        const lastInsertedNode = fragment.lastChild;
+        range.insertNode(fragment);
+        sel.removeAllRanges();
+        if (selectInserted) {
+            if (firstInsertedNode) {
+                range.setStartBefore(firstInsertedNode);
+                range.setEndAfter(lastInsertedNode);
+            }
+            sel.addRange(range);
+        }
+        else {
+            range.setStartAfter(lastInsertedNode);
+            sel.addRange(range);
+        }
+    }
+};
+export { replaceSelection };

package/dist/fn/resize.d.ts

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

package/dist/fn/resize.js

@@ -0,0 +1,38 @@
+import { bbn } from '../definitions';
+import { getCssVar } from './getCssVar';
+import { each } from './each';
+import { defaultResizeFunction } from './defaultResizeFunction';
+const resize = function () {
+    let diffW = bbn.env.width !== window.innerWidth;
+    let diffH = bbn.env.height !== window.innerHeight;
+    if (diffW || diffH) {
+        if (diffW) {
+            bbn.env.width = window.innerWidth || window.document.documentElement.clientWidth || window.document.body.clientWidth;
+            document.documentElement.style.setProperty('--vw', (bbn.env.width * 0.01) + 'px');
+        }
+        if (diffH) {
+            bbn.env.height = window.innerHeight || window.document.documentElement.clientHeight || window.document.body.clientHeight;
+            document.documentElement.style.setProperty('--vh', (bbn.env.height * 0.01) + 'px');
+        }
+        let smallWidth = getCssVar('mobile-limit') || 650;
+        let newCls = 'bbn-screen-' + (bbn.env.width < parseInt(smallWidth) ? 'small' : 'regular');
+        let classes = (document.body.className || '').split(' ');
+        let done = false;
+        each(classes, (cls, idx) => {
+            let bits = cls.split('-');
+            if ((bits.length === 3) && (cls.indexOf('bbn-screen-') === 0)) {
+                done = true;
+                if (cls !== newCls) {
+                    classes.splice(idx, 1, newCls);
+                }
+                return false;
+            }
+        });
+        if (!done) {
+            classes.push(newCls);
+        }
+        document.body.className = classes.join(' ');
+        defaultResizeFunction();
+    }
+};
+export { resize };

package/dist/fn/rgb2hex.d.ts

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

package/dist/fn/rgb2hex.js

@@ -0,0 +1,8 @@
+const rgb2hex = function (rgb) {
+    rgb = rgb.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
+    return (rgb && rgb.length === 4) ? "#" +
+        ("0" + parseInt(rgb[1], 10).toString(16)).slice(-2) +
+        ("0" + parseInt(rgb[2], 10).toString(16)).slice(-2) +
+        ("0" + parseInt(rgb[3], 10).toString(16)).slice(-2) : '';
+};
+export { rgb2hex };

package/dist/fn/riterate.d.ts

@@ -0,0 +1,2 @@
+declare const riterate: (obj: any, fn: any, noPrivate: any) => any;
+export { riterate };

package/dist/fn/riterate.js

@@ -0,0 +1,3 @@
+import { iterate } from './iterate';
+const riterate = function (obj, fn, noPrivate) { return iterate(obj, fn, noPrivate, true); };
+export { riterate };

package/dist/fn/roundDecimal.d.ts

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

package/dist/fn/roundDecimal.js

@@ -0,0 +1,2 @@
+const roundDecimal = function (value, decimals) { return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals); };
+export { roundDecimal };

package/dist/fn/sanitize.d.ts

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

package/dist/fn/sanitize.js

@@ -0,0 +1,17 @@
+import { removeAccents } from './removeAccents';
+import { trim } from './trim';
+const sanitize = function (str, separator = '_') {
+    let escaped = ['[', ']', '{', '}', '(', ')', '-', '+', '*', '/'];
+    let exp = '[';
+    for (let i = 0; i < separator.length; i++) {
+        if (escaped.includes(separator[i])) {
+            exp += '\\';
+        }
+        exp += separator[i];
+    }
+    exp += ']+';
+    let re = new RegExp(exp, 'g');
+    let res = removeAccents(str).replace(/[^a-z0-9]/gi, separator).replace(re, separator);
+    return trim(res, separator);
+};
+export { sanitize };

package/dist/fn/search.d.ts

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

package/dist/fn/search.js

@@ -0,0 +1,62 @@
+import { bbn } from '../definitions';
+import { isIterable } from './isIterable';
+import { isString } from './isString';
+import { compareConditions } from './compareConditions';
+import { filterToConditions } from './filterToConditions';
+import { isObject } from './isObject';
+import { numProperties } from './numProperties';
+import { isNumber } from './isNumber';
+const search = function (arr, prop, val, operator, startFrom) {
+    if (!isIterable(arr)) {
+        throw new Error(bbn._("The first argument for a search should be iterable") + " " + (typeof arr) + " " + bbn._("given"));
+    }
+    if (!arr.length) {
+        return -1;
+    }
+    let filter = {};
+    let isFunction = false;
+    if (isString(prop)) {
+        filter.conditions = [{ field: prop, value: val, operator: operator || '=' }];
+    }
+    else if (!prop) {
+        isFunction = true;
+        filter = a => { return compareConditions({ value: a }, filterToConditions({ logic: 'AND', conditions: [{ field: 'value', operator: operator || '=', value: val }] })); };
+    }
+    else {
+        startFrom = operator;
+        operator = val;
+        if (isObject(prop)) {
+            filter = prop;
+        }
+        else if (isFunction(prop)) {
+            isFunction = true;
+            filter = prop;
+        }
+    }
+    if (isFunction || (isObject(filter) && numProperties(filter))) {
+        if (isNumber(operator)) {
+            startFrom = operator;
+            operator = undefined;
+        }
+        if (!isNumber(startFrom)) {
+            startFrom = 0;
+        }
+        if (isFunction) {
+            for (let i = startFrom; i < arr.length; i++) {
+                if (filter(arr[i])) {
+                    return i;
+                }
+            }
+        }
+        else {
+            filter = filterToConditions(filter);
+            for (let i = startFrom; i < arr.length; i++) {
+                if (compareConditions(arr[i], filter)) {
+                    return i;
+                }
+            }
+        }
+    }
+    return -1;
+};
+export { search };

package/dist/fn/selectElementText.d.ts

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

package/dist/fn/selectElementText.js

@@ -0,0 +1,23 @@
+const selectElementText = function (ele, win) {
+    win = win || window;
+    if (ele instanceof HTMLInputElement) {
+        ele.select();
+        return;
+    }
+    let doc = win.document;
+    let sel;
+    let range;
+    if (win.getSelection && doc.createRange) {
+        sel = win.getSelection();
+        range = doc.createRange();
+        range.selectNodeContents(ele);
+        sel.removeAllRanges();
+        sel.addRange(range);
+    }
+    else if (doc.body.createTextRange) {
+        range = doc.body.createTextRange();
+        range.moveToElementText(ele);
+        range.select();
+    }
+};
+export { selectElementText };

package/dist/fn/selector.d.ts

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

package/dist/fn/selector.js

@@ -0,0 +1,2 @@
+const selector = function (ele) { return (typeof el === 'string') ? document.querySelector(ele) : ele; };
+export { selector };

package/dist/fn/setCookie.d.ts

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

package/dist/fn/setCookie.js

@@ -0,0 +1,11 @@
+const setCookie = function (name, value, days) {
+    let expires = "";
+    if (days) {
+        let date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        expires = "; expires=" + date.toUTCString();
+    }
+    let st = escape(JSON.stringify({ value: value }));
+    document.cookie = name + "=" + st + expires + "; path=/";
+};
+export { setCookie };

package/dist/fn/setCssVar.d.ts

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

package/dist/fn/setCssVar.js

@@ -0,0 +1,7 @@
+const setCssVar = function (varname, value) {
+    if (varname.indexOf('--') !== 0) {
+        varname = '--' + varname;
+    }
+    document.documentElement.setProperty(varname, value);
+};
+export { setCssVar };

package/dist/fn/setNavigationVars.d.ts

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

package/dist/fn/setNavigationVars.js

@@ -0,0 +1,39 @@
+import { bbn } from '../definitions';
+import { substr } from './substr';
+import { filter } from './filter';
+import { extend } from './extend';
+import { html2text } from './html2text';
+const setNavigationVars = function (url, title, data, repl) {
+    bbn.env.old_path = bbn.env.path;
+    bbn.env.url = ['https:/', 'http://'].includes(substr(url, 0, 7)) ? url : bbn.env.root + url;
+    bbn.env.path = substr(bbn.env.url, bbn.env.root.length);
+    bbn.env.params = filter(bbn.env.path.split("/"), (v) => { return v !== ''; });
+    let h = window.history;
+    if (h) {
+        let state = h.state;
+        let obj = { url: bbn.env.path, old_path: bbn.env.old_path || null, data: data || {} };
+        if (state && (state.url === bbn.env.path)) {
+            if (state.data) {
+                extend(obj.data, state.data);
+            }
+            if (state.title && !title) {
+                title = state.title;
+            }
+            repl = 1;
+        }
+        if (!title) {
+            title = bbn.env.siteTitle;
+        }
+        else {
+            title = html2text(title);
+        }
+        if (repl) {
+            obj.reload = 1;
+            h.replaceState(obj, title, bbn.env.url);
+        }
+        else {
+            h.pushState(obj, title, bbn.env.url);
+        }
+    }
+};
+export { setNavigationVars };

package/dist/fn/setProp.d.ts

@@ -0,0 +1,2 @@
+declare const setProp: (obj: any, prop: any, value: any, writable?: boolean, configurable?: boolean) => void;
+export { setProp };

package/dist/fn/setProp.js

@@ -0,0 +1,3 @@
+import { bbn } from '../definitions';
+const setProp = function (obj, prop, value, writable = true, configurable = true) { checkType(prop, "string", bbn._("The prop must be a string in setProp")); checkType(obj, "object", bbn._("The obj must be an object in setProp")); Object.defineProperty(obj, prop, { value: value, writable: writable, configurable: configurable }); };
+export { setProp };

package/dist/fn/setProperty.d.ts

@@ -0,0 +1,2 @@
+declare const setProperty: (obj: any, prop: any, value: any, force: any) => void;
+export { setProperty };

package/dist/fn/setProperty.js

@@ -0,0 +1,23 @@
+import { bbn } from '../definitions';
+import { each } from './each';
+const setProperty = function (obj, prop, value, force) {
+    if ((typeof obj === 'object') && (typeof prop === 'string')) {
+        let o = obj;
+        const bits = prop.split('.');
+        each(bits, (v, i) => {
+            if (!o) {
+                if (!force) {
+                    throw new Error(bbn._("The object is invalid"));
+                }
+                o = {};
+            }
+            if (bits.length - 1 === i) {
+                o[v] = value;
+            }
+            else {
+                o = o[v];
+            }
+        });
+    }
+};
+export { setProperty };

package/dist/fn/shorten.d.ts

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

package/dist/fn/shorten.js

@@ -0,0 +1,18 @@
+import { bbn } from '../definitions';
+import { isString } from './isString';
+import { substr } from './substr';
+const shorten = function (st, len, adj) {
+    if (typeof (st).toLowerCase() === 'string') {
+        if (!len) {
+            len = bbn.var.shortenLen;
+        }
+        if ((adj === undefined) || !isString(adj)) {
+            adj = '...';
+        }
+        if (st.length > len) {
+            st = substr(st, 0, len) + adj;
+        }
+    }
+    return st;
+};
+export { shorten };

package/dist/fn/shortenObj.d.ts

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

package/dist/fn/shortenObj.js

@@ -0,0 +1,17 @@
+import { clone } from './clone';
+import { each } from './each';
+import { isString } from './isString';
+import { shorten } from './shorten';
+const shortenObj = function (obj, max = 100) {
+    let o = clone(obj);
+    each(o, (a, n) => {
+        if (isString(a) && (a.length > max)) {
+            o[n] = shorten(a, max);
+        }
+        else if (a && (typeof a === 'object')) {
+            o[n] = shortenObj(a);
+        }
+    });
+    return o;
+};
+export { shortenObj };

package/dist/fn/shuffle.d.ts

@@ -1,7 +1,2 @@
-/**
- *
- * @param {Array} array
- * @returns Array
- */
 declare const shuffle: (array: any) => any;
 export { shuffle };

package/dist/fn/shuffle.js

@@ -1,19 +1,9 @@
-/**
- *
- * @param {Array} array
- * @returns Array
- */
 const shuffle = function (array) {
     let currentIndex = array.length, randomIndex;
-    // While there remain elements to shuffle.
     while (currentIndex != 0) {
-        // Pick a remaining element.
         randomIndex = Math.floor(Math.random() * currentIndex);
         currentIndex--;
-        // And swap it with the current element.
-        [array[currentIndex], array[randomIndex]] = [
-            array[randomIndex], array[currentIndex]
-        ];
+        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
     }
     return array;
 };

package/dist/fn/simpleHash.d.ts

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

package/dist/fn/simpleHash.js

@@ -0,0 +1,4 @@
+import { simpleHash1 } from './simpleHash1';
+import { simpleHash2 } from './simpleHash2';
+const simpleHash = function (str) { const part1 = simpleHash1(str).toString(16).padStart(8, '0'); const part2 = simpleHash2(str).toString(16).padStart(8, '0'); return part1 + part2; };
+export { simpleHash };

package/dist/fn/simpleHash1.d.ts

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

package/dist/fn/simpleHash1.js

@@ -0,0 +1,10 @@
+const simpleHash1 = function (str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash |= 0;
+    }
+    return hash;
+};
+export { simpleHash1 };

package/dist/fn/simpleHash2.d.ts

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

package/dist/fn/simpleHash2.js

@@ -0,0 +1,10 @@
+const simpleHash2 = function (str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = char + (hash << 6) + (hash << 16) - hash;
+        hash |= 0;
+    }
+    return hash;
+};
+export { simpleHash2 };

package/dist/fn/startChrono.d.ts

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

package/dist/fn/startChrono.js

@@ -0,0 +1,13 @@
+import { each } from './each';
+const startChrono = function (name) {
+    let now = (new Date()).getTime();
+    let h1 = 3600 * 1000;
+    if (_private.length) {
+        each(_private, (t, n) => { if (now - t > h1) {
+            delete _private[n];
+        } });
+        now = (new Date()).getTime();
+    }
+    _private[name] = now;
+};
+export { startChrono };