@bbn/bbn 1.0.59 → 1.0.61

package/dist/fn/string/sanitize.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Removes all unacceptable characters in a DOM node.
+ *
+ * @method   sanitize
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //"this_is_a_test"
+ * bbn.fn.sanitize("this&is_$a^test");
+ * ```
+ *
+ * @memberof bbn.fn
+ * @returns  {String} str
+ */
+declare const sanitize: (str: any, separator?: string) => any;
+export { sanitize };

package/dist/fn/string/sanitize.js

@@ -0,0 +1,34 @@
+import { removeAccents } from "./removeAccents";
+import { trim } from "./trim";
+/**
+ * Removes all unacceptable characters in a DOM node.
+ *
+ * @method   sanitize
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //"this_is_a_test"
+ * bbn.fn.sanitize("this&is_$a^test");
+ * ```
+ *
+ * @memberof bbn.fn
+ * @returns  {String} str
+ */
+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/string/shorten.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shortens the given string after *len* characters.
+ *
+ * Provides an abbreviation to the string passed as the first argument,
+ * deciding through the second argument the number of characters to keep and the remainder replaced
+ * by what is passed as the third argument and if not given a defalut it is: '...'
+ *
+ * @method   shorten
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //"test***"
+ * bbn.fn.shorten('testing', 4, '***');
+ * ```
+ *  @example
+ * ```javascript
+ * //"test..."
+ * bbn.fn.shorten('testing', 4);
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @param    {Number} len
+ * @returns  {String}
+ */
+declare const shorten: (st: string, len?: number, adj?: string) => string;
+export { shorten };

package/dist/fn/string/shorten.js

@@ -0,0 +1,42 @@
+import { isString } from "../type/isString";
+import { substr } from "./substr";
+/**
+ * Shortens the given string after *len* characters.
+ *
+ * Provides an abbreviation to the string passed as the first argument,
+ * deciding through the second argument the number of characters to keep and the remainder replaced
+ * by what is passed as the third argument and if not given a defalut it is: '...'
+ *
+ * @method   shorten
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //"test***"
+ * bbn.fn.shorten('testing', 4, '***');
+ * ```
+ *  @example
+ * ```javascript
+ * //"test..."
+ * bbn.fn.shorten('testing', 4);
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @param    {Number} len
+ * @returns  {String}
+ */
+const shorten = function (st, len, adj) {
+    if (typeof st.toLowerCase() === "string") {
+        if (!len) {
+            len = bbn.vars.shortenLen;
+        }
+        if (adj === undefined || !isString(adj)) {
+            adj = "...";
+        }
+        if (st.length > len) {
+            st = substr(st, 0, len) + adj;
+        }
+    }
+    return st;
+};
+export { shorten };

package/dist/fn/string/simpleHash.d.ts

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

package/dist/fn/string/simpleHash.js

@@ -0,0 +1,8 @@
+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/string/simpleHash1.d.ts

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

package/dist/fn/string/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; // Convert to 32-bit integer
+    }
+    return hash;
+};
+export { simpleHash1 };

package/dist/fn/string/simpleHash2.d.ts

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

package/dist/fn/string/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; // Convert to 32-bit integer
+    }
+    return hash;
+};
+export { simpleHash2 };

package/dist/fn/string/substr.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Basic substring function accepting both positive and negative values.
+ *
+ * @method   substr
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.substr(bbn.fn, 'Hello', -3, -1);
+ * // "ll"
+ * bbn.fn.substr(bbn.fn, 'Hello', -3);
+ * // "llo"
+ * bbn.fn.substr(bbn.fn, 'Hello', 0, 1);
+ * // "H"
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} str
+ * @param    {Number} from
+ * @param    {Number} length
+ * @returns  {String} Result substring
+ */
+declare const substr: (str: string, from: number, length?: number) => string;
+export { substr };

package/dist/fn/string/substr.js

@@ -0,0 +1,38 @@
+import { isString } from "../type/isString";
+import { isInt } from "../type/isInt";
+import { log } from "../browser/log";
+/**
+ * Basic substring function accepting both positive and negative values.
+ *
+ * @method   substr
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.substr(bbn.fn, 'Hello', -3, -1);
+ * // "ll"
+ * bbn.fn.substr(bbn.fn, 'Hello', -3);
+ * // "llo"
+ * bbn.fn.substr(bbn.fn, 'Hello', 0, 1);
+ * // "H"
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} str
+ * @param    {Number} from
+ * @param    {Number} length
+ * @returns  {String} Result substring
+ */
+const substr = function (str, from, length) {
+    if (!isString(str) || !isInt(from)) {
+        log(arguments);
+        throw new Error(bbn._("The substr function should be applied to a string and at least a `from` argument should be given"));
+    }
+    if (from < 0) {
+        from = str.length + from;
+    }
+    if (!isInt(length)) {
+        return str.substring(from);
+    }
+    return str.substring(from, (length < 0 ? str.length : from) + length);
+};
+export { substr };

package/dist/fn/string/trim.d.ts

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

package/dist/fn/string/trim.js

@@ -0,0 +1,20 @@
+import { substr } from './substr';
+const trim = function (str, hair = ' ') {
+    if (hair === ' ') {
+        return str.trim();
+    }
+    if (!hair) {
+        return str;
+    }
+    if (hair === str) {
+        return '';
+    }
+    while (str.indexOf(hair) === 0) {
+        str = substr(str, hair.length);
+    }
+    while (str.lastIndexOf(hair) === str.length - hair.length) {
+        str = substr(str, 0, str.length - hair.length);
+    }
+    return str;
+};
+export { trim };

package/dist/fn/string/uniqString.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a unique string in md5 format.
+ *
+ * Converts and return all the arguments inserted in a unique string in md5 format.
+ *
+ * @method   uniqString
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //"6cb083da4d4987af9b4fa4ad8ca23bb1"
+ * bbn.fn.uniqString('test',['test'],{id:1, test:2},4);
+ * ```
+ * @memberof bbn.fn
+ * @returns  {String} The unique string in md5 format
+ */
+declare const uniqString: (...args: any[]) => string;
+export { uniqString };

package/dist/fn/string/uniqString.js

@@ -0,0 +1,49 @@
+import { isArray } from "../type/isArray";
+import { each } from "../loop/each";
+import { md5 } from "./md5";
+/**
+ * Create a unique string in md5 format.
+ *
+ * Converts and return all the arguments inserted in a unique string in md5 format.
+ *
+ * @method   uniqString
+ * @global
+ *
+ * @example
+ * ```javascript
+ * //"6cb083da4d4987af9b4fa4ad8ca23bb1"
+ * bbn.fn.uniqString('test',['test'],{id:1, test:2},4);
+ * ```
+ * @memberof bbn.fn
+ * @returns  {String} The unique string in md5 format
+ */
+const uniqString = function (...args) {
+    var st = "";
+    for (var i = 0; i < args.length; i++) {
+        if (!args[i]) {
+            st += "__bbn_empty__";
+        }
+        else if (typeof args[i] === "object") {
+            if (isArray(args[i])) {
+                st += JSON.stringify(args[i]);
+            }
+            else {
+                // An object with the same properties, even in different order, should produce the same answer
+                let tmp = {};
+                let ks = Object.keys(args[i]).sort();
+                each(ks, (k) => {
+                    tmp[k] = args[i][k];
+                });
+                st += JSON.stringify(tmp);
+            }
+        }
+        else if (typeof args[i] !== "string") {
+            st += args[i].toString();
+        }
+        else {
+            st += args[i];
+        }
+    }
+    return md5(st);
+};
+export { uniqString };

package/dist/fn/style/addColors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Adds the given color to the object bbn.var.colors in order to be able to use
+ * the css classes bbn-bg-myColor for the background and bbn-myColor for the text color.
+ *
+ * @method   addColors
+ * @global
+ * @example
+ * ```javascript
+ * //<div class="bbn-bg-maroon">background</div> <span class="bbn-maroon">text color</span>
+ * bbn.fn.addColors({maroon: '#800000'});
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} colors
+ * @returns
+ */
+declare const addColors: (colors: object) => void;
+export { addColors };

package/dist/fn/style/addColors.js

@@ -0,0 +1,76 @@
+import { numProperties } from "../object/numProperties";
+import { iterate } from "../loop/iterate";
+/**
+ * Adds the given color to the object bbn.var.colors in order to be able to use
+ * the css classes bbn-bg-myColor for the background and bbn-myColor for the text color.
+ *
+ * @method   addColors
+ * @global
+ * @example
+ * ```javascript
+ * //<div class="bbn-bg-maroon">background</div> <span class="bbn-maroon">text color</span>
+ * bbn.fn.addColors({maroon: '#800000'});
+ * ```
+ * @memberof bbn.fn
+ * @param    {Object} colors
+ * @returns
+ */
+const addColors = function (colors) {
+    if (numProperties(colors)) {
+        if (!bbn.vars.colors) {
+            bbn.vars.colors = {};
+        }
+        let element = document.createElement("style");
+        document.head.appendChild(element);
+        let sheet = element.sheet;
+        // Append style element to head
+        let i = 0;
+        iterate(colors, (v, n) => {
+            bbn.vars.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/style/addStyle.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @ignore
+ * @method   addStyle
+ * @todo     Add method description for addStyle
+ * @global
+ * @memberof bbn.fn
+ * @param    {HTMLElement} ele
+ * @param    {Object}      o
+ * @returns  {*}
+ */
+declare const addStyle: (ele: any, o: any) => void;
+export { addStyle };

package/dist/fn/style/addStyle.js

@@ -0,0 +1,20 @@
+import { isObject } from "../type/isObject";
+import { iterate } from "../loop/iterate";
+/**
+ * @ignore
+ * @method   addStyle
+ * @todo     Add method description for addStyle
+ * @global
+ * @memberof bbn.fn
+ * @param    {HTMLElement} ele
+ * @param    {Object}      o
+ * @returns  {*}
+ */
+const addStyle = function (ele, o) {
+    if (isObject(o)) {
+        iterate(o, (v, k) => {
+            ele.style[k] = v;
+        });
+    }
+};
+export { addStyle };

package/dist/fn/style/animateCss.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @ignore
+ * @method   animateCss
+ * @todo     Add method description for animateCss
+ * @global
+ * @memberof bbn.fn
+ * @param    {HTMLElement} ele
+ * @param    {String}      animationName
+ * @param    {Function}    callback
+ * @returns  {*}
+ */
+declare const animateCss: (ele: any, animationName: any, callback: any) => void;
+export { animateCss };

package/dist/fn/style/animateCss.js

@@ -0,0 +1,31 @@
+/**
+ * @ignore
+ * @method   animateCss
+ * @todo     Add method description for animateCss
+ * @global
+ * @memberof bbn.fn
+ * @param    {HTMLElement} ele
+ * @param    {String}      animationName
+ * @param    {Function}    callback
+ * @returns  {*}
+ */
+const animateCss = function (ele, animationName, callback) {
+    let animationEnd = "webkitAnimationEnd mozAnimationEnd MSAnimationEnd oanimationend animationend";
+    /*$(ele).addClass('animated ' + animationName).one(animationEnd, function(){
+          if ( typeof callback == 'function' ){ // make sure the callback is a function
+            callback.call(this); // brings the scope to the callback
+          }
+          $(this).removeClass('animated ' + animationName);
+        })*/
+    ele.classList.add("animated");
+    ele.classList.add(animationName);
+    ele.addEventListener(animationEnd, (e) => {
+        e.target.removeEventListener(e.type, arguments.callee);
+        if (typeof callback == "function") {
+            // make sure the callback is a function
+            callback.call(this); // brings the scope to the callback
+        }
+        e.target.classList.remove(animationName);
+    });
+};
+export { animateCss };

package/dist/fn/style/center.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Centers the given element by giving it a position absolute.
+ *
+ * @method   center
+ * @global
+ * @example
+ * ```javascript
+ * //<div style="position: absolute; top: 73px; left: 0px;">Documentation</div>
+ * bbn.fn.center('<div>Documentation</div>')
+ * ```
+ * @memberof bbn.fn
+ * @param    {HTMLElement} ele
+ * @returns  {HTMLElement} The dom element with the new style.
+ */
+declare const center: (ele: any) => any;
+export { center };

package/dist/fn/style/center.js

@@ -0,0 +1,40 @@
+/**
+ * Centers the given element by giving it a position absolute.
+ *
+ * @method   center
+ * @global
+ * @example
+ * ```javascript
+ * //<div style="position: absolute; top: 73px; left: 0px;">Documentation</div>
+ * bbn.fn.center('<div>Documentation</div>')
+ * ```
+ * @memberof bbn.fn
+ * @param    {HTMLElement} ele
+ * @returns  {HTMLElement} The dom element with the new style.
+ */
+const center = function (ele) {
+    //ele = $(ele);
+    let parent = ele.parentNode, 
+    //w = parent.width(),
+    w = parent.clientWidth, 
+    //h = parent.height();
+    h = parent.clientHeight;
+    while (parent && (!w || !h)) {
+        /*parent = parent.parent(),
+              w = parent.width(),
+              h = parent.height();*/
+        parent = ele.parentNode;
+        w = parent.clientWidth;
+        h = parent.clientHeight;
+    }
+    //ele.css("position","absolute");
+    ele.style.position = "absolute";
+    //ele.css("top", Math.max(0, ((h - ele.outerHeight()) / 2) + parent.scrollTop()) + "px");
+    ele.style.top =
+        Math.max(0, (h - ele.offsetHeight) / 2 + parent.scrollTop) + "px";
+    //ele.css("left", Math.max(0, ((w - ele.outerWidth()) / 2) + parent.scrollLeft()) + "px");
+    ele.style.left =
+        Math.max(0, (h - ele.offsetWidth) / 2 + parent.scrollLeft) + "px";
+    return ele;
+};
+export { center };

package/dist/fn/style/cssExists.d.ts

@@ -0,0 +1,12 @@
+/**
+ * not used
+ * @ignore
+ * @method   cssExists
+ * @todo     Add method description for cssExists
+ * @global
+ * @memberof bbn.fn
+ * @param    {String} f
+ * @returns
+ */
+declare const cssExists: (f: any) => boolean;
+export { cssExists };

package/dist/fn/style/cssExists.js

@@ -0,0 +1,40 @@
+//import { log } from './log';
+import { escapeRegExp } from "../string/escapeRegExp";
+/**
+ * not used
+ * @ignore
+ * @method   cssExists
+ * @todo     Add method description for cssExists
+ * @global
+ * @memberof bbn.fn
+ * @param    {String} f
+ * @returns
+ */
+const cssExists = function (f) {
+    let ok;
+    let rules;
+    let css = document.styleSheets;
+    for (let 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) {
+            //log(rules);
+            for (let cx = 0; cx < rules.length; cx++) {
+                //log(rules[cx].selectorText);
+                if (new RegExp("(^|\\s)" + escapeRegExp(f) + "(\\{|\\s)", "g").test(rules[cx].selectorText)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+};
+export { cssExists };

package/dist/fn/style/getCssVar.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Gets a CSS variable value
+ * @param {String*} varname
+ * @returns
+ */
+declare const getCssVar: (varname: any) => string;
+export { getCssVar };

package/dist/fn/style/getCssVar.js

@@ -0,0 +1,12 @@
+/**
+ * Gets a CSS variable value
+ * @param {String*} varname
+ * @returns
+ */
+const getCssVar = function (varname) {
+    if (varname.indexOf("--") !== 0) {
+        varname = "--" + varname;
+    }
+    return getComputedStyle(document.documentElement).getPropertyValue(varname);
+};
+export { getCssVar };

package/dist/fn/style/getScrollBarSize.d.ts

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

package/dist/fn/style/getScrollBarSize.js

@@ -0,0 +1,25 @@
+const getScrollBarSize = function () {
+    if (bbn.env.scrollBarSize === undefined) {
+        let outer = document.createElement('div');
+        outer.style.visibility = 'hidden';
+        outer.style.width = '100px';
+        if ('msOverflowStyle' in outer.style) {
+            outer.style.msOverflowStyle = 'scrollbar'; // needed for WinJS apps
+        }
+        document.body.appendChild(outer);
+        let widthNoScroll = outer.offsetWidth;
+        // force scrollbars
+        outer.style.overflow = 'scroll';
+        // add innerdiv
+        let inner = document.createElement('div');
+        inner.style.width = '100%';
+        outer.appendChild(inner);
+        let widthWithScroll = inner.offsetWidth;
+        // remove divs
+        outer.parentNode.removeChild(outer);
+        let sz = widthNoScroll - widthWithScroll;
+        bbn.env.scrollBarSize = sz ? sz + 1 : 0;
+    }
+    return bbn.env.scrollBarSize;
+};
+export { getScrollBarSize };