@bbn/bbn 1.0.59 → 1.0.60

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

@@ -0,0 +1,20 @@
+/**
+ * Takes color in hex format and lightens or darkens it with the given value.
+ * @method   lightenDarkenHex
+ * @global
+ * @example
+ * ```javascript
+ * //"#eccb28"
+ * bbn.fn.lightenDarkenHex('#c4a300', 40);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * //"#9c7b00"
+ * bbn.fn.lightenDarkenHex(#c4a300', -40);
+ * ```
+ * @memberof bbn.fn
+ * @returns  {String}
+ */
+declare const lightenDarkenHex: (hex: any, amt: any) => string;
+export { lightenDarkenHex };

package/dist/fn/style/lightenDarkenHex.js

@@ -0,0 +1,45 @@
+/**
+ * Takes color in hex format and lightens or darkens it with the given value.
+ * @method   lightenDarkenHex
+ * @global
+ * @example
+ * ```javascript
+ * //"#eccb28"
+ * bbn.fn.lightenDarkenHex('#c4a300', 40);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * //"#9c7b00"
+ * bbn.fn.lightenDarkenHex(#c4a300', -40);
+ * ```
+ * @memberof bbn.fn
+ * @returns  {String}
+ */
+const lightenDarkenHex = function (hex, amt) {
+    if (hex && amt) {
+        let ht = hex[0] === "#";
+        hex = ht ? hex.slice(1) : hex;
+        let num = parseInt(hex, 16), r = (num >> 16) + amt, b = ((num >> 8) & 0x00ff) + amt, g = (num & 0x0000ff) + amt;
+        if (r > 255) {
+            r = 255;
+        }
+        else if (r < 0) {
+            r = 0;
+        }
+        if (b > 255) {
+            b = 255;
+        }
+        else if (b < 0) {
+            b = 0;
+        }
+        if (g > 255) {
+            g = 255;
+        }
+        else if (g < 0) {
+            g = 0;
+        }
+        return (ht ? "#" : "") + (g | (b << 8) | (r << 16)).toString(16);
+    }
+};
+export { lightenDarkenHex };

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

@@ -0,0 +1,11 @@
+/**
+ *
+ * @ignore
+ * @method   outerHeight
+ * @todo     Add method description for outerHeight
+ * @global
+ * @memberof bbn.fn
+ * @returns  {*}
+ */
+declare const outerHeight: (ele: HTMLElement) => number | false;
+export { outerHeight };

package/dist/fn/style/outerHeight.js

@@ -0,0 +1,19 @@
+import { selector } from "../html/selector";
+/**
+ *
+ * @ignore
+ * @method   outerHeight
+ * @todo     Add method description for outerHeight
+ * @global
+ * @memberof bbn.fn
+ * @returns  {*}
+ */
+const outerHeight = function (ele) {
+    ele = selector(ele);
+    if (ele && "offsetHeight" in ele) {
+        let styles = window.getComputedStyle(ele);
+        let margin = parseFloat(styles["marginTop"]) + parseFloat(styles["marginBottom"]);
+        return Math.ceil(ele.offsetHeight + margin);
+    }
+};
+export { outerHeight };

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

@@ -0,0 +1,10 @@
+/**
+ * @ignore
+ * @method   outerWidth
+ * @todo     Add method description for outerWidth
+ * @global
+ * @memberof bbn.fn
+ * @returns  {*}
+ */
+declare const outerWidth: (ele: HTMLElement) => number | false;
+export { outerWidth };

package/dist/fn/style/outerWidth.js

@@ -0,0 +1,16 @@
+import { selector } from "../html/selector";
+/**
+ * @ignore
+ * @method   outerWidth
+ * @todo     Add method description for outerWidth
+ * @global
+ * @memberof bbn.fn
+ * @returns  {*}
+ */
+const outerWidth = function (ele) {
+    ele = selector(ele);
+    let styles = window.getComputedStyle(ele);
+    let margin = parseFloat(styles["marginLeft"]) + parseFloat(styles["marginRight"]);
+    return Math.ceil(ele.offsetWidth + margin);
+};
+export { outerWidth };

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

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

package/dist/fn/style/resize.js

@@ -0,0 +1,39 @@
+import { getCssVar } from './getCssVar';
+import { each } from '../loop/each';
+import { defaultResizeFunction } from '../default/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 = parseInt(getCssVar('mobile-limit')) || 650;
+        let newCls = 'bbn-screen-' + (bbn.env.width < 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/style/setCssVar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a CSS variable
+ * @param {String*} varname
+ * @param {String*} value
+ * @returns
+ */
+declare const setCssVar: (varname: any, value: any) => void;
+export { setCssVar };

package/dist/fn/style/setCssVar.js

@@ -0,0 +1,14 @@
+/**
+ * Creates a CSS variable
+ * @param {String*} varname
+ * @param {String*} value
+ * @returns
+ */
+const setCssVar = function (varname, value) {
+    if (varname.indexOf("--") !== 0) {
+        varname = "--" + varname;
+    }
+    /** @todo To Fix */
+    document.documentElement.style.setProperty(varname, value);
+};
+export { setCssVar };

package/dist/fn/type/checkType.d.ts

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

package/dist/fn/type/checkType.js

@@ -0,0 +1,59 @@
+import { isArray } from './isArray';
+import { each } from '../loop/each';
+import { isFunction } from './isFunction';
+import { isString } from './isString';
+import { correctCase } from '../string/correctCase';
+import { error } from '../browser/error';
+import { log } from '../browser/log';
+const checkType = function (value, type, msg, ...logs) {
+    let ok = false;
+    if (!isArray(type)) {
+        type = [type];
+    }
+    const typesList = [];
+    each(type, (t) => {
+        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 || t.constructor?.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/type/isArray.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns true if the given argument is array.
+ * @method   isArray
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isArray([5,2,6]);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isArray: (...args: any[]) => boolean;
+export { isArray };

package/dist/fn/type/isArray.js

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the given argument is array.
+ * @method   isArray
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isArray([5,2,6]);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isArray = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (!Array.isArray(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isArray };

package/dist/fn/type/isBlob.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @method   isBlob
+ * @todo     Add method description for isFunction
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isBlob: (...args: any[]) => boolean;
+export { isBlob };

package/dist/fn/type/isBlob.js

@@ -0,0 +1,18 @@
+/**
+ * @method   isBlob
+ * @todo     Add method description for isFunction
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isBlob = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if ({}.toString.apply(a) !== "[object Blob]") {
+            return false;
+        }
+    }
+    return true;
+};
+export { isBlob };

package/dist/fn/type/isBoolean.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns true if the given argument is a boolean
+ * @method   isBoolean
+ * @global
+ * @example
+ * ```javascript
+ * const sb = true;
+ * bbn.fn.isBoolean(sb); // true
+ * const sb = 1;
+ * bbn.fn.isBoolean(sb); // false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isBoolean: (...args: any[]) => boolean;
+export { isBoolean };

package/dist/fn/type/isBoolean.js

@@ -0,0 +1,25 @@
+/**
+ * Returns true if the given argument is a boolean
+ * @method   isBoolean
+ * @global
+ * @example
+ * ```javascript
+ * const sb = true;
+ * bbn.fn.isBoolean(sb); // true
+ * const sb = 1;
+ * bbn.fn.isBoolean(sb); // false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isBoolean = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (![true, false].includes(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isBoolean };

package/dist/fn/type/isCanvas.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns true if the given argumen is a Canvas.
+ *
+ * @method   isCanvas
+ * @global
+ * @example
+ * ```javascript
+ * let myCanvas = document.createElement('canvas');
+ * bbn.fn.isCanvas(myCanvas);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isCanvas: (...args: any[]) => boolean;
+export { isCanvas };

package/dist/fn/type/isCanvas.js

@@ -0,0 +1,25 @@
+/**
+ * Returns true if the given argumen is a Canvas.
+ *
+ * @method   isCanvas
+ * @global
+ * @example
+ * ```javascript
+ * let myCanvas = document.createElement('canvas');
+ * bbn.fn.isCanvas(myCanvas);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isCanvas = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (!(a instanceof HTMLCanvasElement)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isCanvas };

package/dist/fn/type/isColor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Intended to check if the argument provided is a color.
+ *
+ * It is possible to pass as argument a string with hexadecimal value in rgb or the name of the color.
+ *
+ * @method   isColor
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isColor("#FF0000")
+ * //true
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isColor("rgb 255, 0, 0");
+ * //true
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isColor("red");
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns  {Boolean}
+ */
+declare const isColor: (...args: any[]) => boolean;
+export { isColor };

package/dist/fn/type/isColor.js

@@ -0,0 +1,45 @@
+import { isString } from "./isString";
+/**
+ * Intended to check if the argument provided is a color.
+ *
+ * It is possible to pass as argument a string with hexadecimal value in rgb or the name of the color.
+ *
+ * @method   isColor
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isColor("#FF0000")
+ * //true
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isColor("rgb 255, 0, 0");
+ * //true
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isColor("red");
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns  {Boolean}
+ */
+const isColor = function (...args) {
+    if (!args.length)
+        return false;
+    var reg = new RegExp("^(#[a-f0-9]{6}|#[a-f0-9]{3}|rgb *( *[0-9]{1,3}%? *, *[0-9]{1,3}%? *, *[0-9]{1,3}%? *)|rgba *( *[0-9]{1,3}%? *, *[0-9]{1,3}%? *, *[0-9]{1,3}%? *, *[0-9]{1,3}%? *)|black|green|silver|gray|olive|white|yellow|maroon|navy|red|blue|purple|teal|fuchsia|aqua)$", "i");
+    for (let st of args) {
+        if (!isString(st)) {
+            return false;
+        }
+        if (!reg.test(st)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isColor };

package/dist/fn/type/isComment.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns true if the given argument is a dom comment;
+ * @method   isComment
+ * @example
+ * ```javascript
+ * bbn.fn.isComment(node.childNodes[0]);
+ * //true
+ * ```
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isComment: (...args: any[]) => boolean;
+export { isComment };

package/dist/fn/type/isComment.js

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the given argument is a dom comment;
+ * @method   isComment
+ * @example
+ * ```javascript
+ * bbn.fn.isComment(node.childNodes[0]);
+ * //true
+ * ```
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isComment = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (!(a instanceof Comment)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isComment };

package/dist/fn/type/isCp.d.ts

@@ -0,0 +1,2 @@
+declare const isCp: (...args: any[]) => boolean;
+export { isCp };

package/dist/fn/type/isCp.js

@@ -0,0 +1,17 @@
+import { isDom } from './isDom';
+const isCp = function (...args) {
+    if (!args.length) {
+        return false;
+    }
+    if ('cp' in bbn && 'isComponent' in bbn['cp'] && (typeof bbn['cp'].isComponent === 'function')) {
+        for (let a of args) {
+            let res = bbn.cp.isComponent(a);
+            if (!res || isDom(res) || !res.$el) {
+                return false;
+            }
+        }
+        return false;
+    }
+    return true;
+};
+export { isCp };

package/dist/fn/type/isDate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns true if the given argument is a date object.
+ * @method   isDate
+ * @global
+ * @example
+ * ```javascript
+ * let date = new Date();
+ * bbn.fn.isDate(date);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isDate('16/04/2020');
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isDate: (...args: any[]) => boolean;
+export { isDate };

package/dist/fn/type/isDate.js

@@ -0,0 +1,29 @@
+/**
+ * Returns true if the given argument is a date object.
+ * @method   isDate
+ * @global
+ * @example
+ * ```javascript
+ * let date = new Date();
+ * bbn.fn.isDate(date);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isDate('16/04/2020');
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isDate = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if ({}.toString.apply(a) !== "[object Date]") {
+            return false;
+        }
+    }
+    return true;
+};
+export { isDate };

package/dist/fn/type/isDimension.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns true if the given value is a valid CSS dimension string or a number, false otherwise.
+ *
+ * @method   isDimension
+ * @global
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns
+ */
+declare const isDimension: (...args: any[]) => boolean;
+export { isDimension };

package/dist/fn/type/isDimension.js

@@ -0,0 +1,24 @@
+import { isValidDimension } from "./isValidDimension";
+/**
+ * Returns true if the given value is a valid CSS dimension string or a number, false otherwise.
+ *
+ * @method   isDimension
+ * @global
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns
+ */
+const isDimension = function (...args) {
+    if (!args.length)
+        return false;
+    for (let st of args) {
+        if (typeof st !== "number" || st < 0) {
+            return false;
+        }
+        if (!isValidDimension(st)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isDimension };

package/dist/fn/type/isDom.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns true if the given argument is a dom element;
+ * @method   isDom
+ * @example
+ * ```javascript
+ * bbn.fn.isDom(document.body.childNodes[0]);
+ * //true
+ * ```
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isDom: (...args: any[]) => boolean;
+export { isDom };