chore: updating & cleaning dependencies

Author: martinheidegger

package.json

@@ -50,24 +50,23 @@
     "/src/types/"
   ],
   "dependencies": {
-    "@sindresorhus/is": "^4.0.0",
     "abort-controller": "^3.0.0",
-    "event-target-shim": "^5.0.0"
+    "event-target-shim": "^6.0.2"
   },
   "devDependencies": {
     "@leichtgewicht/pack-ts": "^1.0.1",
-    "@types/jest": "^26.0.16",
-    "@types/libsodium-wrappers-sumo": "^0.7.4",
-    "@typescript-eslint/eslint-plugin": "^4.9.0",
-    "eslint": "^7.15.0",
-    "eslint-config-standard-with-typescript": "^19.0.1",
+    "@types/jest": "^26.0.22",
+    "@types/libsodium-wrappers-sumo": "^0.7.5",
+    "@typescript-eslint/eslint-plugin": "^4.20.0",
+    "eslint": "^7.23.0",
+    "eslint-config-standard-with-typescript": "^20.0.0",
     "eslint-plugin-import": "^2.22.1",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-promise": "^4.3.1",
     "eslint-plugin-standard": "^5.0.0",
     "jest": "^26.6.3",
-    "ts-jest": "^26.4.4",
-    "typescript": "^4.1.2"
+    "ts-jest": "^26.5.4",
+    "typescript": "^4.2.3"
   },
   "repository": {
     "type": "git",

src/__tests__/composeAbort.test.ts

@@ -55,45 +55,4 @@ describe('composeAbort(signal?)', () => {
       composeAbort(parent.signal)
     }).toThrowError(AbortError)
   })
-  it('composing will not add an unnecessary event listener', async () => {
-    const parent = new AbortController()
-    const listeners: { [key in string]: Set<any>} = {}
-    parent.signal.addEventListener = function (...[type, listener]: Parameters<typeof AbortSignal.prototype.addEventListener>) {
-      AbortSignal.prototype.addEventListener.call(this, type, listener)
-      if (listener === null) return
-      let forEvent = listeners[type]
-      if (forEvent === undefined) {
-        forEvent = new Set()
-        listeners[type] = forEvent
-      }
-      forEvent.add(listener)
-    }
-    parent.signal.removeEventListener = function (...[type, listener]: Parameters<typeof AbortSignal.prototype.removeEventListener>) {
-      AbortSignal.prototype.removeEventListener.call(this, type, listener)
-      if (listener === null) return
-      const forEvent = listeners[type]
-      if (forEvent === undefined) return
-      forEvent.delete(listener)
-      if (forEvent.size === 0) {
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete listeners[type]
-      }
-    }
-    const child = composeAbort(parent.signal)
-    expect(child.signal.aborted).toBe(false)
-    expect(listeners).toEqual({})
-    const listener = (): void => {}
-    child.signal.addEventListener('otherEvent', listener)
-    expect(listeners).toEqual({})
-    child.signal.addEventListener('abort', listener)
-    expect(listeners.abort?.size).toEqual(1)
-    child.signal.removeEventListener('abort', listener)
-    expect(listeners).toEqual({})
-    child.signal.addEventListener('abort', listener)
-    expect(listeners.abort?.size).toEqual(1)
-    child.abort()
-    expect(listeners).toEqual({})
-    child.signal.addEventListener('abort', listener)
-    expect(listeners).toEqual({})
-  })
 })

src/bubbleAbort.ts

@@ -1,4 +1,5 @@
 import { AbortError } from './AbortError'
+import { AbortSignal } from 'abort-controller'
 
 /**
  * Simple function that throws an AbortError if an AbortSignal
@@ -22,7 +23,7 @@ import { AbortError } from './AbortError'
  * @see checkpoint for an alternative syntax that requires less typing.
  * @see AbortError
  */
-export function bubbleAbort (signal?: AbortSignal | null): void {
+export function bubbleAbort (signal?: AbortSignal | null | undefined): void {
   if (signal === undefined || signal === null) {
     return
   }

src/checkpoint.ts

@@ -1,4 +1,5 @@
 import { AbortError } from './AbortError'
+import { AbortSignal } from 'abort-controller'
 
 const cache = new WeakMap<AbortSignal, CheckPoint>()
 const passthrough: CheckPoint = <T> (input?: () => T): T | undefined => {

src/cleanupPromise.ts

@@ -1,4 +1,4 @@
-import is from '@sindresorhus/is'
+import { AbortSignal } from 'abort-controller'
 import { TimeoutOptions } from './options'
 import { AbortError } from './AbortError'
 import { wrapTimeout } from './wrapTimeout'
@@ -81,7 +81,7 @@ export async function cleanupPromise <T = unknown> (
         return
       }
       const withCleanup = (cleanup: any): void => {
-        const hasSignal = !is.nullOrUndefined(signal)
+        const hasSignal = signal !== null && signal !== undefined
         // @ts-expect-error 2532 - signal is certainly not undefined with hasSignal
         if (hasSignal && signal.aborted) {
           earlyFinish = earlyFinish ?? { error: new AbortError() }
@@ -92,7 +92,7 @@ export async function cleanupPromise <T = unknown> (
             if ('error' in finish) {
               return reject(finish.error)
             }
-            if (!is.nullOrUndefined(cleanupError)) {
+            if (cleanupError !== null && cleanupError !== undefined) {
               return reject(cleanupError)
             }
             return resolve(finish.result)
@@ -130,7 +130,7 @@ export async function cleanupPromise <T = unknown> (
             if ('error' in finish) {
               return reject(finish.error)
             }
-            if (!is.nullOrUndefined(cleanupError)) {
+            if (cleanupError !== null && cleanupError !== undefined) {
               return reject(cleanupError)
             }
             return resolve(finish.result)

src/composeAbort.ts

@@ -1,87 +1,26 @@
-import is from '@sindresorhus/is'
 import { AbortController, AbortSignal } from 'abort-controller'
-import ShimEventTarget from 'event-target-shim'
 import { AbortError } from './AbortError'
 
-const EventTarget = global.EventTarget ?? ShimEventTarget
-const Event: new (type: string) => any = global.Event ?? class {
-  type: string
-  constructor (type: string) {
-    this.type = type
-  }
-}
-
-export interface AbortControllerLike {
-  readonly signal: AbortSignal
-  abort: () => void
-}
-
-const { addEventListener, removeEventListener } = AbortSignal.prototype
-
-interface IComposedAbortSignal extends AbortSignal {
-  _parent: AbortSignal
-  _signal: AbortSignal
-  _handlers: Map<any, true> | undefined
-  _onAbort: () => void
-  _clear: () => void
-}
-
-function onAbort (this: IComposedAbortSignal): void {
-  this._clear()
-  this.dispatchEvent(new Event('abort'))
-}
-
-/**
- * AbortSignal's constructor throws an error
- */
-function ComposedAbortSignal (this: IComposedAbortSignal, signal: AbortSignal, parent: AbortSignal): void {
-  EventTarget.apply(this)
-  this._signal = signal
-  this._parent = parent
-}
-ComposedAbortSignal.prototype = Object.defineProperties(Object.create(AbortSignal.prototype), {
-  aborted: {
-    get (this: IComposedAbortSignal) {
-      return this._parent.aborted || this._signal.aborted
+class ComposedAbortController extends AbortController {
+  constructor (signal?: AbortSignal) {
+    super()
+    if (signal === null || signal === undefined) {
+      return
     }
-  },
-  _clear: {
-    value (this: IComposedAbortSignal): void {
-      this._handlers = undefined
-      if (this._onAbort !== undefined) {
-        this._signal.removeEventListener('abort', this._onAbort)
-        this._parent.removeEventListener('abort', this._onAbort)
-      }
+    if (signal.aborted) {
+      throw new AbortError()
     }
-  },
-  addEventListener: {
-    value (this: IComposedAbortSignal, ...[type, listener]: Parameters<typeof addEventListener>): void {
-      addEventListener.call(this, type, listener)
-      if (this.aborted || type !== 'abort' || is.nullOrUndefined(listener)) {
-        return
-      }
-      if (this._handlers === undefined) {
-        this._handlers = new Map()
-        this._onAbort = onAbort.bind(this)
-        this._signal.addEventListener('abort', this._onAbort)
-        this._parent.addEventListener('abort', this._onAbort)
-      }
-      this._handlers.set(listener, true)
+    const parentAborted = (): void => {
+      this.abort()
     }
-  },
-  removeEventListener: {
-    value (this: IComposedAbortSignal, ...[type, listener]: Parameters<typeof removeEventListener>): void {
-      removeEventListener.call(this, type, listener)
-      if (this._handlers === undefined || type !== 'abort' || is.nullOrUndefined(listener)) {
-        return
-      }
-      this._handlers.delete(listener)
-      if (this._handlers.size === 0) {
-        this._clear()
-      }
+    const clear = (): void => {
+      signal.removeEventListener('abort', parentAborted)
+      this.signal.removeEventListener('abort', clear)
     }
+    signal.addEventListener('abort', parentAborted)
+    this.signal.addEventListener('abort', clear)
   }
-})
+}
 
 /**
  * Creates a new AbortController-compatible instance
@@ -104,17 +43,6 @@ ComposedAbortSignal.prototype = Object.defineProperties(Object.create(AbortSigna
  *
  * @param signal Optional Signal that can abort the controller
  */
-export function composeAbort (signal?: AbortSignal): AbortControllerLike {
-  const controller = new AbortController()
-  if (is.nullOrUndefined(signal)) {
-    return controller
-  }
-  if (signal.aborted) {
-    throw new AbortError()
-  }
-  return {
-    // @ts-expect-error - ComposedAbortSignal is hacked together as AbortSignal is not easily extendable.
-    signal: new ComposedAbortSignal(controller.signal, signal),
-    abort: controller.abort.bind(controller)
-  }
+export function composeAbort (signal?: AbortSignal): AbortController {
+  return new ComposedAbortController(signal)
 }

src/raceWithSignal.ts

@@ -1,4 +1,3 @@
-import is from '@sindresorhus/is'
 import { AbortSignal } from 'abort-controller'
 import { AbortError } from './AbortError'
 import { composeAbort } from './composeAbort'
@@ -28,7 +27,7 @@ export async function raceWithSignal <TReturn = unknown> (command: (signal: Abor
   const controller = composeAbort(inputSignal)
   const { signal } = controller
   const promises = Array.from(command(signal))
-  if (!is.nullOrUndefined(inputSignal)) {
+  if (inputSignal !== null && inputSignal !== undefined) {
     promises.push(new Promise((resolve, reject) => {
       const abortHandler = (): void => {
         clear()

src/wrapTimeout.ts

@@ -1,6 +1,5 @@
 import { TimeoutOptions } from './options'
 import { AbortSignal } from 'abort-controller'
-import is from '@sindresorhus/is'
 import { bubbleAbort } from './bubbleAbort'
 import { raceWithSignal } from './raceWithSignal'
 
@@ -45,7 +44,7 @@ export type TimeoutCommand <T> = (signal: AbortSignal | undefined, resetTimeout:
  */
 export async function wrapTimeout <T> (command: TimeoutCommand<T>, opts: TimeoutOptions = {}): Promise<T> {
   const { timeout, signal: inputSignal } = opts
-  if (is.nullOrUndefined(timeout) || timeout === 0) {
+  if (timeout === null || timeout === undefined || timeout === 0) {
     bubbleAbort(inputSignal)
     return await command(inputSignal, noop)
   }