style: format code for all

src/utils/algorithm/index.ts

@@ -8,14 +8,14 @@ class algorithmProxy implements ProxyAlgorithm {
   // 数组每一项添加索引字段
   public increaseIndexes<T>(val: Array<T>): Array<T> {
     return Object.keys(val)
-      .map((v) => {
+      .map(v => {
         return {
           // @ts-ignore
           ...val[v],
-          key: v,
+          key: v
         };
       })
-      .filter((v) => v.meta && v.meta.showLink);
+      .filter(v => v.meta && v.meta.showLink);
   }
 }
 

src/utils/debounce/index.ts

@@ -1,6 +1,6 @@
 // 延迟函数
 export const delay = (timeout: number) =>
-  new Promise((resolve) => setTimeout(resolve, timeout));
+  new Promise(resolve => setTimeout(resolve, timeout));
 
 // 防抖函数
 export const debounce = (fn: () => Fn, timeout: number) => {

src/utils/deviceDetection/index.ts

@@ -4,22 +4,16 @@ interface deviceInter {
 
 // 检测设备类型(手机返回true,反之)
 export const deviceDetection = () => {
-  let sUserAgent: deviceInter = navigator.userAgent.toLowerCase();
-  let bIsIpad = sUserAgent.match(/ipad/i) == "ipad";
-  let bIsIphoneOs = sUserAgent.match(/iphone os/i) == "iphone os";
-  let bIsMidp = sUserAgent.match(/midp/i) == "midp";
-  let bIsUc7 = sUserAgent.match(/rv:1.2.3.4/i) == "rv:1.2.3.4";
-  let bIsUc = sUserAgent.match(/ucweb/i) == "ucweb";
-  let bIsAndroid = sUserAgent.match(/android/i) == "android";
-  let bIsCE = sUserAgent.match(/windows ce/i) == "windows ce";
-  let bIsWM = sUserAgent.match(/windows mobile/i) == "windows mobile";
-  return bIsIphoneOs ||
-    bIsMidp ||
-    bIsUc7 ||
-    bIsUc ||
-    bIsAndroid ||
-    bIsCE ||
-    bIsWM
-    ? true
-    : false;
+  const sUserAgent: deviceInter = navigator.userAgent.toLowerCase();
+  // const bIsIpad = sUserAgent.match(/ipad/i) == "ipad";
+  const bIsIphoneOs = sUserAgent.match(/iphone os/i) == "iphone os";
+  const bIsMidp = sUserAgent.match(/midp/i) == "midp";
+  const bIsUc7 = sUserAgent.match(/rv:1.2.3.4/i) == "rv:1.2.3.4";
+  const bIsUc = sUserAgent.match(/ucweb/i) == "ucweb";
+  const bIsAndroid = sUserAgent.match(/android/i) == "android";
+  const bIsCE = sUserAgent.match(/windows ce/i) == "windows ce";
+  const bIsWM = sUserAgent.match(/windows mobile/i) == "windows mobile";
+  return (
+    bIsIphoneOs || bIsMidp || bIsUc7 || bIsUc || bIsAndroid || bIsCE || bIsWM
+  );
 };

src/utils/http/config.ts

@@ -9,8 +9,8 @@ export const defaultConfig: AxiosRequestConfig = {
   headers: {
     Accept: "application/json, text/plain, */*",
     "Content-Type": "application/json",
-    "X-Requested-With": "XMLHttpRequest",
-  },
+    "X-Requested-With": "XMLHttpRequest"
+  }
 };
 
 export function genConfig(config?: AxiosRequestConfig): AxiosRequestConfig {
@@ -22,7 +22,7 @@ export function genConfig(config?: AxiosRequestConfig): AxiosRequestConfig {
   if (headers && typeof headers === "object") {
     defaultConfig.headers = {
       ...defaultConfig.headers,
-      ...headers,
+      ...headers
     };
   }
   return { ...excludeProps(config!, "headers"), ...defaultConfig };

src/utils/http/core.ts

@@ -1,16 +1,14 @@
-
 import Axios, {
   AxiosRequestConfig,
   CancelTokenStatic,
-  AxiosInstance,
-  Canceler
-} from "axios"
+  AxiosInstance
+} from "axios";
 
-import NProgress from "../progress"
+import NProgress from "../progress";
 
-import { genConfig } from "./config"
+import { genConfig } from "./config";
 
-import { transformConfigByMethod } from "./utils"
+import { transformConfigByMethod } from "./utils";
 
 import {
   cancelTokenType,
@@ -18,12 +16,12 @@ import {
   EnclosureHttpRequestConfig,
   EnclosureHttpResoponse,
   EnclosureHttpError
-} from "./types.d"
+} from "./types.d";
 
 class EnclosureHttp {
   constructor() {
-    this.httpInterceptorsRequest()
-    this.httpInterceptorsResponse()
+    this.httpInterceptorsRequest();
+    this.httpInterceptorsResponse();
   }
   // 初始化配置对象
   private static initConfig: EnclosureHttpRequestConfig = {};
@@ -32,7 +30,7 @@ class EnclosureHttp {
   private static axiosInstance: AxiosInstance = Axios.create(genConfig());
 
   // 保存 EnclosureHttp实例
-  private static EnclosureHttpInstance: EnclosureHttp
+  private static EnclosureHttpInstance: EnclosureHttp;
 
   // axios取消对象
   private CancelToken: CancelTokenStatic = Axios.CancelToken;
@@ -43,17 +41,19 @@ class EnclosureHttp {
   // 记录当前这一次cancelToken的key
   private currentCancelTokenKey = "";
 
-  private beforeRequestCallback: EnclosureHttpRequestConfig["beforeRequestCallback"] = undefined;
+  private beforeRequestCallback: EnclosureHttpRequestConfig["beforeRequestCallback"] =
+    undefined;
 
-  private beforeResponseCallback: EnclosureHttpRequestConfig["beforeResponseCallback"] = undefined;
+  private beforeResponseCallback: EnclosureHttpRequestConfig["beforeResponseCallback"] =
+    undefined;
 
   public get cancelTokenList(): Array<cancelTokenType> {
-    return this.sourceTokenList
+    return this.sourceTokenList;
   }
 
   // eslint-disable-next-line class-methods-use-this
   public set cancelTokenList(value) {
-    throw new Error("cancelTokenList不允许赋值")
+    throw new Error("cancelTokenList不允许赋值");
   }
 
   /**
@@ -68,8 +68,8 @@ class EnclosureHttp {
    * @returns string
    */
   // eslint-disable-next-line class-methods-use-this
-  private genUniqueKey(config: EnclosureHttpRequestConfig): string {
-    return `${config.url}--${JSON.stringify(config.data)}`
+  private static genUniqueKey(config: EnclosureHttpRequestConfig): string {
+    return `${config.url}--${JSON.stringify(config.data)}`;
   }
 
   /**
@@ -77,21 +77,21 @@ class EnclosureHttp {
    * @returns void 0
    */
   private cancelRepeatRequest(): void {
-    const temp: { [key: string]: boolean } = {}
+    const temp: { [key: string]: boolean } = {};
 
     this.sourceTokenList = this.sourceTokenList.reduce<Array<cancelTokenType>>(
       (res: Array<cancelTokenType>, cancelToken: cancelTokenType) => {
-        const { cancelKey, cancelExecutor } = cancelToken
+        const { cancelKey, cancelExecutor } = cancelToken;
         if (!temp[cancelKey]) {
-          temp[cancelKey] = true
-          res.push(cancelToken)
+          temp[cancelKey] = true;
+          res.push(cancelToken);
         } else {
-          cancelExecutor()
+          cancelExecutor();
         }
-        return res
+        return res;
       },
       []
-    )
+    );
   }
 
   /**
@@ -102,9 +102,9 @@ class EnclosureHttp {
     this.sourceTokenList =
       this.sourceTokenList.length < 1
         ? this.sourceTokenList.filter(
-          cancelToken => cancelToken.cancelKey !== cancelKey
-        )
-        : []
+            cancelToken => cancelToken.cancelKey !== cancelKey
+          )
+        : [];
   }
 
   /**
@@ -115,30 +115,32 @@ class EnclosureHttp {
   private httpInterceptorsRequest(): void {
     EnclosureHttp.axiosInstance.interceptors.request.use(
       (config: EnclosureHttpRequestConfig) => {
-        const $config = config
-        NProgress.start()   // 每次切换页面时，调用进度条
-        const cancelKey = this.genUniqueKey($config)
-        $config.cancelToken = new this.CancelToken((cancelExecutor: (cancel: any) => void) => {
-          this.sourceTokenList.push({ cancelKey, cancelExecutor })
-        })
-        this.cancelRepeatRequest()
-        this.currentCancelTokenKey = cancelKey
+        const $config = config;
+        NProgress.start(); // 每次切换页面时，调用进度条
+        const cancelKey = EnclosureHttp.genUniqueKey($config);
+        $config.cancelToken = new this.CancelToken(
+          (cancelExecutor: (cancel: any) => void) => {
+            this.sourceTokenList.push({ cancelKey, cancelExecutor });
+          }
+        );
+        this.cancelRepeatRequest();
+        this.currentCancelTokenKey = cancelKey;
         // 优先判断post/get等方法是否传入回掉，否则执行初始化设置等回掉
         if (typeof this.beforeRequestCallback === "function") {
-          this.beforeRequestCallback($config)
-          this.beforeRequestCallback = undefined
-          return $config
+          this.beforeRequestCallback($config);
+          this.beforeRequestCallback = undefined;
+          return $config;
         }
         if (EnclosureHttp.initConfig.beforeRequestCallback) {
-          EnclosureHttp.initConfig.beforeRequestCallback($config)
-          return $config
+          EnclosureHttp.initConfig.beforeRequestCallback($config);
+          return $config;
         }
-        return $config
+        return $config;
       },
       error => {
-        return Promise.reject(error)
+        return Promise.reject(error);
       }
-    )
+    );
   }
 
   /**
@@ -146,7 +148,7 @@ class EnclosureHttp {
    * @returns void 0
    */
   public clearCancelTokenList(): void {
-    this.sourceTokenList.length = 0
+    this.sourceTokenList.length = 0;
   }
 
   /**
@@ -154,74 +156,75 @@ class EnclosureHttp {
    * @returns void 0
    */
   private httpInterceptorsResponse(): void {
-    const instance = EnclosureHttp.axiosInstance
+    const instance = EnclosureHttp.axiosInstance;
     instance.interceptors.response.use(
       (response: EnclosureHttpResoponse) => {
         // 请求每次成功一次就删除当前canceltoken标记
-        const cancelKey = this.genUniqueKey(response.config)
-        this.deleteCancelTokenByCancelKey(cancelKey)
+        const cancelKey = EnclosureHttp.genUniqueKey(response.config);
+        this.deleteCancelTokenByCancelKey(cancelKey);
         // 优先判断post/get等方法是否传入回掉，否则执行初始化设置等回掉
         if (typeof this.beforeResponseCallback === "function") {
-          this.beforeResponseCallback(response)
-          this.beforeResponseCallback = undefined
-          return response.data
+          this.beforeResponseCallback(response);
+          this.beforeResponseCallback = undefined;
+          return response.data;
         }
         if (EnclosureHttp.initConfig.beforeResponseCallback) {
-          EnclosureHttp.initConfig.beforeResponseCallback(response)
-          return response.data
+          EnclosureHttp.initConfig.beforeResponseCallback(response);
+          return response.data;
         }
-        NProgress.done()
-        return response.data
+        NProgress.done();
+        return response.data;
       },
       (error: EnclosureHttpError) => {
-        const $error = error
+        const $error = error;
         // 判断当前的请求中是否在 取消token数组理存在，如果存在则移除（单次请求流程）
         if (this.currentCancelTokenKey) {
           const haskey = this.sourceTokenList.filter(
             cancelToken => cancelToken.cancelKey === this.currentCancelTokenKey
-          ).length
+          ).length;
           if (haskey) {
             this.sourceTokenList = this.sourceTokenList.filter(
               cancelToken =>
                 cancelToken.cancelKey !== this.currentCancelTokenKey
-            )
-            this.currentCancelTokenKey = ""
+            );
+            this.currentCancelTokenKey = "";
           }
         }
-        $error.isCancelRequest = Axios.isCancel($error)
+        $error.isCancelRequest = Axios.isCancel($error);
         // 所有的响应异常 区分来源为取消请求/非取消请求
-        return Promise.reject($error)
+        return Promise.reject($error);
       }
-    )
+    );
   }
 
   public request<T>(
     method: RequestMethods,
     url: string,
     param?: AxiosRequestConfig,
-    axiosConfig?: EnclosureHttpRequestConfig,
+    axiosConfig?: EnclosureHttpRequestConfig
   ): Promise<T> {
     const config = transformConfigByMethod(param, {
       method,
       url,
       ...axiosConfig
-    } as EnclosureHttpRequestConfig)
+    } as EnclosureHttpRequestConfig);
     // 单独处理自定义请求/响应回掉
     if (axiosConfig?.beforeRequestCallback) {
-      this.beforeRequestCallback = axiosConfig.beforeRequestCallback
+      this.beforeRequestCallback = axiosConfig.beforeRequestCallback;
     }
     if (axiosConfig?.beforeResponseCallback) {
-      this.beforeResponseCallback = axiosConfig.beforeResponseCallback
+      this.beforeResponseCallback = axiosConfig.beforeResponseCallback;
     }
     return new Promise((resolve, reject) => {
-      EnclosureHttp.axiosInstance.request(config)
+      EnclosureHttp.axiosInstance
+        .request(config)
         .then((response: EnclosureHttpResoponse) => {
-          resolve(response)
+          resolve(response);
         })
         .catch((error: any) => {
-          reject(error)
-        })
-    })
+          reject(error);
+        });
+    });
   }
 
   public post<T>(
@@ -229,7 +232,7 @@ class EnclosureHttp {
     params?: T,
     config?: EnclosureHttpRequestConfig
   ): Promise<T> {
-    return this.request<T>("post", url, params, config)
+    return this.request<T>("post", url, params, config);
   }
 
   public get<T>(
@@ -237,8 +240,8 @@ class EnclosureHttp {
     params?: T,
     config?: EnclosureHttpRequestConfig
   ): Promise<T> {
-    return this.request<T>("get", url, params, config)
+    return this.request<T>("get", url, params, config);
   }
 }
 
-export default EnclosureHttp
+export default EnclosureHttp;

src/utils/http/index.ts

@@ -1,3 +1,2 @@
-import EnclosureHttp from "./core"
-export const http = new EnclosureHttp()
-
+import EnclosureHttp from "./core";
+export const http = new EnclosureHttp();

src/utils/http/utils.ts

@@ -1,4 +1,4 @@
-import { EnclosureHttpRequestConfig } from "./types.d"
+import { EnclosureHttpRequestConfig } from "./types.d";
 
 export function excludeProps<T extends { [key: string]: any }>(
   origin: T,
@@ -7,23 +7,23 @@ export function excludeProps<T extends { [key: string]: any }>(
   return Object.keys(origin)
     .filter(key => !prop.includes(key))
     .reduce((res, key) => {
-      res[key] = origin[key]
-      return res
-    }, {} as { [key: string]: T })
+      res[key] = origin[key];
+      return res;
+    }, {} as { [key: string]: T });
 }
 
 export function transformConfigByMethod(
   params: any,
   config: EnclosureHttpRequestConfig
 ): EnclosureHttpRequestConfig {
-  const { method } = config
+  const { method } = config;
   const props = ["delete", "get", "head", "options"].includes(
     method!.toLocaleLowerCase()
   )
     ? "params"
-    : "data"
+    : "data";
   return {
     ...config,
     [props]: params
-  }
+  };
 }

src/utils/is.ts

@@ -1,94 +1,101 @@
-const toString = Object.prototype.toString
+/* eslint-disable */
+const toString = Object.prototype.toString;
 
 export function is(val: unknown, type: string) {
-  return toString.call(val) === `[object ${type}]`
+  return toString.call(val) === `[object ${type}]`;
 }
 
 export function isDef<T = unknown>(val?: T): val is T {
-  return typeof val !== 'undefined'
+  return typeof val !== "undefined";
 }
 
 export function isUnDef<T = unknown>(val?: T): val is T {
-  return !isDef(val)
+  return !isDef(val);
 }
 
 export function isObject(val: any): val is Record<any, any> {
-  return val !== null && is(val, 'Object')
+  return val !== null && is(val, "Object");
 }
 
 export function isEmpty<T = unknown>(val: T): val is T {
   if (isArray(val) || isString(val)) {
-    return val.length === 0
+    return val.length === 0;
   }
 
   if (val instanceof Map || val instanceof Set) {
-    return val.size === 0
+    return val.size === 0;
   }
 
   if (isObject(val)) {
-    return Object.keys(val).length === 0
+    return Object.keys(val).length === 0;
   }
 
-  return false
+  return false;
 }
 
 export function isDate(val: unknown): val is Date {
-  return is(val, 'Date')
+  return is(val, "Date");
 }
 
 export function isNull(val: unknown): val is null {
-  return val === null
+  return val === null;
 }
 
 export function isNullAndUnDef(val: unknown): val is null | undefined {
-  return isUnDef(val) && isNull(val)
+  return isUnDef(val) && isNull(val);
 }
 
 export function isNullOrUnDef(val: unknown): val is null | undefined {
-  return isUnDef(val) || isNull(val)
+  return isUnDef(val) || isNull(val);
 }
 
 export function isNumber(val: unknown): val is number {
-  return is(val, 'Number')
+  return is(val, "Number");
 }
 
 export function isPromise<T = any>(val: unknown): val is Promise<T> {
-  return is(val, 'Promise') && isObject(val) && isFunction(val.then) && isFunction(val.catch)
+  return (
+    is(val, "Promise") &&
+    isObject(val) &&
+    isFunction(val.then) &&
+    isFunction(val.catch)
+  );
 }
 
 export function isString(val: unknown): val is string {
-  return is(val, 'String')
+  return is(val, "String");
 }
 
 export function isFunction(val: unknown): val is Function {
-  return typeof val === 'function'
+  return typeof val === "function";
 }
 
 export function isBoolean(val: unknown): val is boolean {
-  return is(val, 'Boolean')
+  return is(val, "Boolean");
 }
 
 export function isRegExp(val: unknown): val is RegExp {
-  return is(val, 'RegExp')
+  return is(val, "RegExp");
 }
 
 export function isArray(val: any): val is Array<any> {
-  return val && Array.isArray(val)
+  return val && Array.isArray(val);
 }
 
 export function isWindow(val: any): val is Window {
-  return typeof window !== 'undefined' && is(val, 'Window')
+  return typeof window !== "undefined" && is(val, "Window");
 }
 
 export function isElement(val: unknown): val is Element {
-  return isObject(val) && !!val.tagName
+  return isObject(val) && !!val.tagName;
 }
 
-export const isServer = typeof window === 'undefined'
+export const isServer = typeof window === "undefined";
 
-export const isClient = !isServer
+export const isClient = !isServer;
 
 export function isUrl(path: string): boolean {
-  const reg = /(((^https?:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+(?::\d+)?|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)$/
-  return reg.test(path)
+  const reg =
+    /(((^https?:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+(?::\d+)?|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)$/;
+  return reg.test(path);
 }

src/utils/loaders/index.ts

@@ -1,54 +1,54 @@
 interface ProxyLoader {
-  loadCss(src: string): any
-  loadScript(src: string): Promise<any>
-  loadScriptConcurrent(src: Array<string>): Promise<any>
+  loadCss(src: string): any;
+  loadScript(src: string): Promise<any>;
+  loadScriptConcurrent(src: Array<string>): Promise<any>;
 }
 
 class loaderProxy implements ProxyLoader {
+  constructor() {}
 
-  constructor() { }
-
-  protected scriptLoaderCache: Array<string> = []
+  protected scriptLoaderCache: Array<string> = [];
 
   public loadCss = (src: string): any => {
-    let element:HTMLLinkElement = document.createElement("link")
-    element.rel = "stylesheet"
-    element.href = src
-    document.body.appendChild(element)
-  }
+    const element: HTMLLinkElement = document.createElement("link");
+    element.rel = "stylesheet";
+    element.href = src;
+    document.body.appendChild(element);
+  };
 
   public loadScript = async (src: string): Promise<any> => {
     if (this.scriptLoaderCache.includes(src)) {
-      return src
+      return src;
     } else {
-      let element: HTMLScriptElement = document.createElement("script")
-      element.src = src
-      document.body.appendChild(element)
+      const element: HTMLScriptElement = document.createElement("script");
+      element.src = src;
+      document.body.appendChild(element);
       element.onload = () => {
-        return this.scriptLoaderCache.push(src)
-      }
+        return this.scriptLoaderCache.push(src);
+      };
     }
-  }
+  };
 
-  public loadScriptConcurrent = async (srcList: Array<string>): Promise<any> => {
+  public loadScriptConcurrent = async (
+    srcList: Array<string>
+  ): Promise<any> => {
     if (Array.isArray(srcList)) {
-      const len: number = srcList.length
+      const len: number = srcList.length;
       if (len > 0) {
-        let count: number = 0
+        let count = 0;
         srcList.map(src => {
           if (src) {
             this.loadScript(src).then(() => {
-              count++
+              count++;
               if (count === len) {
-                return
+                return;
               }
-            })
+            });
           }
-        })
+        });
       }
     }
-  }
-
+  };
 }
 
-export const loader = new loaderProxy()
+export const loader = new loaderProxy();

src/utils/message/index.ts

@@ -1,12 +1,12 @@
-import { ElMessage } from "element-plus"
+import { ElMessage } from "element-plus";
 
 // 消息
 const Message = (message: string): any => {
   return ElMessage({
     showClose: true,
     message
-  })
-}
+  });
+};
 
 // 成功
 const successMessage = (message: string): any => {
@@ -14,8 +14,8 @@ const successMessage = (message: string): any => {
     showClose: true,
     message,
     type: "success"
-  })
-}
+  });
+};
 
 // 警告
 const warnMessage = (message: string): any => {
@@ -23,8 +23,8 @@ const warnMessage = (message: string): any => {
     showClose: true,
     message,
     type: "warning"
-  })
-}
+  });
+};
 
 // 失败
 const errorMessage = (message: string): any => {
@@ -32,12 +32,7 @@ const errorMessage = (message: string): any => {
     showClose: true,
     message,
     type: "error"
-  })
-}
+  });
+};
 
-export {
-  Message,
-  successMessage,
-  warnMessage,
-  errorMessage
-}
+export { Message, successMessage, warnMessage, errorMessage };

src/utils/mitt.ts

@@ -1,4 +1,4 @@
-import type { Emitter }  from 'mitt';
-import mitt from 'mitt';
+import type { Emitter } from "mitt";
+import mitt from "mitt";
 
-export const emitter: Emitter = mitt();
+export const emitter: Emitter = mitt();

src/utils/progress/index.ts

@@ -1,12 +1,12 @@
-import NProgress from "nprogress"
-import "nprogress/nprogress.css"
+import NProgress from "nprogress";
+import "nprogress/nprogress.css";
 
 NProgress.configure({
-  easing: 'ease', // 动画方式    
-  speed: 500, // 递增进度条的速度    
-  showSpinner: true, // 是否显示加载ico    
-  trickleSpeed: 200, // 自动递增间隔    
+  easing: "ease", // 动画方式
+  speed: 500, // 递增进度条的速度
+  showSpinner: true, // 是否显示加载ico
+  trickleSpeed: 200, // 自动递增间隔
   minimum: 0.3 // 初始化时的最小百分比
-})
+});
 
-export default NProgress
+export default NProgress;

src/utils/propTypes.ts

@@ -1,12 +1,12 @@
-import { CSSProperties, VNodeChild } from 'vue'
-import { createTypes, VueTypeValidableDef, VueTypesInterface } from 'vue-types'
+import { CSSProperties, VNodeChild } from "vue";
+import { createTypes, VueTypeValidableDef, VueTypesInterface } from "vue-types";
 
-export type VueNode = VNodeChild | JSX.Element
+export type VueNode = VNodeChild | JSX.Element;
 
 type PropTypes = VueTypesInterface & {
-  readonly style: VueTypeValidableDef<CSSProperties>
-  readonly VNodeChild: VueTypeValidableDef<VueNode>
-}
+  readonly style: VueTypeValidableDef<CSSProperties>;
+  readonly VNodeChild: VueTypeValidableDef<VueNode>;
+};
 
 const propTypes = createTypes({
   func: undefined,
@@ -14,20 +14,20 @@ const propTypes = createTypes({
   string: undefined,
   number: undefined,
   object: undefined,
-  integer: undefined,
-}) as PropTypes
+  integer: undefined
+}) as PropTypes;
 
 propTypes.extend([
   {
-    name: 'style',
+    name: "style",
     getter: true,
     type: [String, Object],
-    default: undefined,
+    default: undefined
   },
   {
-    name: 'VNodeChild',
+    name: "VNodeChild",
     getter: true,
-    type: undefined,
+    type: undefined
   }
-])
-export { propTypes }
+]);
+export { propTypes };

src/utils/resize/index.ts

@@ -1,32 +1,35 @@
-import ResizeObserver from 'resize-observer-polyfill'
+import ResizeObserver from "resize-observer-polyfill";
 
-const isServer = typeof window === 'undefined'
+const isServer = typeof window === "undefined";
 
 const resizeHandler = (entries: any[]): void => {
   for (const entry of entries) {
-    const listeners = entry.target.__resizeListeners__ || []
+    const listeners = entry.target.__resizeListeners__ || [];
     if (listeners.length) {
       listeners.forEach((fn: () => any) => {
-        fn()
-      })
+        fn();
+      });
     }
   }
-}
+};
 
 export const addResizeListener = (element: any, fn: () => any): any => {
-  if (isServer) return
+  if (isServer) return;
   if (!element.__resizeListeners__) {
-    element.__resizeListeners__ = []
-    element.__ro__ = new ResizeObserver(resizeHandler)
-    element.__ro__.observe(element)
+    element.__resizeListeners__ = [];
+    element.__ro__ = new ResizeObserver(resizeHandler);
+    element.__ro__.observe(element);
   }
-  element.__resizeListeners__.push(fn)
-}
+  element.__resizeListeners__.push(fn);
+};
 
 export const removeResizeListener = (element: any, fn: () => any): any => {
-  if (!element || !element.__resizeListeners__) return
-  element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1)
+  if (!element || !element.__resizeListeners__) return;
+  element.__resizeListeners__.splice(
+    element.__resizeListeners__.indexOf(fn),
+    1
+  );
   if (!element.__resizeListeners__.length) {
-    element.__ro__.disconnect()
+    element.__ro__.disconnect();
   }
-}
+};

src/utils/useAttrs.ts

@@ -1,39 +1,42 @@
-import { getCurrentInstance, reactive, shallowRef, watchEffect } from 'vue'
-import type { Ref } from 'vue'
+import { getCurrentInstance, reactive, shallowRef, watchEffect } from "vue";
+import type { Ref } from "vue";
 interface Params {
-  excludeListeners?: boolean
-  excludeKeys?: string[]
+  excludeListeners?: boolean;
+  excludeKeys?: string[];
 }
 
-const DEFAULT_EXCLUDE_KEYS = ['class', 'style']
-const LISTENER_PREFIX = /^on[A-Z]/
+const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
+const LISTENER_PREFIX = /^on[A-Z]/;
 
 export function entries<T>(obj: Recordable<T>): [string, T][] {
-  return Object.keys(obj).map((key: string) => [key, obj[key]])
+  return Object.keys(obj).map((key: string) => [key, obj[key]]);
 }
 
 export function useAttrs(params: Params = {}): Ref<Recordable> | {} {
-  const instance = getCurrentInstance()
-  if (!instance) return {}
+  const instance = getCurrentInstance();
+  if (!instance) return {};
 
-  const { excludeListeners = false, excludeKeys = [] } = params
-  const attrs = shallowRef({})
-  const allExcludeKeys = excludeKeys.concat(DEFAULT_EXCLUDE_KEYS)
+  const { excludeListeners = false, excludeKeys = [] } = params;
+  const attrs = shallowRef({});
+  const allExcludeKeys = excludeKeys.concat(DEFAULT_EXCLUDE_KEYS);
 
   // Since attrs are not reactive, make it reactive instead of doing in `onUpdated` hook for better performance
-  instance.attrs = reactive(instance.attrs)
+  instance.attrs = reactive(instance.attrs);
 
   watchEffect(() => {
     const res = entries(instance.attrs).reduce((acm, [key, val]) => {
-      if (!allExcludeKeys.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))) {
-        acm[key] = val
+      if (
+        !allExcludeKeys.includes(key) &&
+        !(excludeListeners && LISTENER_PREFIX.test(key))
+      ) {
+        acm[key] = val;
       }
 
-      return acm
-    }, {} as Recordable)
+      return acm;
+    }, {} as Recordable);
 
-    attrs.value = res
-  })
+    attrs.value = res;
+  });
 
-  return attrs
+  return attrs;
 }

src/utils/uuid.ts

@@ -1,28 +1,28 @@
-const hexList: string[] = []
+const hexList: string[] = [];
 for (let i = 0; i <= 15; i++) {
-  hexList[i] = i.toString(16)
+  hexList[i] = i.toString(16);
 }
 
 export function buildUUID(): string {
-  let uuid = ''
+  let uuid = "";
   for (let i = 1; i <= 36; i++) {
     if (i === 9 || i === 14 || i === 19 || i === 24) {
-      uuid += '-'
+      uuid += "-";
     } else if (i === 15) {
-      uuid += 4
+      uuid += 4;
     } else if (i === 20) {
-      uuid += hexList[(Math.random() * 4) | 8]
+      uuid += hexList[(Math.random() * 4) | 8];
     } else {
-      uuid += hexList[(Math.random() * 16) | 0]
+      uuid += hexList[(Math.random() * 16) | 0];
     }
   }
-  return uuid.replace(/-/g, '')
+  return uuid.replace(/-/g, "");
 }
 
-let unique = 0
-export function buildShortUUID(prefix = ''): string {
-  const time = Date.now()
-  const random = Math.floor(Math.random() * 1000000000)
-  unique++
-  return prefix + '_' + random + unique + String(time)
+let unique = 0;
+export function buildShortUUID(prefix = ""): string {
+  const time = Date.now();
+  const random = Math.floor(Math.random() * 1000000000);
+  unique++;
+  return prefix + "_" + random + unique + String(time);
 }