@bbn/bbn 1.0.59 → 1.0.60

package/dist/fn/type/isDom.js

@@ -0,0 +1,23 @@
+/**
+ * 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}
+ */
+const isDom = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (!(a instanceof HTMLElement)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isDom };

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

@@ -0,0 +1,23 @@
+/**
+ * Intended to check if the argument provided is an e-mail address written correctly
+ *
+ * @method   isEmail
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isEmail('test@testorg');
+ * //false
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isEmail('test@test.org');
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns  {Boolean}
+ */
+declare const isEmail: (...args: any[]) => boolean;
+export { isEmail };

package/dist/fn/type/isEmail.js

@@ -0,0 +1,37 @@
+import { isString } from "./isString";
+/**
+ * Intended to check if the argument provided is an e-mail address written correctly
+ *
+ * @method   isEmail
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isEmail('test@testorg');
+ * //false
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isEmail('test@test.org');
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns  {Boolean}
+ */
+const isEmail = function (...args) {
+    if (!args.length)
+        return false;
+    let regex = /^([a-zA-Z0-9_.+-])+\@(([a-zA-Z0-9-])+\.)+([a-zA-Z0-9]{2,4})+$/;
+    for (let st of args) {
+        if (!isString(st)) {
+            return false;
+        }
+        if (!regex.test(st)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isEmail };

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

@@ -0,0 +1,41 @@
+/**
+ * Checks if the argument is empty or not.
+ * @method   isEmpty
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty({});
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty({test : 1});
+ * //false
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty([]);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty(['test']);
+ * //false
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty('');
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty('test');
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @param    {*} obj
+ * @returns  {Boolean}
+ */
+declare const isEmpty: (obj: any) => boolean;
+export { isEmpty };

package/dist/fn/type/isEmpty.js

@@ -0,0 +1,57 @@
+import { isArray } from "./isArray";
+import { numProperties } from "../object/numProperties";
+/**
+ * Checks if the argument is empty or not.
+ * @method   isEmpty
+ * @global
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty({});
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty({test : 1});
+ * //false
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty([]);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty(['test']);
+ * //false
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty('');
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isEmpty('test');
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @param    {*} obj
+ * @returns  {Boolean}
+ */
+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/type/isEvent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns true if the given argument is an event.
+ * @method   isEvent
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isEvent: (...args: any[]) => boolean;
+export { isEvent };

package/dist/fn/type/isEvent.js

@@ -0,0 +1,18 @@
+/**
+ * Returns true if the given argument is an event.
+ * @method   isEvent
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isEvent = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (!(a instanceof Event)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isEvent };

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

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

package/dist/fn/type/isFunction.js

@@ -0,0 +1,25 @@
+/**
+ * Returns true if the given argument is a function.
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isFunction(() => {
+ *  alert('Hello world');
+ * });
+ * //true
+ * ```
+ * @method   isFunction
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isFunction = function (...args) {
+    if (!args.length)
+        return false;
+    for (let obj of args) {
+        if (!(obj && obj.constructor && obj.call && obj.apply)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isFunction };

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

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

package/dist/fn/type/isHostname.js

@@ -0,0 +1,16 @@
+import { isString } from './isString';
+import { isIP } from './isIP';
+const isHostname = function (...args) {
+    if (!args.length)
+        return false;
+    for (let st of args) {
+        if (!isString(st)) {
+            return false;
+        }
+        if (!isIP(st) && !bbn.vars.regexp.hostname.test(st)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isHostname };

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

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

package/dist/fn/type/isIP.js

@@ -0,0 +1,12 @@
+import { isString } from './isString';
+const isIP = function (...args) {
+    if (!args.length)
+        return false;
+    for (let st of args) {
+        if (!isString(st) || !bbn.vars.regexp.ip.test(st)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isIP };

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

@@ -0,0 +1,18 @@
+/**
+ * Returns true if the given argument is an integer
+ * @method   isInt
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isInt(5);
+ * // true
+ * bbn.fn.isInt(0.5);
+ * // false
+ * bbn.fn.isInt("hello");
+ * // false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isInt: (...args: any[]) => boolean;
+export { isInt };

package/dist/fn/type/isInt.js

@@ -0,0 +1,27 @@
+/**
+ * Returns true if the given argument is an integer
+ * @method   isInt
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isInt(5);
+ * // true
+ * bbn.fn.isInt(0.5);
+ * // false
+ * bbn.fn.isInt("hello");
+ * // false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isInt = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (!Number.isInteger(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isInt };

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

@@ -0,0 +1,27 @@
+/**
+ * Returns true if the given object can be iterated as an array (numerically).
+ *
+ * It is possible to pass as argument a string with hexadecimal value in rgb or the name of the color.
+ *
+ * @method   isIterable
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isIterable([1, 2])
+ * // true
+ * bbn.fn.isIterable({a: 1, b: 2})
+ * // false
+ * bbn.fn.isIterable(25)
+ * // false
+ * bbn.fn.isIterable(document.body.querySelectorAll('.container > div'))
+ * // true
+ * ```
+ *
+ * @param    {String} st
+ *
+ * @returns  {Boolean}
+ */
+declare const isIterable: (...args: any[]) => boolean;
+export { isIterable };

package/dist/fn/type/isIterable.js

@@ -0,0 +1,37 @@
+/**
+ * Returns true if the given object can be iterated as an array (numerically).
+ *
+ * It is possible to pass as argument a string with hexadecimal value in rgb or the name of the color.
+ *
+ * @method   isIterable
+ * @global
+ * @memberof bbn.fn
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isIterable([1, 2])
+ * // true
+ * bbn.fn.isIterable({a: 1, b: 2})
+ * // false
+ * bbn.fn.isIterable(25)
+ * // false
+ * bbn.fn.isIterable(document.body.querySelectorAll('.container > div'))
+ * // true
+ * ```
+ *
+ * @param    {String} st
+ *
+ * @returns  {Boolean}
+ */
+const isIterable = function (...args) {
+    if (!args.length) {
+        return false;
+    }
+    for (let i = 0; i < args.length; i++) {
+        if (!args[i] || !(typeof args[i] === "object") || Symbol.iterator in Object(args[i])) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isIterable };

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

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

package/dist/fn/type/isNull.js

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the given argument is null;
+ * @method   isNull
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isNull(myData);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isNull = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if ({}.toString.apply(a) !== "[object Null]") {
+            return false;
+        }
+    }
+    return true;
+};
+export { isNull };

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

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

package/dist/fn/type/isNumber.js

@@ -0,0 +1,30 @@
+/**
+ * Returns true if the given argument is a number
+ * @method   isNumber
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isNumber(5);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isNumber(0.5);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isNumber = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (["boolean", "object", "symbol"].includes(typeof a) ||
+            a === "" ||
+            isNaN(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isNumber };

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

@@ -0,0 +1,19 @@
+/**
+ * Returns true if the given argument is an object.
+ * @method   isObject
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isObject({name: 'cami', age: 7});
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isObject([{name: 'cami', age: 7}]);
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isObject: (...args: any[]) => boolean;
+export { isObject };

package/dist/fn/type/isObject.js

@@ -0,0 +1,28 @@
+/**
+ * Returns true if the given argument is an object.
+ * @method   isObject
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isObject({name: 'cami', age: 7});
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isObject([{name: 'cami', age: 7}]);
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isObject = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if ({}.toString.apply(a) !== "[object Object]") {
+            return false;
+        }
+    }
+    return true;
+};
+export { isObject };

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

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

package/dist/fn/type/isPercent.js

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the given argument is a percentage.
+ * @method   isPercent
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isPercent('5%');
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isPercent = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (typeof a !== "string" || !a.match(/^\d+(?:\.\d+)?%$/)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isPercent };

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

@@ -0,0 +1,18 @@
+/**
+ * Returns true if the given arguments are primitive;
+ * @method   isPrimitive
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isPrimitive('myString', 6, true);
+ * //true
+ * bbn.fn.isPrimitive([80,10,22]);
+ * //false
+ * bbn.fn.isPrimitive({});
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isPrimitive: (...args: any[]) => boolean;
+export { isPrimitive };

package/dist/fn/type/isPrimitive.js

@@ -0,0 +1,27 @@
+/**
+ * Returns true if the given arguments are primitive;
+ * @method   isPrimitive
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isPrimitive('myString', 6, true);
+ * //true
+ * bbn.fn.isPrimitive([80,10,22]);
+ * //false
+ * bbn.fn.isPrimitive({});
+ * //false
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isPrimitive = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (a !== null && (typeof a == "object" || typeof a == "function")) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isPrimitive };

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

@@ -0,0 +1,18 @@
+/**
+ * Returns true if the given argument is a promise.
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isPromise(bbn.fn.post('myUrl'));
+ * // true
+ * bbn.fn.isPromise(setTimeout(() => {}))
+ * // false
+ * bbn.fn.isPromise(myVueObject.$nextTick());
+ * // true
+ * ```
+ * @method   isFunction
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isPromise: (...args: any[]) => boolean;
+export { isPromise };

package/dist/fn/type/isPromise.js

@@ -0,0 +1,27 @@
+/**
+ * Returns true if the given argument is a promise.
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isPromise(bbn.fn.post('myUrl'));
+ * // true
+ * bbn.fn.isPromise(setTimeout(() => {}))
+ * // false
+ * bbn.fn.isPromise(myVueObject.$nextTick());
+ * // true
+ * ```
+ * @method   isFunction
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isPromise = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if ({}.toString.apply(a) !== "[object Promise]") {
+            return false;
+        }
+    }
+    return true;
+};
+export { isPromise };

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

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