refactor: 优化eslint配置，提升代码质量 (#1341)

* feat: 统一并标准化eslint

* lint: napcat.webui

* lint: napcat.webui

* lint: napcat.core

* build: fix

* lint: napcat.webui

* refactor: 重构eslint

* Update README.md

src/common/cancel-task.ts

@@ -1,80 +1,79 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 export type TaskExecutor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: (callback: () => void) => void) => void | Promise<void>;
 
 export class CancelableTask<T> {
-    private promise: Promise<T>;
-    private cancelCallback: (() => void) | null = null;
-    private isCanceled = false;
-    private cancelListeners: Array<() => void> = [];
+  private promise: Promise<T>;
+  private cancelCallback: (() => void) | null = null;
+  private isCanceled = false;
+  private cancelListeners: Array<() => void> = [];
 
-    constructor(executor: TaskExecutor<T>) {
-        this.promise = new Promise<T>((resolve, reject) => {
-            const onCancel = (callback: () => void) => {
-                this.cancelCallback = callback;
-            };
+  constructor (executor: TaskExecutor<T>) {
+    this.promise = new Promise<T>((resolve, reject) => {
+      const onCancel = (callback: () => void) => {
+        this.cancelCallback = callback;
+      };
 
-            const execute = async () => {
-                try {
-                    await executor(
-                        (value) => {
-                            if (!this.isCanceled) {
-                                resolve(value);
-                            }
-                        },
-                        (reason) => {
-                            if (!this.isCanceled) {
-                                reject(reason);
-                            }
-                        },
-                        onCancel
-                    );
-                } catch (error) {
-                    if (!this.isCanceled) {
-                        reject(error);
-                    }
-                }
-            };
-
-            execute();
-        });
-    }
-
-    public cancel() {
-        if (this.cancelCallback) {
-            this.cancelCallback();
+      const execute = async () => {
+        try {
+          await executor(
+            (value) => {
+              if (!this.isCanceled) {
+                resolve(value);
+              }
+            },
+            (reason) => {
+              if (!this.isCanceled) {
+                reject(reason);
+              }
+            },
+            onCancel
+          );
+        } catch (error) {
+          if (!this.isCanceled) {
+            reject(error);
+          }
         }
-        this.isCanceled = true;
-        this.cancelListeners.forEach(listener => listener());
-    }
+      };
 
-    public isTaskCanceled(): boolean {
-        return this.isCanceled;
-    }
+      execute();
+    });
+  }
 
-    public onCancel(listener: () => void) {
-        this.cancelListeners.push(listener);
+  public cancel () {
+    if (this.cancelCallback) {
+      this.cancelCallback();
     }
+    this.isCanceled = true;
+    this.cancelListeners.forEach(listener => listener());
+  }
 
-    public then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
-        onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
-    ): Promise<TResult1 | TResult2> {
-        return this.promise.then(onfulfilled, onrejected);
-    }
+  public isTaskCanceled (): boolean {
+    return this.isCanceled;
+  }
 
-    public catch<TResult = never>(
-        onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null
-    ): Promise<T | TResult> {
-        return this.promise.catch(onrejected);
-    }
+  public onCancel (listener: () => void) {
+    this.cancelListeners.push(listener);
+  }
 
-    public finally(onfinally?: (() => void) | undefined | null): Promise<T> {
-        return this.promise.finally(onfinally);
-    }
+  public then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+  ): Promise<TResult1 | TResult2> {
+    return this.promise.then(onfulfilled, onrejected);
+  }
 
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => this.promise.then(value => ({ value, done: true })),
-        };
-    }
-}
+  public catch<TResult = never>(
+    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null
+  ): Promise<T | TResult> {
+    return this.promise.catch(onrejected);
+  }
+
+  public finally (onfinally?: (() => void) | undefined | null): Promise<T> {
+    return this.promise.finally(onfinally);
+  }
+
+  [Symbol.asyncIterator] () {
+    return {
+      next: () => this.promise.then(value => ({ value, done: true })),
+    };
+  }
+}