utils-lib-js 1.0.1

package/dist/common/object.d.ts

@@ -0,0 +1,10 @@
+import { IGetValue, ISetValue, IMixIn, ICloneDeep, ICreateObjectVariable, IEnumInversion, IInherit, ICreateObject } from "./types";
+export declare const getValue: IGetValue;
+export declare const setValue: ISetValue;
+export declare const mixIn: IMixIn;
+export declare const enumInversion: IEnumInversion;
+export declare const isNotObject: (source: any, type: any) => boolean;
+export declare const cloneDeep: ICloneDeep;
+export declare const createObjectVariable: ICreateObjectVariable;
+export declare const createObject: ICreateObject;
+export declare const inherit: IInherit;

package/dist/common/object.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inherit = exports.createObject = exports.createObjectVariable = exports.cloneDeep = exports.isNotObject = exports.enumInversion = exports.mixIn = exports.setValue = exports.getValue = void 0;
+var base_1 = require("./base");
+var getValue = function (object, key, defaultValue) {
+    if (defaultValue === void 0) {
+        defaultValue = '';
+    }
+    var paths = key.split('.');
+    for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
+        var i = paths_1[_i];
+        object = object[i];
+        if (object === undefined) {
+            return defaultValue;
+        }
+    }
+    return object;
+};
+exports.getValue = getValue;
+var setValue = function (object, key, value) {
+    if (value === void 0) {
+        value = {};
+    }
+    var paths = key.split('.');
+    var last = paths[paths.length - 1];
+    var _object = object;
+    for (var _i = 0, paths_2 = paths; _i < paths_2.length; _i++) {
+        var i = paths_2[_i];
+        if (typeof _object !== "object" && _object !== undefined) {
+            return object;
+        }
+        !_object && (_object = {});
+        !_object[i] && (_object[i] = {});
+        last === i && (_object[last] = value);
+        _object = _object[i];
+    }
+    return object;
+};
+exports.setValue = setValue;
+var mixIn = function (target, source, overwrite) {
+    var _a;
+    if (source === void 0) {
+        source = {};
+    }
+    if (overwrite === void 0) {
+        overwrite = false;
+    }
+    for (var k in source) {
+        for (var key in source[k]) {
+            var proto = (_a = target.prototype) !== null && _a !== void 0 ? _a : target;
+            if (target[key] === undefined || overwrite) {
+                proto[key] = source[k][key];
+            }
+        }
+    }
+    return target;
+};
+exports.mixIn = mixIn;
+var enumInversion = function (target) {
+    for (var key in target) {
+        var _key = target[key];
+        if (typeof _key === "string" && !!!target[_key]) {
+            target[_key] = key;
+        }
+    }
+    return target;
+};
+exports.enumInversion = enumInversion;
+var isNotObject = function (source, type) {
+    return typeof source !== "object" || type === 'null';
+};
+exports.isNotObject = isNotObject;
+var cloneDeep = function (target) {
+    var __type = (0, base_1.getType)(target);
+    if ((0, exports.isNotObject)(target, __type)) return target;
+    var __init = (0, exports.createObjectVariable)(__type, target);
+    if (__type === "map") {
+        target.forEach(function (value, key) {
+            __init.set(key, (0, exports.cloneDeep)(value));
+        });
+    } else if (__type === "set") {
+        target.forEach(function (value) {
+            __init.add((0, exports.cloneDeep)(value));
+        });
+    } else {
+        Reflect.ownKeys(target).forEach(function (keys) {
+            var desc = target[keys];
+            __init[keys] = (0, exports.cloneDeep)(desc);
+        });
+    }
+    return __init;
+};
+exports.cloneDeep = cloneDeep;
+var createObjectVariable = function (type, source) {
+    if (source === void 0) {
+        source = {};
+    }
+    switch (type) {
+        case "array":
+            return [];
+        case "function":
+            return source;
+        case "set":
+            return new Set();
+        case "map":
+            return new Map();
+        case "date":
+            return new Date(source);
+        case "regExp":
+            return new RegExp(source);
+        case "math":
+            return Math;
+        default:
+            return {};
+    }
+};
+exports.createObjectVariable = createObjectVariable;
+var createObject = function (source) {
+    function F() {}
+    F.prototype = source;
+    return new F();
+};
+exports.createObject = createObject;
+var inherit = function (source, target) {
+    if (target === void 0) {
+        target = function () {};
+    }
+    target.prototype = (0, exports.createObject)(source.prototype);
+    target.prototype.super = source;
+    target.prototype.constructor = target;
+    return target;
+};
+exports.inherit = inherit;

package/dist/common/static.d.ts

@@ -0,0 +1,12 @@
+export declare enum types {
+    "[object Array]" = "array",
+    "[object Object]" = "object",
+    "[object Function]" = "function",
+    "[object Set]" = "set",
+    "[object Map]" = "map",
+    "[object WeakMap]" = "weakMap",
+    "[object WeakSet]" = "weakSet",
+    "[object Date]" = "date",
+    "[object RegExp]" = "regExp",
+    "[object Math]" = "math"
+}

package/dist/common/static.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.types = void 0;
+var types;
+(function (types) {
+    types["[object Array]"] = "array";
+    types["[object Object]"] = "object";
+    types["[object Function]"] = "function";
+    types["[object Set]"] = "set";
+    types["[object Map]"] = "map";
+    types["[object WeakMap]"] = "weakMap";
+    types["[object WeakSet]"] = "weakSet";
+    types["[object Date]"] = "date";
+    types["[object RegExp]"] = "regExp";
+    types["[object Math]"] = "math";
+})(types = exports.types || (exports.types = {}));
+;

package/dist/common/types.d.ts

@@ -0,0 +1,42 @@
+export declare type IKey = string | symbol | number;
+export interface IObject<T> {
+    [key: IKey]: T | IObject<any>;
+}
+export interface IPromise extends IObject<any> {
+    promise: Promise<void>;
+    resolve: () => unknown;
+    reject: () => unknown;
+}
+export declare type IDemoteArray<T> = Array<IDemoteArray<T> | T>;
+export declare type IRandomNum = (min: number, max: number, bool?: boolean) => number;
+export declare type IUrlSplit = (url: string) => IObject<any>;
+export declare type IUrlJoin = (url: string, query: object) => string;
+export declare type IGetType<T> = (data: any) => typeof data | T[keyof T] | "null";
+export declare type IGetValue = <T>(object: IObject<T> | IObject<T>[IKey], key: string, defaultValue?: any) => IObject<T>[IKey];
+export declare type ISetValue = <T>(object: IObject<T>, key: string, value?: any) => IObject<T>;
+export declare type IMixIn = <U extends IObject<any>>(target?: U, source?: IObject<any>, overwrite?: boolean) => U;
+export declare type IEnumInversion = (target: IObject<string>) => IObject<string>;
+export declare type ICloneDeep = (target?: any) => any;
+export declare type ICreateObjectVariable = (type: string, source?: any) => any;
+export declare type ICreateObject = <T, U extends T>(source: T) => U;
+export declare type IInherit = <T extends Function>(source: T, target?: Function) => Function;
+export declare type IThrottle = (fn: Function, time: number) => (...args: any[]) => void;
+export declare type IDebounce = (fn: Function, time: number) => (...args: any[]) => void;
+export declare type IDefer = () => IPromise;
+export declare type ICatchAwait<T extends Promise<any>> = (defer: T) => T;
+export declare type IArrayRandom<T extends any[]> = (arr: T) => T;
+export declare type IArrayUniq<T extends any[]> = (arr: T) => T;
+export declare type IArrayDemote<T extends IDemoteArray<any>> = (arr: T, result?: T) => T;
+interface IElementParams<T> {
+    ele: T | string;
+    style: CSSStyleDeclaration;
+    attr: Attr;
+    parent: T;
+}
+export declare type ICreateElement<T = HTMLElement> = (params: IElementParams<T>) => T;
+export declare type IAddHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export declare type IStopBubble = (e: Event) => void;
+export declare type IStopDefault = (e: Event) => void;
+export declare type IRemoveHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export declare type IDispatchEvent = <T extends Document>(ele: T, data: any) => void;
+export {};

package/dist/common/types.js

@@ -0,0 +1,3 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/array.d.ts

@@ -0,0 +1,4 @@
+import { IArrayRandom, IArrayUniq, IArrayDemote, IDemoteArray } from "./types";
+export declare const arrayRandom: IArrayRandom<any[]>;
+export declare const arrayUniq: IArrayUniq<any[]>;
+export declare const arrayDemote: IArrayDemote<IDemoteArray<any>>;

package/dist/esm/array.js

@@ -0,0 +1,18 @@
+import { getType } from "./base";
+export var arrayRandom = function (arr) {
+    return arr.sort(function () {
+        return Math.random() - 0.5;
+    });
+};
+export var arrayUniq = function (arr) {
+    return Array.from(new Set(arr));
+};
+export var arrayDemote = function (arr, result) {
+    if (result === void 0) {
+        result = [];
+    }
+    arr.forEach(function (i) {
+        return getType(i) === "array" ? arrayDemote(i, result) : result.push(i);
+    });
+    return result;
+};

package/dist/esm/base.d.ts

@@ -0,0 +1,6 @@
+import { IRandomNum, IUrlSplit, IUrlJoin, IGetType } from "./types";
+import { types } from "./static";
+export declare const randomNum: IRandomNum;
+export declare const urlSplit: IUrlSplit;
+export declare const urlJoin: IUrlJoin;
+export declare const getType: IGetType<types>;

package/dist/esm/base.js

@@ -0,0 +1,35 @@
+import { types } from "./static";
+export var randomNum = function (min, max, bool) {
+    if (bool === void 0) {
+        bool = false;
+    }
+    return Math.floor(Math.random() * (max - min + (bool ? 1 : 0)) + min);
+};
+export var urlSplit = function (url) {
+    var result = {};
+    if (!url.includes("?")) {
+        return result;
+    }
+    var params = url.split("?")[1].split("&");
+    params.forEach(function (i) {
+        var key = i.split("=")[0];
+        result[key] = i.split("=")[1];
+    });
+    return result;
+};
+export var urlJoin = function (url, query) {
+    var params = Object.keys(query).map(function (i) {
+        return "".concat(i, "=").concat(query[i]);
+    });
+    return "".concat(url).concat(url.includes("?") ? "&" : '?').concat(params.join("&"));
+};
+export var getType = function (data) {
+    var type = typeof data;
+    if (data === null) {
+        return "null";
+    } else if (type === "object") {
+        var key = Object.prototype.toString.call(data);
+        return types[key];
+    }
+    return type;
+};

package/dist/esm/element.d.ts

@@ -0,0 +1,2 @@
+import { ICreateElement } from "./types";
+export declare const createElement: ICreateElement;

package/dist/esm/element.js

@@ -0,0 +1,16 @@
+export var createElement = function (_a) {
+    var _b, _c;
+    var ele = _a.ele,
+        style = _a.style,
+        attr = _a.attr,
+        parent = _a.parent;
+    var element = ele instanceof HTMLElement ? ele : document.createElement(ele !== null && ele !== void 0 ? ele : 'div');
+    style && ((_b = Object.keys(style)) === null || _b === void 0 ? void 0 : _b.forEach(function (key) {
+        return element.style[key] = style[key];
+    }));
+    attr && ((_c = Object.keys(style)) === null || _c === void 0 ? void 0 : _c.forEach(function (key) {
+        return element[key] = attr[key];
+    }));
+    parent && parent.appendChild(element);
+    return element;
+};

package/dist/esm/event.d.ts

@@ -0,0 +1,6 @@
+import { IAddHandler, IStopBubble, IStopDefault, IRemoveHandler, IDispatchEvent } from "./types";
+export declare const addHandler: IAddHandler;
+export declare const stopBubble: IStopBubble;
+export declare const stopDefault: IStopDefault;
+export declare const removeHandler: IRemoveHandler;
+export declare const dispatchEvent: IDispatchEvent;

package/dist/esm/event.js

@@ -0,0 +1,34 @@
+export var addHandler = function (ele, type, handler) {
+    if (ele.addEventListener) {
+        ele.addEventListener(type, handler, false);
+    } else {
+        ele["on" + type] = handler;
+    }
+};
+export var stopBubble = function (event) {
+    event = event || window.event;
+    if (event.stopPropagation) {
+        event.stopPropagation();
+    } else {
+        event.cancelBubble = false;
+    }
+};
+export var stopDefault = function (event) {
+    event = event || window.event;
+    if (event.preventDefault) {
+        event.preventDefault();
+    } else {
+        event.returnValue = false;
+    }
+};
+export var removeHandler = function (ele, type, handler) {
+    if (ele.removeEventListener) {
+        ele.removeEventListener(type, handler, false);
+    } else {
+        ele["on" + type] = null;
+    }
+};
+export var dispatchEvent = function (ele, data) {
+    var evts = new Event(data);
+    ele.dispatchEvent(evts);
+};

package/dist/esm/function.d.ts

@@ -0,0 +1,5 @@
+import { ICatchAwait, IThrottle, IDebounce, IDefer } from "./types";
+export declare const throttle: IThrottle;
+export declare const debounce: IDebounce;
+export declare const defer: IDefer;
+export declare const catchAwait: ICatchAwait<Promise<any>>;

package/dist/esm/function.js

@@ -0,0 +1,58 @@
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var _this = this;
+export var throttle = function (fn, time) {
+    var _timer = null;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (_timer) return;
+        _timer = setTimeout(function () {
+            fn.call.apply(fn, __spreadArray([_this], args, false));
+            _timer = null;
+        }, time);
+    };
+};
+export var debounce = function (fn, time) {
+    var _timer = null;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (_timer) {
+            clearTimeout(_timer);
+            _timer = null;
+        }
+        _timer = setTimeout(function () {
+            fn.call.apply(fn, __spreadArray([_this], args, false));
+        }, time);
+    };
+};
+export var defer = function () {
+    var resolve, reject;
+    return {
+        promise: new Promise(function (_resolve, _reject) {
+            resolve = _resolve;
+            reject = _reject;
+        }),
+        resolve: resolve,
+        reject: reject
+    };
+};
+export var catchAwait = function (defer) {
+    return defer.then(function (res) {
+        return [null, res];
+    }).catch(function (err) {
+        return [err];
+    });
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./object";
+export * from "./base";
+export * from "./array";
+export * from "./function";
+export * from "./element";
+export * from "./static";
+export * from "./types";
+export * from "event-message-center";

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export * from "./object";
+export * from "./base";
+export * from "./array";
+export * from "./function";
+export * from "./element";
+export * from "./static";
+export * from "./types";
+export * from "event-message-center";

package/dist/esm/object.d.ts

@@ -0,0 +1,10 @@
+import { IGetValue, ISetValue, IMixIn, ICloneDeep, ICreateObjectVariable, IEnumInversion, IInherit, ICreateObject } from "./types";
+export declare const getValue: IGetValue;
+export declare const setValue: ISetValue;
+export declare const mixIn: IMixIn;
+export declare const enumInversion: IEnumInversion;
+export declare const isNotObject: (source: any, type: any) => boolean;
+export declare const cloneDeep: ICloneDeep;
+export declare const createObjectVariable: ICreateObjectVariable;
+export declare const createObject: ICreateObject;
+export declare const inherit: IInherit;

package/dist/esm/object.js

@@ -0,0 +1,121 @@
+import { getType } from "./base";
+export var getValue = function (object, key, defaultValue) {
+    if (defaultValue === void 0) {
+        defaultValue = '';
+    }
+    var paths = key.split('.');
+    for (var _i = 0, paths_1 = paths; _i < paths_1.length; _i++) {
+        var i = paths_1[_i];
+        object = object[i];
+        if (object === undefined) {
+            return defaultValue;
+        }
+    }
+    return object;
+};
+export var setValue = function (object, key, value) {
+    if (value === void 0) {
+        value = {};
+    }
+    var paths = key.split('.');
+    var last = paths[paths.length - 1];
+    var _object = object;
+    for (var _i = 0, paths_2 = paths; _i < paths_2.length; _i++) {
+        var i = paths_2[_i];
+        if (typeof _object !== "object" && _object !== undefined) {
+            return object;
+        }
+        !_object && (_object = {});
+        !_object[i] && (_object[i] = {});
+        last === i && (_object[last] = value);
+        _object = _object[i];
+    }
+    return object;
+};
+export var mixIn = function (target, source, overwrite) {
+    var _a;
+    if (source === void 0) {
+        source = {};
+    }
+    if (overwrite === void 0) {
+        overwrite = false;
+    }
+    for (var k in source) {
+        for (var key in source[k]) {
+            var proto = (_a = target.prototype) !== null && _a !== void 0 ? _a : target;
+            if (target[key] === undefined || overwrite) {
+                proto[key] = source[k][key];
+            }
+        }
+    }
+    return target;
+};
+export var enumInversion = function (target) {
+    for (var key in target) {
+        var _key = target[key];
+        if (typeof _key === "string" && !!!target[_key]) {
+            target[_key] = key;
+        }
+    }
+    return target;
+};
+export var isNotObject = function (source, type) {
+    return typeof source !== "object" || type === 'null';
+};
+export var cloneDeep = function (target) {
+    var __type = getType(target);
+    if (isNotObject(target, __type)) return target;
+    var __init = createObjectVariable(__type, target);
+    if (__type === "map") {
+        target.forEach(function (value, key) {
+            __init.set(key, cloneDeep(value));
+        });
+    } else if (__type === "set") {
+        target.forEach(function (value) {
+            __init.add(cloneDeep(value));
+        });
+    } else {
+        Reflect.ownKeys(target).forEach(function (keys) {
+            var desc = target[keys];
+            __init[keys] = cloneDeep(desc);
+        });
+    }
+    return __init;
+};
+export var createObjectVariable = function (type, source) {
+    if (source === void 0) {
+        source = {};
+    }
+    switch (type) {
+        case "array":
+            return [];
+        case "function":
+            return source;
+        case "set":
+            return new Set();
+        case "map":
+            return new Map();
+        case "date":
+            return new Date(source);
+        case "regExp":
+            return new RegExp(source);
+        case "math":
+            return Math;
+        default:
+            return {};
+    }
+};
+export var createObject = function (source) {
+    function F() {}
+    F.prototype = source;
+    return new F();
+};
+export var inherit = function (source, target) {
+    if (target === void 0) {
+        target = function () {};
+    }
+    target.prototype = createObject(source.prototype);
+    target.prototype.super = source;
+    target.prototype.constructor = target;
+    return target;
+};

package/dist/esm/static.d.ts

@@ -0,0 +1,12 @@
+export declare enum types {
+    "[object Array]" = "array",
+    "[object Object]" = "object",
+    "[object Function]" = "function",
+    "[object Set]" = "set",
+    "[object Map]" = "map",
+    "[object WeakMap]" = "weakMap",
+    "[object WeakSet]" = "weakSet",
+    "[object Date]" = "date",
+    "[object RegExp]" = "regExp",
+    "[object Math]" = "math"
+}

package/dist/esm/static.js

@@ -0,0 +1,14 @@
+export var types;
+(function (types) {
+    types["[object Array]"] = "array";
+    types["[object Object]"] = "object";
+    types["[object Function]"] = "function";
+    types["[object Set]"] = "set";
+    types["[object Map]"] = "map";
+    types["[object WeakMap]"] = "weakMap";
+    types["[object WeakSet]"] = "weakSet";
+    types["[object Date]"] = "date";
+    types["[object RegExp]"] = "regExp";
+    types["[object Math]"] = "math";
+})(types || (types = {}));
+;

package/dist/esm/types.d.ts

@@ -0,0 +1,42 @@
+export declare type IKey = string | symbol | number;
+export interface IObject<T> {
+    [key: IKey]: T | IObject<any>;
+}
+export interface IPromise extends IObject<any> {
+    promise: Promise<void>;
+    resolve: () => unknown;
+    reject: () => unknown;
+}
+export declare type IDemoteArray<T> = Array<IDemoteArray<T> | T>;
+export declare type IRandomNum = (min: number, max: number, bool?: boolean) => number;
+export declare type IUrlSplit = (url: string) => IObject<any>;
+export declare type IUrlJoin = (url: string, query: object) => string;
+export declare type IGetType<T> = (data: any) => typeof data | T[keyof T] | "null";
+export declare type IGetValue = <T>(object: IObject<T> | IObject<T>[IKey], key: string, defaultValue?: any) => IObject<T>[IKey];
+export declare type ISetValue = <T>(object: IObject<T>, key: string, value?: any) => IObject<T>;
+export declare type IMixIn = <U extends IObject<any>>(target?: U, source?: IObject<any>, overwrite?: boolean) => U;
+export declare type IEnumInversion = (target: IObject<string>) => IObject<string>;
+export declare type ICloneDeep = (target?: any) => any;
+export declare type ICreateObjectVariable = (type: string, source?: any) => any;
+export declare type ICreateObject = <T, U extends T>(source: T) => U;
+export declare type IInherit = <T extends Function>(source: T, target?: Function) => Function;
+export declare type IThrottle = (fn: Function, time: number) => (...args: any[]) => void;
+export declare type IDebounce = (fn: Function, time: number) => (...args: any[]) => void;
+export declare type IDefer = () => IPromise;
+export declare type ICatchAwait<T extends Promise<any>> = (defer: T) => T;
+export declare type IArrayRandom<T extends any[]> = (arr: T) => T;
+export declare type IArrayUniq<T extends any[]> = (arr: T) => T;
+export declare type IArrayDemote<T extends IDemoteArray<any>> = (arr: T, result?: T) => T;
+interface IElementParams<T> {
+    ele: T | string;
+    style: CSSStyleDeclaration;
+    attr: Attr;
+    parent: T;
+}
+export declare type ICreateElement<T = HTMLElement> = (params: IElementParams<T>) => T;
+export declare type IAddHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export declare type IStopBubble = (e: Event) => void;
+export declare type IStopDefault = (e: Event) => void;
+export declare type IRemoveHandler = <T extends Document>(ele: T, type: string, handler: (e: Event) => void) => void;
+export declare type IDispatchEvent = <T extends Document>(ele: T, data: any) => void;
+export {};

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};