utils-lib-js 1.4.6 → 1.5.1

package/dist/esm/index.mjs

@@ -0,0 +1,692 @@
+import { getType } from "./index.js";
+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;
+};
+import { types } from "./index.js";
+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) {
+    if (query === void 0) {
+        query = {};
+    }
+    var queryObject = Object.keys(query);
+    if (queryObject.length === 0) return url;
+    var params = queryObject.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;
+};
+export var getTypeByList = function (data, whiteList) {
+    if (whiteList === void 0) {
+        whiteList = [];
+    }
+    var __type = getType(data);
+    return whiteList.indexOf(__type) > 0;
+};
+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;
+};
+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);
+};
+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];
+    });
+};
+export * from "./object.js";
+export * from "./base.js";
+export * from "./array.js";
+export * from "./function.js";
+export * from "./element.js";
+export * from "./static.js";
+export * from "./types.js";
+export * from "./request.js";
+export * from "./event.js";
+export * from "./storage.js";
+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));
+};
+import { getType, getTypeByList } from "./index.js";
+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;
+};
+export var getInstance = function (classProto, overwrite) {
+    if (overwrite === void 0) {
+        overwrite = false;
+    }
+    var params = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        params[_i - 2] = arguments[_i];
+    }
+    if (!classProto._instance || overwrite) {
+        classProto._instance = new (classProto.bind.apply(classProto, __spreadArray([void 0], params, false)))();
+    }
+    return classProto._instance;
+};
+export var classDecorator = function (params) {
+    return function (target) {
+        for (var key in params) {
+            if (!!!Reflect.has(target.prototype, key)) {
+                target.prototype[key] = params[key];
+            }
+        }
+    };
+};
+export var stringToJson = function (target) {
+    if (getType(target) !== "string") return null;
+    try {
+        return JSON.parse(target);
+    } catch (error) {
+        return null;
+    }
+};
+export var jsonToString = function (target) {
+    if (!getTypeByList(target, ["array", "object", "set", "map"])) return "";
+    try {
+        return JSON.stringify(target);
+    } catch (error) {
+        return "";
+    }
+};
+var __extends = this && this.__extends || function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {
+            d.__proto__ = b;
+        } || function (d, b) {
+            for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+        };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+            this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+}();
+var __assign = this && this.__assign || function () {
+    __assign = Object.assign || function (t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = this && this.__rest || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+    }
+    return t;
+};
+import { urlJoin, defer, jsonToString, stringToJson } from "./index.js";
+var httpRequest, httpsRequest, parse, CustomAbortController;
+if (typeof require !== "undefined") {
+    CustomAbortController = require("abort-controller");
+    httpRequest = require("http").request;
+    httpsRequest = require("https").request;
+    parse = require("url").parse;
+} else if (typeof AbortController !== "undefined") {
+    CustomAbortController = AbortController;
+} else {
+    CustomAbortController = function () {
+        throw new Error('AbortController is not defined');
+    };
+}
+var Interceptors = function () {
+    function Interceptors() {}
+    Interceptors.prototype.use = function (type, fn) {
+        switch (type) {
+            case "request":
+                this.requestSuccess = fn;
+                break;
+            case "response":
+                this.responseSuccess = fn;
+                break;
+            case "error":
+                this.error = fn;
+                break;
+        }
+        return this;
+    };
+    Object.defineProperty(Interceptors.prototype, "reqFn", {
+        get: function () {
+            return this.requestSuccess;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Interceptors.prototype, "resFn", {
+        get: function () {
+            return this.responseSuccess;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Interceptors.prototype, "errFn", {
+        get: function () {
+            return this.error;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Interceptors;
+}();
+var RequestBase = function (_super) {
+    __extends(RequestBase, _super);
+    function RequestBase(origin) {
+        var _this = _super.call(this) || this;
+        _this.chackUrl = function (url) {
+            return url.startsWith('/');
+        };
+        _this.checkIsHttps = function (url) {
+            return url.startsWith('https');
+        };
+        _this.fixOrigin = function (fixStr) {
+            if (_this.chackUrl(fixStr)) return _this.origin + fixStr;
+            return fixStr;
+        };
+        _this.envDesc = function () {
+            if (typeof Window !== "undefined") {
+                return "Window";
+            }
+            return "Node";
+        };
+        _this.errorFn = function (reject) {
+            return function (err) {
+                var _a, _b;return reject((_b = (_a = _this.errFn) === null || _a === void 0 ? void 0 : _a.call(_this, err)) !== null && _b !== void 0 ? _b : err);
+            };
+        };
+        _this.clearTimer = function (opts) {
+            return !!opts.timer && (clearTimeout(opts.timer), opts.timer = null);
+        };
+        _this.initAbort = function (params) {
+            var controller = params.controller,
+                timer = params.timer,
+                timeout = params.timeout;
+            !!!timer && (params.timer = setTimeout(function () {
+                return controller.abort();
+            }, timeout));
+            return params;
+        };
+        _this.requestType = function () {
+            switch (_this.envDesc()) {
+                case "Window":
+                    return _this.fetch;
+                case "Node":
+                    return _this.http;
+            }
+        };
+        _this.getDataByType = function (type, response) {
+            switch (type) {
+                case "text":
+                case "json":
+                case "blob":
+                case "formData":
+                case "arrayBuffer":
+                    return response[type]();
+                default:
+                    return response['json']();
+            }
+        };
+        _this.formatBodyString = function (bodyString) {
+            return {
+                text: function () {
+                    return bodyString;
+                },
+                json: function () {
+                    var _a;return (_a = stringToJson(bodyString)) !== null && _a !== void 0 ? _a : bodyString;
+                },
+                blob: function () {
+                    return stringToJson(bodyString);
+                },
+                formData: function () {
+                    return stringToJson(bodyString);
+                },
+                arrayBuffer: function () {
+                    return stringToJson(bodyString);
+                }
+            };
+        };
+        _this.origin = origin !== null && origin !== void 0 ? origin : '';
+        return _this;
+    }
+    return RequestBase;
+}(Interceptors);
+var RequestInit = function (_super) {
+    __extends(RequestInit, _super);
+    function RequestInit(origin) {
+        var _this = _super.call(this, origin) || this;
+        _this.initDefaultParams = function (url, _a) {
+            var _b, _c;
+            var _d = _a.method,
+                method = _d === void 0 ? "GET" : _d,
+                _e = _a.query,
+                query = _e === void 0 ? {} : _e,
+                _f = _a.headers,
+                headers = _f === void 0 ? {} : _f,
+                _g = _a.body,
+                body = _g === void 0 ? null : _g,
+                _h = _a.timeout,
+                timeout = _h === void 0 ? 30 * 1000 : _h,
+                _j = _a.controller,
+                controller = _j === void 0 ? new CustomAbortController() : _j,
+                _k = _a.type,
+                type = _k === void 0 ? "json" : _k,
+                others = __rest(_a, ["method", "query", "headers", "body", "timeout", "controller", "type"]);
+            var __params = __assign({ url: url, method: method, query: query, headers: headers, body: method === "GET" ? null : jsonToString(body), timeout: timeout, signal: controller === null || controller === void 0 ? void 0 : controller.signal, controller: controller, type: type, timer: null }, others);
+            var params = (_c = (_b = _this.reqFn) === null || _b === void 0 ? void 0 : _b.call(_this, __params)) !== null && _c !== void 0 ? _c : __params;
+            params.url = urlJoin(_this.fixOrigin(url), __params.query);
+            return params;
+        };
+        _this.initFetchParams = function (url, opts) {
+            var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
+            return _temp;
+        };
+        _this.initHttpParams = function (url, opts) {
+            var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
+            var options = parse(_temp.url, true);
+            return __assign(__assign({}, _temp), options);
+        };
+        return _this;
+    }
+    return RequestInit;
+}(RequestBase);
+var Request = function (_super) {
+    __extends(Request, _super);
+    function Request(origin) {
+        var _this = _super.call(this, origin) || this;
+        _this.fetch = function (_url, _opts) {
+            var _a = defer(),
+                promise = _a.promise,
+                resolve = _a.resolve,
+                reject = _a.reject;
+            var _b = _this.initFetchParams(_url, _opts),
+                url = _b.url,
+                opts = __rest(_b, ["url"]);
+            var signal = opts.signal;
+            promise.finally(function () {
+                return _this.clearTimer(opts);
+            });
+            signal.addEventListener('abort', function () {
+                return _this.errorFn(reject);
+            });
+            fetch(url, opts).then(function (response) {
+                if ((response === null || response === void 0 ? void 0 : response.status) >= 200 && (response === null || response === void 0 ? void 0 : response.status) < 300) {
+                    return _this.getDataByType(opts.type, response);
+                }
+                return _this.errorFn(reject);
+            }).then(function (res) {
+                var _a, _b;return resolve((_b = (_a = _this.resFn) === null || _a === void 0 ? void 0 : _a.call(_this, res)) !== null && _b !== void 0 ? _b : res);
+            }).catch(_this.errorFn(reject));
+            return promise;
+        };
+        _this.http = function (_url, _opts) {
+            var _a = defer(),
+                promise = _a.promise,
+                resolve = _a.resolve,
+                reject = _a.reject;
+            var params = _this.initHttpParams(_url, _opts);
+            var signal = params.signal,
+                url = params.url;
+            promise.finally(function () {
+                return _this.clearTimer(params);
+            });
+            var request = _this.checkIsHttps(url) ? httpsRequest : httpRequest;
+            var req = request(params, function (response) {
+                if ((response === null || response === void 0 ? void 0 : response.statusCode) >= 200 && (response === null || response === void 0 ? void 0 : response.statusCode) < 300) {
+                    var data_1 = "";
+                    response.setEncoding('utf8');
+                    response.on('data', function (chunk) {
+                        return data_1 += chunk;
+                    });
+                    return response.on("end", function () {
+                        var _a, _b;
+                        var result = _this.getDataByType(params.type, _this.formatBodyString(data_1));
+                        resolve((_b = (_a = _this.resFn) === null || _a === void 0 ? void 0 : _a.call(_this, result)) !== null && _b !== void 0 ? _b : result);
+                    });
+                }
+                return _this.errorFn(reject)(response === null || response === void 0 ? void 0 : response.statusMessage);
+            });
+            signal.addEventListener('abort', function () {
+                return _this.errorFn(reject)(req.destroy(new Error('request timeout')));
+            });
+            req.on('error', _this.errorFn(reject));
+            req.end();
+            return promise;
+        };
+        _this.GET = function (url, query, _, opts) {
+            return _this.request(url, __assign({ query: query, method: "GET" }, opts));
+        };
+        _this.POST = function (url, query, body, opts) {
+            return _this.request(url, __assign({ query: query, method: "POST", body: body }, opts));
+        };
+        _this.PUT = function (url, query, body, opts) {
+            return _this.request(url, __assign({ query: query, method: "PUT", body: body }, opts));
+        };
+        _this.DELETE = function (url, query, body, opts) {
+            return _this.request(url, __assign({ query: query, method: "DELETE", body: body }, opts));
+        };
+        _this.OPTIONS = function (url, query, body, opts) {
+            return _this.request(url, __assign({ query: query, method: "OPTIONS", body: body }, opts));
+        };
+        _this.HEAD = function (url, query, body, opts) {
+            return _this.request(url, __assign({ query: query, method: "HEAD", body: body }, opts));
+        };
+        _this.PATCH = function (url, query, body, opts) {
+            return _this.request(url, __assign({ query: query, method: "PATCH", body: body }, opts));
+        };
+        _this.request = _this.requestType();
+        return _this;
+    }
+    return Request;
+}(RequestInit);
+export { Request };
+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 = {}));
+;
+export var setStorage = function (key, val) {
+    try {
+        localStorage.setItem(key, JSON.stringify(val));
+    } catch (error) {
+        console.error(error);
+    }
+};
+export var getStorage = function (key) {
+    try {
+        var str = localStorage.getItem(key);
+        if (str === null || str === undefined) {
+            return null;
+        }
+        return JSON.parse(str);
+    } catch (error) {
+        console.error(error);
+        return null;
+    }
+};
+export var clearStorage = function (key) {
+    try {
+        key && localStorage.removeItem(key);
+        !key && localStorage.clear();
+    } catch (error) {
+        console.error(error);
+    }
+};
+export {};