feat: add isDisposable

src/abortable.ts

@@ -6,7 +6,7 @@ import {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in type doc
   type Disposer,
 } from "./interface";
-import { dispose, isFn } from "./utils";
+import { dispose, isDisposable, isFn } from "./utils";
 
 /**
  * A {@link DisposableDisposer} that can be safely self-disposed.
@@ -69,6 +69,5 @@ function abortable$abortable(
 export const isAbortable = (
   disposable: any
 ): disposable is AbortableDisposable =>
-  isFn(disposable) &&
-  isFn((disposable as AbortableDisposable).dispose) &&
+  isDisposable(disposable) &&
   isFn((disposable as AbortableDisposable).abortable);

src/index.ts

@@ -10,4 +10,4 @@ export type {
   IDisposable,
 } from "./interface";
 export { join } from "./join";
-export { dispose } from "./utils";
+export { dispose, isDisposable } from "./utils";

src/join.ts

@@ -1,7 +1,5 @@
 import { type DisposableType, type Disposer } from "./interface";
 import { dispose } from "./utils";
 
-export const join =
-  (...disposers: DisposableType[]): Disposer =>
-  () =>
-    disposers.forEach(dispose);
+export const join = (...disposers: DisposableType[]): Disposer =>
+  disposers.forEach.bind(disposers, dispose);

src/utils.ts

@@ -1,8 +1,15 @@
-import { type Disposer, type IDisposable } from "./interface";
+import {
+  type DisposableType,
+  type Disposer,
+  type IDisposable,
+} from "./interface";
 
 export const isFn = (value: any): value is (...args: any[]) => any =>
   !!(value && value.constructor && value.call && value.apply);
 
+export const isDisposable = (value: any): value is DisposableType =>
+  isFn(value as Disposer) || isFn((value as IDisposable)?.dispose);
+
 /**
  * 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.

test/utils.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+
+import { type Disposer, type IDisposable, isDisposable } from "../src";
+
+describe("isDisposable", () => {
+  it("should returns true for Disposer", () => {
+    const a = () => void 0;
+    const b: Disposer = () => void 0;
+    expect(isDisposable(a)).toBe(true);
+    expect(isDisposable(b)).toBe(true);
+  });
+
+  it("should returns true for IDisposable", () => {
+    const a = { dispose() {} };
+    const b: IDisposable = { dispose: () => {} };
+    expect(isDisposable(a)).toBe(true);
+    expect(isDisposable(b)).toBe(true);
+  });
+
+  it("should returns false for other types", () => {
+    const a = {};
+    const b = () => {};
+    expect(isDisposable(a)).toBe(false);
+    expect(isDisposable(b)).toBe(false);
+  });
+});