@brandup/ui-helpers 1.0.3 → 1.0.4

package/dist/cjs/index.js

@@ -1,166 +1,117 @@
 'use strict';
 
-class Utility {
-    static arrayToObject(array) {
-        if (array) {
-            const result = {};
-            for (let i = 0; i < array.length; i++)
-                result[array[i].Key] = array[i].Value;
-            return result;
-        }
-        return null;
-    }
-    static objectToArray(obj) {
-        if (!obj)
-            return null;
-        const result = new Array();
-        for (const key in obj)
-            result.push({ Key: key, Value: obj[key] });
-        return result;
-    }
-    static getWordEnd(count, word, one, two, five) {
-        const tt = count % 100;
-        if (tt >= 5 && tt <= 20)
-            return word + (Utility.isString(five) ? five : "");
-        const t = count % 10;
-        return (t === 1 ?
-            (word + (Utility.isString(one) ? one : "")) :
-            ((t >= 2 && t <= 4) ?
-                (word + (Utility.isString(two) ? two : "")) :
-                (word + (Utility.isString(five) ? five : ""))));
-    }
-    static isString(value) {
-        return (typeof value === "string" || value instanceof String);
-    }
-    static isArray(value) {
-        return (value instanceof Array);
-    }
-    static isUndefined(value) {
-        return (typeof value === "undefined");
-    }
-    static isFunction(value) {
-        return (typeof value === "function");
-    }
-    static isPlainObject(obj) {
-        if (!obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval) {
+function hasProperty(obj, property) {
+    if (!obj)
+        return false;
+    const props = property.split(".");
+    let t = obj;
+    for (let i = 0; i < props.length; i++) {
+        if (!t)
             return false;
-        }
-        if (obj.constructor && !obj.hasOwnProperty.call(obj, "constructor") && !obj.hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf")) {
+        const pName = props[i];
+        if (!(pName in t))
             return false;
-        }
-        let key;
-        for (key in obj) {
-            continue;
-        }
-        return key === undefined || obj.hasOwnProperty.call(obj, key);
-    }
-    static joinString(separator, items) {
-        if (!Utility.isArray(items))
-            throw "Param items is not array.";
-        let str = "";
-        for (let i = 0; i < items.length; i++)
-            str += (i > 0 ? separator : "") + items[i];
-        return str;
-    }
-    static stringIsNullOrEmpty(str) {
-        return !Utility.isString(str) || str === null || str === "";
-    }
-    static hasProperty(obj, property) {
-        if (!obj)
-            return false;
-        const props = (property.indexOf(".") >= 0 ? property.split(".") : [property]);
-        let t = obj;
-        for (let i = 0; i < props.length; i++) {
-            if (!t)
-                return false;
-            const pName = props[i];
-            if (!t.hasOwnProperty(pName))
-                return false;
-            t = t[pName];
-        }
-        return true;
-    }
-    static getProperty(obj, property) {
-        if (!obj)
-            return null;
-        const props = (property.indexOf(".") >= 0 ? property.split(".") : [property]);
-        let t = obj;
-        for (let i = 0; i < props.length; i++) {
-            const pName = props[i];
-            if (!t.hasOwnProperty(pName))
-                return null;
-            t = t[pName];
-        }
-        return t;
-    }
-    static extend(...params) {
-        let options, name, src, copy, copyIsArray, clone, target = params[0] || {}, i = 1, length = params.length;
-        if (typeof target !== "object" && !Utility.isFunction(target))
-            target = {};
-        if (length === i) {
-            //target = this;
-            --i;
-        }
-        for (; i < length; i++) {
-            if ((options = params[i]) != null) {
-                for (name in options) {
-                    src = target[name];
-                    copy = options[name];
-                    if (target === copy)
-                        continue;
-                    if (copy && (Utility.isPlainObject(copy) || (copyIsArray = Utility.isArray(copy)))) {
-                        if (copyIsArray) {
-                            copyIsArray = false;
-                            clone = src && Utility.isArray(src) ? src : [];
-                        }
-                        else
-                            clone = src && Utility.isPlainObject(src) ? src : {};
-                        target[name] = Utility.extend(clone, copy);
-                    }
-                    else if (copy !== undefined)
-                        target[name] = copy;
-                }
-            }
-        }
-        return target;
-    }
-    static createDelegate(context, func) {
-        return (...params) => func.apply(context, params);
-    }
-    static createDelegate2(context, func, args) {
-        return (...params) => {
-            const args2 = new Array();
-            if (args && args.length) {
-                for (let i = 0; i < args.length; i++) {
-                    args2.push(args[i]);
-                }
-            }
-            if (params.length) {
-                for (let i = 0; i < params.length; i++) {
-                    args2.push(params[i]);
-                }
-            }
-            return func.apply(context, args2);
-        };
+        t = t[pName];
     }
-    static createDelegate3(context, func, args) {
-        return (...params) => {
-            const args2 = new Array();
-            if (params.length) {
-                for (let i = 0; i < params.length; i++) {
-                    args2.push(params[i]);
-                }
-            }
-            if (args && args.length) {
-                for (let i = 0; i < args.length; i++) {
-                    args2.push(args[i]);
-                }
-            }
-            return func.apply(context, args2);
-        };
-    }
-    ;
+    return true;
+}
+function getProperty(obj, property) {
+    if (!obj)
+        return null;
+    const props = property.split(".");
+    let t = obj;
+    for (let i = 0; i < props.length; i++) {
+        const pName = props[i];
+        if (!(pName in t))
+            return undefined;
+        t = t[pName];
+    }
+    return t;
+}
+
+var object = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	getProperty: getProperty,
+	hasProperty: hasProperty
+});
+
+function isFunction(value) {
+    return (typeof value === "function");
 }
+function isString(value) {
+    return (typeof value === "string" || value instanceof String);
+}
+
+var type = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	isFunction: isFunction,
+	isString: isString
+});
+
+const minWait = (func, minTime) => {
+    if (!minTime)
+        return func;
+    const beginTime = Date.now();
+    const ret = (...args) => {
+        const rightTime = getRightTime(beginTime, minTime);
+        if (rightTime)
+            window.setTimeout(() => func(...args), rightTime);
+        else
+            func(...args);
+    };
+    return ret;
+};
+function minWaitAsync(func, minTime) {
+    if (!minTime)
+        return func();
+    const beginTime = Date.now();
+    return func()
+        .then(data => {
+        const rightTime = getRightTime(beginTime, minTime);
+        if (rightTime)
+            return new Promise(resolve => window.setTimeout(() => resolve(data), rightTime));
+        else
+            return data;
+    });
+}
+const getRightTime = (start, minTime) => {
+    const finishTime = Date.now();
+    const w = minTime - (finishTime - start);
+    return w > minTime * 0.1 ? w : 0;
+};
+function delay(time, abort) {
+    return new Promise(resolve => {
+        const timer = window.setTimeout(() => resolve(), time);
+        abort.addEventListener("abort", () => {
+            window.clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+
+var func = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	delay: delay,
+	minWait: minWait,
+	minWaitAsync: minWaitAsync
+});
+
+function getWordEnd(count, word, one, two, five) {
+    const tt = count % 100;
+    if (tt >= 5 && tt <= 20)
+        return word + (five || "");
+    const t = count % 10;
+    return (t === 1 ?
+        (word + (one || "")) : ((t >= 2 && t <= 4) ? (word + (two || "")) : (word + (five || ""))));
+}
+
+var word = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	getWordEnd: getWordEnd
+});
 
-exports.Utility = Utility;
+exports.FuncHelper = func;
+exports.ObjectHelper = object;
+exports.TypeHelper = type;
+exports.WordHelper = word;
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/mjs/index.js

@@ -1,164 +1,112 @@
-class Utility {
-    static arrayToObject(array) {
-        if (array) {
-            const result = {};
-            for (let i = 0; i < array.length; i++)
-                result[array[i].Key] = array[i].Value;
-            return result;
-        }
-        return null;
-    }
-    static objectToArray(obj) {
-        if (!obj)
-            return null;
-        const result = new Array();
-        for (const key in obj)
-            result.push({ Key: key, Value: obj[key] });
-        return result;
-    }
-    static getWordEnd(count, word, one, two, five) {
-        const tt = count % 100;
-        if (tt >= 5 && tt <= 20)
-            return word + (Utility.isString(five) ? five : "");
-        const t = count % 10;
-        return (t === 1 ?
-            (word + (Utility.isString(one) ? one : "")) :
-            ((t >= 2 && t <= 4) ?
-                (word + (Utility.isString(two) ? two : "")) :
-                (word + (Utility.isString(five) ? five : ""))));
-    }
-    static isString(value) {
-        return (typeof value === "string" || value instanceof String);
-    }
-    static isArray(value) {
-        return (value instanceof Array);
-    }
-    static isUndefined(value) {
-        return (typeof value === "undefined");
-    }
-    static isFunction(value) {
-        return (typeof value === "function");
-    }
-    static isPlainObject(obj) {
-        if (!obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval) {
+function hasProperty(obj, property) {
+    if (!obj)
+        return false;
+    const props = property.split(".");
+    let t = obj;
+    for (let i = 0; i < props.length; i++) {
+        if (!t)
             return false;
-        }
-        if (obj.constructor && !obj.hasOwnProperty.call(obj, "constructor") && !obj.hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf")) {
+        const pName = props[i];
+        if (!(pName in t))
             return false;
-        }
-        let key;
-        for (key in obj) {
-            continue;
-        }
-        return key === undefined || obj.hasOwnProperty.call(obj, key);
-    }
-    static joinString(separator, items) {
-        if (!Utility.isArray(items))
-            throw "Param items is not array.";
-        let str = "";
-        for (let i = 0; i < items.length; i++)
-            str += (i > 0 ? separator : "") + items[i];
-        return str;
-    }
-    static stringIsNullOrEmpty(str) {
-        return !Utility.isString(str) || str === null || str === "";
-    }
-    static hasProperty(obj, property) {
-        if (!obj)
-            return false;
-        const props = (property.indexOf(".") >= 0 ? property.split(".") : [property]);
-        let t = obj;
-        for (let i = 0; i < props.length; i++) {
-            if (!t)
-                return false;
-            const pName = props[i];
-            if (!t.hasOwnProperty(pName))
-                return false;
-            t = t[pName];
-        }
-        return true;
-    }
-    static getProperty(obj, property) {
-        if (!obj)
-            return null;
-        const props = (property.indexOf(".") >= 0 ? property.split(".") : [property]);
-        let t = obj;
-        for (let i = 0; i < props.length; i++) {
-            const pName = props[i];
-            if (!t.hasOwnProperty(pName))
-                return null;
-            t = t[pName];
-        }
-        return t;
-    }
-    static extend(...params) {
-        let options, name, src, copy, copyIsArray, clone, target = params[0] || {}, i = 1, length = params.length;
-        if (typeof target !== "object" && !Utility.isFunction(target))
-            target = {};
-        if (length === i) {
-            //target = this;
-            --i;
-        }
-        for (; i < length; i++) {
-            if ((options = params[i]) != null) {
-                for (name in options) {
-                    src = target[name];
-                    copy = options[name];
-                    if (target === copy)
-                        continue;
-                    if (copy && (Utility.isPlainObject(copy) || (copyIsArray = Utility.isArray(copy)))) {
-                        if (copyIsArray) {
-                            copyIsArray = false;
-                            clone = src && Utility.isArray(src) ? src : [];
-                        }
-                        else
-                            clone = src && Utility.isPlainObject(src) ? src : {};
-                        target[name] = Utility.extend(clone, copy);
-                    }
-                    else if (copy !== undefined)
-                        target[name] = copy;
-                }
-            }
-        }
-        return target;
-    }
-    static createDelegate(context, func) {
-        return (...params) => func.apply(context, params);
-    }
-    static createDelegate2(context, func, args) {
-        return (...params) => {
-            const args2 = new Array();
-            if (args && args.length) {
-                for (let i = 0; i < args.length; i++) {
-                    args2.push(args[i]);
-                }
-            }
-            if (params.length) {
-                for (let i = 0; i < params.length; i++) {
-                    args2.push(params[i]);
-                }
-            }
-            return func.apply(context, args2);
-        };
+        t = t[pName];
     }
-    static createDelegate3(context, func, args) {
-        return (...params) => {
-            const args2 = new Array();
-            if (params.length) {
-                for (let i = 0; i < params.length; i++) {
-                    args2.push(params[i]);
-                }
-            }
-            if (args && args.length) {
-                for (let i = 0; i < args.length; i++) {
-                    args2.push(args[i]);
-                }
-            }
-            return func.apply(context, args2);
-        };
-    }
-    ;
+    return true;
+}
+function getProperty(obj, property) {
+    if (!obj)
+        return null;
+    const props = property.split(".");
+    let t = obj;
+    for (let i = 0; i < props.length; i++) {
+        const pName = props[i];
+        if (!(pName in t))
+            return undefined;
+        t = t[pName];
+    }
+    return t;
+}
+
+var object = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	getProperty: getProperty,
+	hasProperty: hasProperty
+});
+
+function isFunction(value) {
+    return (typeof value === "function");
 }
+function isString(value) {
+    return (typeof value === "string" || value instanceof String);
+}
+
+var type = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	isFunction: isFunction,
+	isString: isString
+});
+
+const minWait = (func, minTime) => {
+    if (!minTime)
+        return func;
+    const beginTime = Date.now();
+    const ret = (...args) => {
+        const rightTime = getRightTime(beginTime, minTime);
+        if (rightTime)
+            window.setTimeout(() => func(...args), rightTime);
+        else
+            func(...args);
+    };
+    return ret;
+};
+function minWaitAsync(func, minTime) {
+    if (!minTime)
+        return func();
+    const beginTime = Date.now();
+    return func()
+        .then(data => {
+        const rightTime = getRightTime(beginTime, minTime);
+        if (rightTime)
+            return new Promise(resolve => window.setTimeout(() => resolve(data), rightTime));
+        else
+            return data;
+    });
+}
+const getRightTime = (start, minTime) => {
+    const finishTime = Date.now();
+    const w = minTime - (finishTime - start);
+    return w > minTime * 0.1 ? w : 0;
+};
+function delay(time, abort) {
+    return new Promise(resolve => {
+        const timer = window.setTimeout(() => resolve(), time);
+        abort.addEventListener("abort", () => {
+            window.clearTimeout(timer);
+            resolve();
+        });
+    });
+}
+
+var func = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	delay: delay,
+	minWait: minWait,
+	minWaitAsync: minWaitAsync
+});
+
+function getWordEnd(count, word, one, two, five) {
+    const tt = count % 100;
+    if (tt >= 5 && tt <= 20)
+        return word + (five || "");
+    const t = count % 10;
+    return (t === 1 ?
+        (word + (one || "")) : ((t >= 2 && t <= 4) ? (word + (two || "")) : (word + (five || ""))));
+}
+
+var word = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	getWordEnd: getWordEnd
+});
 
-export { Utility };
+export { func as FuncHelper, object as ObjectHelper, type as TypeHelper, word as WordHelper };
 //# sourceMappingURL=index.js.map

package/dist/mjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types.d.ts

@@ -1,26 +1,37 @@
-declare class Utility {
-    static arrayToObject(array: Array<{
-        Key: string;
-        Value: any;
-    }>): any;
-    static objectToArray(obj: any): Array<{
-        Key: string;
-        Value: any;
-    }> | null;
-    static getWordEnd(count: number, word: string, one?: string, two?: string, five?: string): string;
-    static isString(value: any): value is string | String;
-    static isArray(value: any): value is any[];
-    static isUndefined(value: any): value is undefined;
-    static isFunction(value: any): boolean;
-    static isPlainObject(obj: any): boolean;
-    static joinString(separator: string, items: Array<any>): string;
-    static stringIsNullOrEmpty(str: string): boolean;
-    static hasProperty(obj: any, property: string): boolean;
-    static getProperty(obj: any, property: string): any;
-    static extend(...params: any[]): any;
-    static createDelegate(context: any, func: (...params: Array<any>) => void): (...params: Array<any>) => void;
-    static createDelegate2(context: any, func: (...params: Array<any>) => void, args?: Array<any>): (...params: Array<any>) => void;
-    static createDelegate3(context: any, func: (...params: Array<any>) => void, args?: Array<any>): (...params: Array<any>) => void;
+declare function hasProperty(obj: any, property: string): boolean;
+declare function getProperty(obj: any, property: string): any;
+
+declare const object_getProperty: typeof getProperty;
+declare const object_hasProperty: typeof hasProperty;
+declare namespace object {
+  export { object_getProperty as getProperty, object_hasProperty as hasProperty };
+}
+
+declare function isFunction(value: any): boolean;
+declare function isString(value: any): value is string | String;
+
+declare const type_isFunction: typeof isFunction;
+declare const type_isString: typeof isString;
+declare namespace type {
+  export { type_isFunction as isFunction, type_isString as isString };
+}
+
+declare const minWait: (func: (...args: any[]) => void, minTime?: number) => (...args: any[]) => void;
+declare function minWaitAsync<TResult>(func: () => Promise<TResult>, minTime?: number): Promise<TResult>;
+declare function delay(time: number, abort: AbortSignal): Promise<void>;
+
+declare const func_delay: typeof delay;
+declare const func_minWait: typeof minWait;
+declare const func_minWaitAsync: typeof minWaitAsync;
+declare namespace func {
+  export { func_delay as delay, func_minWait as minWait, func_minWaitAsync as minWaitAsync };
+}
+
+declare function getWordEnd(count: number, word: string, one?: string, two?: string, five?: string): string;
+
+declare const word_getWordEnd: typeof getWordEnd;
+declare namespace word {
+  export { word_getWordEnd as getWordEnd };
 }
 
-export { Utility };
+export { func as FuncHelper, object as ObjectHelper, type as TypeHelper, word as WordHelper };

package/package.json

@@ -22,7 +22,7 @@
     "email": "it@brandup.online"
   },
   "license": "Apache-2.0",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/types.d.ts",