From 067e0312fe74a7e1bb9b76ead690edf799f052b7 Mon Sep 17 00:00:00 2001
From: CRIMX <straybugs@gmail.com>
Date: Mon, 13 Jan 2025 11:39:35 +0800
Subject: [PATCH] refactor: clean code

---
 src/abortable.ts | 29 ++++++++++++-----------------
 src/utils.ts     | 15 +++++++--------
 2 files changed, 19 insertions(+), 25 deletions(-)

diff --git a/src/abortable.ts b/src/abortable.ts
index 3c2de79..2d88fa4 100644
--- a/src/abortable.ts
+++ b/src/abortable.ts
@@ -7,7 +7,7 @@ import type {
   Disposer,
 } from "./interface";
 
-import { dispose } from "./utils";
+import { dispose, isFn } from "./utils";
 
 /**
  * A {@link DisposableDisposer} that can be safely self-disposed.
@@ -16,12 +16,13 @@ import { dispose } from "./utils";
 interface AbortableDisposable {
   (): any;
   dispose: (this: void) => any;
-  abortable: (onDispose?: () => void) => void;
+  abortable: (onDispose: () => void) => void;
 }
 
 interface AbortableDisposableImpl extends AbortableDisposable {
-  /** onDisposer */
-  _o?: (() => any) | null;
+  abortable: (onDispose?: () => void) => void;
+  /** deps */
+  _o?: (() => any) | null | void;
 }
 
 /**
@@ -47,14 +48,11 @@ interface AbortableDisposableImpl extends AbortableDisposable {
  * ```
  */
 export const abortable: (disposable: DisposableType) => DisposableDisposer = (
-  disposable: DisposableType | null
+  disposable: DisposableType | void
 ): DisposableDisposer => {
   const abortable: AbortableDisposableImpl = (): void => {
     abortable.abortable();
-    if (disposable) {
-      dispose(disposable);
-      disposable = null;
-    }
+    disposable = dispose(disposable);
   };
   abortable.dispose = abortable;
   abortable.abortable = abortable$abortable;
@@ -65,16 +63,13 @@ function abortable$abortable(
   this: AbortableDisposableImpl,
   onDispose?: () => void
 ): void {
-  if (this._o) {
-    try {
-      this._o();
-    } catch (e) {
-      console.error(e);
-    }
-  }
+  dispose(this?._o);
   this._o = onDispose;
 }
 
 export const isAbortable = (
   disposable: any
-): disposable is AbortableDisposable => disposable && disposable.abortable;
+): disposable is AbortableDisposable =>
+  isFn(disposable) &&
+  isFn((disposable as AbortableDisposable).dispose) &&
+  isFn((disposable as AbortableDisposable).abortable);
diff --git a/src/utils.ts b/src/utils.ts
index 1d673a7..da6f425 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,20 +1,19 @@
-import type { Disposer, IDisposable } from "./interface";
+import type { DisposableType, Disposer, IDisposable } from "./interface";
+
+export const isFn = (value: any): value is (...args: any[]) => any =>
+  !!(value && value.constructor && value.call && value.apply);
 
 /**
  * Dispose a disposable object or a disposer function. Log the error if any.
  * @param disposable A disposable object or a disposer function. Do nothing otherwise.
  */
-export function dispose(disposable: any): void {
+export function dispose(disposable?: DisposableType | null | void): void {
   try {
     if (disposable) {
-      if ((disposable as IDisposable).dispose) {
+      if (isFn((disposable as IDisposable).dispose)) {
         // isDisposableObject
         (disposable as IDisposable).dispose();
-      } else if (
-        disposable.constructor &&
-        disposable.call &&
-        disposable.apply
-      ) {
+      } else if (isFn(disposable)) {
         // isFunction
         (disposable as Disposer)();
       }