@bbn/bbn 1.0.12 → 1.0.14

package/dist/fn/isEmail.d.ts

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

package/dist/fn/isEmail.js

@@ -0,0 +1,9 @@
+import { isString } from './isString';
+const isEmail = function (st) {
+    if (!isString(st)) {
+        return false;
+    }
+    let regex = /^([a-zA-Z0-9_.+-])+\@(([a-zA-Z0-9-])+\.)+([a-zA-Z0-9]{2,4})+$/;
+    return regex.test(st);
+};
+export { isEmail };

package/dist/fn/isEmpty.d.ts

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

package/dist/fn/isEmpty.js

@@ -0,0 +1,18 @@
+import { isArray } from './isArray';
+import { numProperties } from './numProperties';
+const isEmpty = function (obj) {
+    if (!obj) {
+        return true;
+    }
+    if (isArray(obj)) {
+        return obj.length ? false : true;
+    }
+    if (typeof (obj) === 'object') {
+        if (numProperties(obj)) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+};
+export { isEmpty };

package/dist/fn/isEvent.d.ts

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

package/dist/fn/isEvent.js

@@ -0,0 +1,11 @@
+const isEvent = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if (!(a instanceof Event)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isEvent };

package/dist/fn/isFocused.d.ts

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

package/dist/fn/isFocused.js

@@ -0,0 +1,2 @@
+const isFocused = function (ele, contain) { return (ele === document.activeElement) || (contain && ele.contains && (ele.contains(document.activeElement))); };
+export { isFocused };

package/dist/fn/isFunction.d.ts

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

package/dist/fn/isFunction.js

@@ -0,0 +1,11 @@
+const isFunction = function () {
+    if (!arguments.length)
+        return false;
+    for (let obj of arguments) {
+        if (!(obj && obj.constructor && obj.call && obj.apply)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isFunction };

package/dist/fn/isHostname.d.ts

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

package/dist/fn/isHostname.js

@@ -0,0 +1,12 @@
+import { bbn } from '../definitions';
+import { isString } from './isString';
+import { isIP } from './isIP';
+const isHostname = function (st) {
+    if (isString(st)) {
+        if (isIP(st)) {
+            return true;
+        }
+        return bbn.var.regexp.hostname.test(st);
+    }
+};
+export { isHostname };

package/dist/fn/isIP.d.ts

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

package/dist/fn/isIP.js

@@ -0,0 +1,6 @@
+import { bbn } from '../definitions';
+import { isString } from './isString';
+const isIP = function (st) { if (isString(st)) {
+    return bbn.var.regexp.ip.test(st);
+} };
+export { isIP };

package/dist/fn/isInside.d.ts

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

package/dist/fn/isInside.js

@@ -0,0 +1,21 @@
+import { getAncestors } from './getAncestors';
+import { isString } from './isString';
+import { each } from './each';
+const isInside = function (ele, ancestor) {
+    let ancestors = getAncestors(ele);
+    if (ancestors.length) {
+        if (isString(ancestor)) {
+            let ok = false;
+            each(ancestors, a => { if (a.matches && a.matches(ancestor)) {
+                ok = true;
+                return false;
+            } });
+            return ok;
+        }
+        if (ancestor instanceof HTMLElement) {
+            return ancestors.indexOf(ancestor) > -1;
+        }
+    }
+    return false;
+};
+export { isInside };

package/dist/fn/isInt.d.ts

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

package/dist/fn/isInt.js

@@ -0,0 +1,11 @@
+const isInt = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if (!Number.isInteger(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isInt };

package/dist/fn/isIterable.d.ts

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

package/dist/fn/isIterable.js

@@ -0,0 +1,2 @@
+const isIterable = function (v) { return v && (typeof v === 'object') && (Symbol.iterator in Object(v)); };
+export { isIterable };

package/dist/fn/isMobile.d.ts

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

package/dist/fn/isMobile.js

@@ -0,0 +1,4 @@
+import { isMobileDevice } from './isMobileDevice';
+import { isTabletDevice } from './isTabletDevice';
+const isMobile = function () { return isMobileDevice() || isTabletDevice(); };
+export { isMobile };

package/dist/fn/isMobileDevice.d.ts

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

package/dist/fn/isMobileDevice.js

@@ -0,0 +1,2 @@
+const isMobileDevice = function () { return this.getDeviceType() === 'mobile'; };
+export { isMobileDevice };

package/dist/fn/isNull.d.ts

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

package/dist/fn/isNull.js

@@ -0,0 +1,11 @@
+const isNull = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ({}.toString.apply(a) !== '[object Null]') {
+            return false;
+        }
+    }
+    return true;
+};
+export { isNull };

package/dist/fn/isNumber.d.ts

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

package/dist/fn/isNumber.js

@@ -0,0 +1,11 @@
+const isNumber = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if (['boolean', 'object', 'symbol'].includes(typeof a) || (a === '') || isNaN(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isNumber };

package/dist/fn/isObject.d.ts

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

package/dist/fn/isObject.js

@@ -0,0 +1,11 @@
+const isObject = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ({}.toString.apply(a) !== '[object Object]') {
+            return false;
+        }
+    }
+    return true;
+};
+export { isObject };

package/dist/fn/isPercent.d.ts

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

package/dist/fn/isPercent.js

@@ -0,0 +1,11 @@
+const isPercent = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ((typeof a !== 'string') || !a.match(/^\d+(?:\.\d+)?%$/)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isPercent };

package/dist/fn/isPrimitive.d.ts

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

package/dist/fn/isPrimitive.js

@@ -0,0 +1,11 @@
+const isPrimitive = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ((a !== null) && ((typeof a == "object") || (typeof a == "function"))) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isPrimitive };

package/dist/fn/isPromise.d.ts

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

package/dist/fn/isPromise.js

@@ -0,0 +1,11 @@
+const isPromise = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ({}.toString.apply(a) !== '[object Promise]') {
+            return false;
+        }
+    }
+    return true;
+};
+export { isPromise };

package/dist/fn/isPropSize.d.ts

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

package/dist/fn/isPropSize.js

@@ -0,0 +1,6 @@
+import { each } from './each';
+const isPropSize = function (name) { let isTrue = false; each(['width', 'height', 'gap', 'margin', 'padding', 'top', 'left', 'right', 'bottom'], a => { if (name.indexOf(a) !== -1) {
+    isTrue = true;
+    return false;
+} }); return isTrue; };
+export { isPropSize };

package/dist/fn/isSQLDate.d.ts

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

package/dist/fn/isSQLDate.js

@@ -0,0 +1,11 @@
+const isSQLDate = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ((typeof a !== 'string') || !a.match(/^([1-2]\d{3})-((0[0-9])|(1[12]))-(([0-2][0-9])|(3[01]))(?:( [0-2][0-9]):([0-5][0-9]):([0-5][0-9]))?$/)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isSQLDate };

package/dist/fn/isSame.d.ts

@@ -0,0 +1,3 @@
+import { isSame } from './isSame';
+declare const isSame: (obj1: any, obj2: any, done: any) => boolean;
+export { isSame };

package/dist/fn/isSame.js

@@ -0,0 +1,30 @@
+import { hash } from './hash';
+import { each } from './each';
+const isSame = function (obj1, obj2, done) {
+    if (!done) {
+        done = [];
+    }
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 && obj2 && (typeof (obj1) === 'object') && (typeof (obj2) === 'object')) {
+        let tmp1 = Object.keys(obj1).sort(), tmp2 = Object.keys(obj2).sort();
+        if (hash(tmp1) !== hash(tmp2)) {
+            return false;
+        }
+        let ok = true;
+        if (obj1 && (typeof obj1 === 'object')) {
+            if (done.includes(obj1)) {
+                return ok;
+            }
+            done.push(obj1);
+        }
+        each(tmp1, a => { if (!isSame(obj1[a], obj2[a])) {
+            ok = false;
+            return false;
+        } });
+        return ok;
+    }
+    return false;
+};
+export { isSame };

package/dist/fn/isString.d.ts

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

package/dist/fn/isString.js

@@ -0,0 +1,11 @@
+const isString = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if ({}.toString.apply(a) !== '[object String]') {
+            return false;
+        }
+    }
+    return true;
+};
+export { isString };

package/dist/fn/isSymbol.d.ts

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

package/dist/fn/isSymbol.js

@@ -0,0 +1,11 @@
+const isSymbol = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ({}.toString.apply(a) !== '[object Symbol]') {
+            return false;
+        }
+    }
+    return true;
+};
+export { isSymbol };

package/dist/fn/isTabletDevice.d.ts

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

package/dist/fn/isTabletDevice.js

@@ -0,0 +1,2 @@
+const isTabletDevice = function () { return this.getDeviceType() === 'tablet'; };
+export { isTabletDevice };

package/dist/fn/isURL.d.ts

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

package/dist/fn/isURL.js

@@ -0,0 +1,3 @@
+import { bbn } from '../definitions';
+const isURL = function (str) { return bbn.var.regexp.url.test(str); };
+export { isURL };

package/dist/fn/isValidDimension.d.ts

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

package/dist/fn/isValidDimension.js

@@ -0,0 +1,12 @@
+import { substr } from './substr';
+const isValidDimension = function (st) {
+    if ((typeof (st) === 'string') && (st.length > 0) && ((st.indexOf('calc') === 0) || (!isNaN(substr(st, 0, 1))))) {
+        let el = document.createElement('div');
+        el.style.width = st;
+        let res = !!el.style.width.length;
+        el.remove();
+        return res;
+    }
+    return false;
+};
+export { isValidDimension };

package/dist/fn/isValidName.d.ts

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

package/dist/fn/isValidName.js

@@ -0,0 +1,13 @@
+import { isString } from './isString';
+const isValidName = function (st) {
+    if (!st) {
+        return false;
+    }
+    for (let arg of arguments) {
+        if (!isString(arg) || !/^[$A-Z_][0-9A-Z_$]*$/i.test(arg)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isValidName };

package/dist/fn/isValue.d.ts

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

package/dist/fn/isValue.js

@@ -0,0 +1,12 @@
+import { isNull } from './isNull';
+const isValue = function () {
+    if (!arguments.length)
+        return false;
+    for (let a of arguments) {
+        if ((typeof a === 'object') && !isNull(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isValue };

package/dist/fn/isVue.d.ts

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

package/dist/fn/isVue.js

@@ -0,0 +1,27 @@
+import { bbn } from '../definitions';
+const isVue = function () {
+    if (!arguments.length) {
+        return false;
+    }
+    if (Object.hasOwn(bbn, 'vue')) {
+        if (bbn.vue.app) {
+            for (let a of arguments) {
+                if (!a || (typeof a.render !== 'function')) {
+                    return false;
+                }
+            }
+        }
+        else {
+            for (let a of arguments) {
+                if (!(a instanceof Vue)) {
+                    return false;
+                }
+            }
+        }
+    }
+    if (Object.hasOwn(bbn, 'cp')) {
+        return bbn.cp.isComponent(...arguments);
+    }
+    return true;
+};
+export { isVue };

package/dist/fn/iterate.d.ts

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

package/dist/fn/iterate.js

@@ -0,0 +1,15 @@
+import { removePrivateProp } from './removePrivateProp';
+import { each } from './each';
+const iterate = function (obj, fn, noPrivate, reverse) {
+    if ((obj !== null) && (typeof obj === 'object')) {
+        let iter = Object.keys(noPrivate ? removePrivateProp(obj) : obj);
+        if (reverse) {
+            iter.reverse();
+        }
+        each(iter, prop => { if (fn(obj[prop], prop) === false) {
+            return false;
+        } });
+    }
+    return obj;
+};
+export { iterate };

package/dist/fn/lightenDarkenHex.d.ts

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

package/dist/fn/lightenDarkenHex.js

@@ -0,0 +1,27 @@
+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/link.d.ts

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

package/dist/fn/link.js

@@ -0,0 +1,87 @@
+import { bbn } from '../definitions';
+import { treatAjaxArguments } from './treatAjaxArguments';
+import { getLoader } from './getLoader';
+import { defaultPreLinkFunction } from './defaultPreLinkFunction';
+import { extend } from './extend';
+import { ajax } from './ajax';
+import { log } from './log';
+import { isObject } from './isObject';
+import { callback } from './callback';
+import { setNavigationVars } from './setNavigationVars';
+const link = function () {
+    let cfg = treatAjaxArguments(arguments), ok = 1;
+    if (cfg === true) {
+        return true;
+    }
+    if (!cfg) {
+        return link(window.location.href);
+    }
+    if (cfg.url.indexOf('javascript:') === 0) {
+        return true;
+    }
+    if (cfg.url.indexOf('data:') === 0) {
+        return true;
+    }
+    if (cfg.url.indexOf('#') === 0) {
+        location.href = bbn.env.url + cfg.url;
+        return true;
+    }
+    else if (cfg.url.indexOf('mailto:') === 0) {
+        bbn.env.ignoreUnload = true;
+        window.location.href = cfg.url;
+        setTimeout(() => { bbn.env.ignoreUnload = false; }, 0);
+        return false;
+    }
+    if (getLoader(cfg.url)) {
+        return false;
+    }
+    if (((cfg.url.indexOf("http://") === 0) || (cfg.url.indexOf("https://") === 0)) && (cfg.url.indexOf(bbn.env.host) !== 0)) {
+        if (cfg.e) {
+            cfg.e.preventDefault();
+        }
+        window.open(cfg.url);
+        return false;
+    }
+    else if ((cfg.url !== bbn.env.params.join("/")) || (cfg.force === 1)) {
+        if (cfg.successFn) {
+            ok = cfg.successFn(cfg.url);
+        }
+        else if (defaultPreLinkFunction) {
+            ok = defaultPreLinkFunction(cfg.url, cfg.force, cfg.ele);
+            if (ok.data !== undefined) {
+                extend(cfg.obj, ok.data);
+                ok = 1;
+            }
+        }
+        if (ok) {
+            if (ok !== 1 && (typeof ok === 'string')) {
+                cfg.url = ok;
+            }
+            let errSt = bbn._("The Ajax call to") + ' ' + cfg.url + ' ';
+            return ajax(cfg.url, cfg.datatype, cfg.obj, function (res) {
+                if (!res) {
+                    log(errSt + bbn._("returned no answer"));
+                }
+                if (isObject(res)) {
+                    if ((Object.keys(res).length === 0)) {
+                        log(errSt + bbn._("returned an empty object"));
+                    }
+                    if (res.new_url) {
+                        res.old_path = cfg.url;
+                        cfg.url = res.new_url;
+                    }
+                    else if (res.url && (cfg.url !== res.url)) {
+                        res.old_path = cfg.url;
+                    }
+                }
+                if (callback(cfg.url, res, cfg.successFn, null, cfg.ele) && res.noNav === undefined) {
+                    if (bbn.env.path.indexOf(cfg.url) !== 0) {
+                        setNavigationVars(cfg.url, (res.title ? res.title + ' - ' : '') + bbn.env.siteTitle);
+                    }
+                }
+            }, cfg.errorFn || null);
+        }
+    }
+    return true;
+};
+export { link };

package/dist/fn/log.d.ts

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