@bbn/bbn 1.0.59 → 1.0.61

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

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

package/dist/fn/type/isPropSize.js

@@ -0,0 +1,12 @@
+import { each } from '../loop/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/type/isSQLDate.d.ts

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

package/dist/fn/type/isSQLDate.js

@@ -0,0 +1,20 @@
+/**
+ * @ignore
+ * @method   isSQLDate
+ * @todo     Add method description for isSQLDate
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isSQLDate = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (typeof a !== "string" ||
+            !a.match(/^([1-2]\d{3})-((0\d)|(1[12]))-(([0-2]\d)|(3[01]))(?:( [0-2]\d):([0-5]\d):([0-5]\d))?$/)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isSQLDate };

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

@@ -0,0 +1,41 @@
+/**
+  * Checks whether the data contained in the given objects is identical.
+  *
+  * The properties starting with a non alphanumerical character and the
+  * inherited ones are removed for the comparison, then the properties are
+  * compared individually without the order being taken into account.
+  *
+  * @method   isSame
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.isSame(
+  *   {name: "Wonka", fname: "Willy"},
+  *   {fname: "Willy", name: "Wonka"}
+  * );
+  * // true
+  * ```
+  * @example
+  * ```javascript
+  * // Doesn't take into account properties starting with non-alphanumeric characters
+  * bbn.fn.isSame(
+  *   {name: "Wonka", fname: "Willy", _bbn_timestamp: 1587269593987},
+  *   {fname: "Willy", name: "Wonka"}
+  * );
+  * // true
+  * ```
+  * @example
+  * ```javascript
+  * bbn.fn.isSame(
+  *   {name: "Wonka", fname: "Willy", real: false},
+  *   {fname: "Willy", name: "Wonka"}
+  * );
+  * // false
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object} obj1
+  * @param    {Object} obj2
+  * @returns  {Boolean}
+  */
+declare const isSame: (obj1: any, obj2: any, done?: any[]) => boolean;
+export { isSame };

package/dist/fn/type/isSame.js

@@ -0,0 +1,72 @@
+import { hash } from '../string/hash';
+import { each } from '../loop/each';
+/**
+  * Checks whether the data contained in the given objects is identical.
+  *
+  * The properties starting with a non alphanumerical character and the
+  * inherited ones are removed for the comparison, then the properties are
+  * compared individually without the order being taken into account.
+  *
+  * @method   isSame
+  * @global
+  * @example
+  * ```javascript
+  * bbn.fn.isSame(
+  *   {name: "Wonka", fname: "Willy"},
+  *   {fname: "Willy", name: "Wonka"}
+  * );
+  * // true
+  * ```
+  * @example
+  * ```javascript
+  * // Doesn't take into account properties starting with non-alphanumeric characters
+  * bbn.fn.isSame(
+  *   {name: "Wonka", fname: "Willy", _bbn_timestamp: 1587269593987},
+  *   {fname: "Willy", name: "Wonka"}
+  * );
+  * // true
+  * ```
+  * @example
+  * ```javascript
+  * bbn.fn.isSame(
+  *   {name: "Wonka", fname: "Willy", real: false},
+  *   {fname: "Willy", name: "Wonka"}
+  * );
+  * // false
+  * ```
+  * @memberof bbn.fn
+  * @param    {Object} obj1
+  * @param    {Object} obj2
+  * @returns  {Boolean}
+  */
+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();
+        // Case where the keys are different
+        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/type/isString.d.ts

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

package/dist/fn/type/isString.js

@@ -0,0 +1,23 @@
+/**
+ * Returns true if the given argument is a string;
+ * @method   isString
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isString('bbn');
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+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/type/isSymbol.d.ts

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

package/dist/fn/type/isSymbol.js

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

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

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

package/dist/fn/type/isURL.js

@@ -0,0 +1,11 @@
+const isURL = function (...args) {
+    if (!args.length)
+        return false;
+    for (let str of args) {
+        if (!bbn.vars.regexp.url.test(str)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isURL };

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

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

package/dist/fn/type/isValidDimension.js

@@ -0,0 +1,24 @@
+import { isNumber } from "./isNumber";
+import { substr } from "../string/substr";
+/**
+ * Returns true if the given value is a valid CSS dimension string, false otherwise.
+ *
+ * @method   isValidDimension
+ * @global
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns
+ */
+const isValidDimension = function (st) {
+    if (typeof st === "string" &&
+        st.length > 0 &&
+        (st.indexOf("calc") === 0 || isNumber(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/type/isValidName.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Returns true if the given value is a valid name for a function without checking in reserved words, false otherwise
+ * @method   isValidName
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isValidName('$myFunc_tion')
+ * // true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isValidName('7Y')
+ * // false
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isValidName('function')
+ * // true
+ * ```
+ *
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns {Boolean}
+ */
+declare const isValidName: (...args: any[]) => boolean;
+export { isValidName };

package/dist/fn/type/isValidName.js

@@ -0,0 +1,38 @@
+import { isString } from "./isString";
+/**
+ * Returns true if the given value is a valid name for a function without checking in reserved words, false otherwise
+ * @method   isValidName
+ * @global
+ * @example
+ * ```javascript
+ * bbn.fn.isValidName('$myFunc_tion')
+ * // true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isValidName('7Y')
+ * // false
+ * ```
+ *
+ * @example
+ * ```javascript
+ * bbn.fn.isValidName('function')
+ * // true
+ * ```
+ *
+ * @memberof bbn.fn
+ * @param    {String} st
+ * @returns {Boolean}
+ */
+const isValidName = function (...args) {
+    if (!args.length) {
+        return false;
+    }
+    for (let arg of args) {
+        if (!isString(arg) || !/^[$A-Z_][0-9A-Z_$]*$/i.test(arg)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isValidName };

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

@@ -0,0 +1,26 @@
+/**
+ * Returns true if the given argument is not null or type object or array.
+ * @method   isValue
+ * @deprecated
+ * @see bbn.fn.isPrimitive
+ * @example
+ * ```javascript
+ * bbn.fn.isValue('myString');
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isValue(6);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isValue([80,10,22]);
+ * //false
+ * ```
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isValue: (...args: any[]) => boolean;
+export { isValue };

package/dist/fn/type/isValue.js

@@ -0,0 +1,36 @@
+import { isNull } from "./isNull";
+/**
+ * Returns true if the given argument is not null or type object or array.
+ * @method   isValue
+ * @deprecated
+ * @see bbn.fn.isPrimitive
+ * @example
+ * ```javascript
+ * bbn.fn.isValue('myString');
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isValue(6);
+ * //true
+ * ```
+ * @example
+ * ```javascript
+ * bbn.fn.isValue([80,10,22]);
+ * //false
+ * ```
+ * @global
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isValue = function (...args) {
+    if (!args.length)
+        return false;
+    for (let a of args) {
+        if (typeof a === "object" && !isNull(a)) {
+            return false;
+        }
+    }
+    return true;
+};
+export { isValue };

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

@@ -0,0 +1,16 @@
+/**
+ * Returns true if the given argumen is a VueJS object.
+ *
+ * @method   isVue
+ * @global
+ * @example
+ * ```javascript
+ * let myObj =  new Vue({});
+ * bbn.fn.isVue(myObj);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+declare const isVue: (...args: any[]) => boolean;
+export { isVue };

package/dist/fn/type/isVue.js

@@ -0,0 +1,42 @@
+/**
+ * Returns true if the given argumen is a VueJS object.
+ *
+ * @method   isVue
+ * @global
+ * @example
+ * ```javascript
+ * let myObj =  new Vue({});
+ * bbn.fn.isVue(myObj);
+ * //true
+ * ```
+ * @memberof bbn.fn
+ * @returns  {Boolean}
+ */
+const isVue = function (...args) {
+    if (!args.length) {
+        return false;
+    }
+    if ("vue" in bbn && window["Vue"]) {
+        if ("app" in bbn.vue) {
+            for (let a of args) {
+                if (!a || typeof a.render !== "function") {
+                    return false;
+                }
+            }
+        }
+        else {
+            for (let a of args) {
+                if (!(a instanceof window["Vue"])) {
+                    return false;
+                }
+            }
+        }
+    }
+    if ("cp" in bbn &&
+        "isComponent" in bbn["cp"] &&
+        typeof bbn["cp"].isComponent === "function") {
+        return bbn.cp.isComponent(...args);
+    }
+    return true;
+};
+export { isVue };

package/dist/fn.d.ts

@@ -83,8 +83,8 @@ declare const fn: {
     fdatetime: (d?: string | number | Date, wrong_result?: string | boolean) => any;
     fieldValue: (field: any) => any;
     fileExt: (filename: any) => any;
-    filter: (arr: any[], prop: string | object | import("./fn/filterToConditions").Filter | ((a: any, i: string | number | symbol) => boolean), val?: any, operator?: string) => any[];
-    filterToConditions: (filter: any, operator?: string) => import("./fn/filterToConditions").Filter;
+    filter: (arr: any[], prop: string | object | import("./fn/object/filterToConditions").Filter | ((a: any, i: string | number | symbol) => boolean), val?: any, operator?: string) => any[];
+    filterToConditions: (filter: any, operator?: string) => import("./fn/object/filterToConditions").Filter;
     findAll: (arr: any, filter: any, deepProperty: any, res?: any[]) => any[];
     fori: (arr: any[], fn: (a: any, i: number) => any, max?: number, min?: number) => void;
     forir: (arr: any[], fn: (a: any, b: number) => any, max?: number, min?: number) => void;
@@ -152,7 +152,7 @@ declare const fn: {
     isInside: (ele: any, ancestor: any) => boolean;
     isInt: (...args: any[]) => boolean;
     isIP: (...args: any[]) => boolean;
-    isIterable: (v: any) => boolean;
+    isIterable: (...args: any[]) => boolean;
     isMobile: () => boolean;
     isMobileDevice: () => boolean;
     isNull: (...args: any[]) => boolean;
@@ -210,7 +210,7 @@ declare const fn: {
     riterate: (obj: object, fn: (a: any, b: string) => any, noPrivate?: boolean) => object;
     roundDecimal: (value: number, decimals: number) => number;
     sanitize: (str: any, separator?: string) => any;
-    search: (arr: any[], prop: string | object | import("./fn/filterToConditions").Filter | ((a: any, i: string | number | symbol) => boolean), val?: any, operator?: string | number, startFrom?: number) => number;
+    search: (arr: any[], prop: string | object | import("./fn/object/filterToConditions").Filter | ((a: any, i: string | number | symbol) => boolean), val?: any, operator?: string | number, startFrom?: number) => number;
     selectElementText: (ele: HTMLElement, win?: Window) => void;
     selector: (ele: string | HTMLElement) => HTMLElement;
     setCookie: (name: any, value: any, days: any) => void;
@@ -225,7 +225,6 @@ declare const fn: {
     simpleHash1: (str: string) => number;
     simpleHash2: (str: string) => number;
     startChrono: (name: any) => void;
-    stat: (returnStat: any) => void;
     stopChrono: (name: any) => number;
     string2ArrayBuffer: (str: string) => ArrayBuffer;
     submit: (form: HTMLFormElement, e?: Event, fn?: Function) => void;