feat: Add AbortSignal.any(signals), signal.throwIfAborted() and AbortSignal.timeout(time)

Author: retyui

packages/react-native/Libraries/Core/setUpXHR.js

@@ -36,10 +36,13 @@ polyfillGlobal('URL', () => require('../Blob/URL').URL);
 polyfillGlobal('URLSearchParams', () => require('../Blob/URL').URLSearchParams);
 polyfillGlobal(
   'AbortController',
-  () => require('../../src/private/webapis/dom/abort-api/AbortController').AbortController, // flowlint-line untyped-import:off
+  () =>
+    require('../../src/private/webapis/dom/abort-api/AbortController')
+      .AbortController, // flowlint-line untyped-import:off
 );
 polyfillGlobal(
   'AbortSignal',
   () =>
-    require('../../src/private/webapis/dom/abort-api/AbortSignal').AbortSignal, // flowlint-line untyped-import:off
+    require('../../src/private/webapis/dom/abort-api/AbortSignal')
+      .AbortSignal_public, // flowlint-line untyped-import:off
 );

packages/react-native/src/private/webapis/dom/abort-api/AbortController.js

@@ -1,7 +1,34 @@
 /**
+ * Based on abort-controller by Toru Nagashima
+ * https://github.com/mysticatea/abort-controller
+ *
+ * Original work Copyright (c) 2017 Toru Nagashima
+ * Modified work Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
  * @flow strict
  * @format
  */
+
+// flowlint unsafe-getters-setters:off
+
 import {AbortSignal, abortSignal, createAbortSignal} from './AbortSignal';
 
 /**
@@ -19,29 +46,28 @@ export class AbortController {
   /**
    * Returns the `AbortSignal` object associated with this object.
    */
-  // $FlowExpectedError[unsafe-getters-setters]
   get signal(): AbortSignal {
     return getSignal(this);
   }
 
   /**
    * Abort and signal to any observers that the associated activity is to be aborted.
    */
-  abort(): void {
-    abortSignal(getSignal(this));
+  abort(reason: unknown): void {
+    abortSignal(reason, getSignal(this));
   }
 }
 
 /**
  * Associated signals.
  */
-const signals = new WeakMap<AbortController, AbortSignal>()
+const signals = new WeakMap<AbortController, AbortSignal>();
 
 /**
  * Get the associated signal of a given controller.
  */
 function getSignal(controller: AbortController): AbortSignal {
-  const signal = signals.get(controller)
+  const signal = signals.get(controller);
   if (signal == null) {
     throw new TypeError(
       `Expected 'this' to be an 'AbortController' object, but got ${
@@ -50,20 +76,18 @@ function getSignal(controller: AbortController): AbortSignal {
       }`,
     );
   }
-  return signal
+  return signal;
 }
 
 // Properties should be enumerable.
 //$FlowExpectedError[cannot-write]
 Object.defineProperties(AbortController.prototype, {
-  signal: { enumerable: true },
-  abort: { enumerable: true },
-})
+  signal: {enumerable: true},
+  abort: {enumerable: true},
+});
 
-if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
-  //$FlowExpectedError[cannot-write]
-  Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
-    configurable: true,
-    value: 'AbortController',
-  });
-}
+//$FlowExpectedError[cannot-write]
+Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
+  configurable: true,
+  value: 'AbortController',
+});

packages/react-native/src/private/webapis/dom/abort-api/AbortSignal.js

@@ -1,29 +1,139 @@
 /**
+ * Based on abort-controller by Toru Nagashima
+ * https://github.com/mysticatea/abort-controller
+ *
+ * Original work Copyright (c) 2017 Toru Nagashima
+ * Modified work Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
  * @flow strict
  * @format
  */
-import Event from '../events/Event';
-import EventTarget from '../events/EventTarget'
 
+// flowlint unsafe-getters-setters:off
+
+import type {EventCallback} from '../events/EventTarget';
+
+import DOMException from '../../errors/DOMException';
+import Event from '../events/Event';
+import {
+  getEventHandlerAttribute,
+  setEventHandlerAttribute,
+} from '../events/EventHandlerAttributes';
+import EventTarget from '../events/EventTarget';
+import {AbortController} from './AbortController';
 
+const reasons = new WeakMap<AbortSignal, unknown>();
 
 /**
  * The signal class.
  * @see https://dom.spec.whatwg.org/#abortsignal
  */
 export class AbortSignal extends EventTarget {
+  /**
+   *
+   * Returns an AbortSignal instance whose abort reason is set to reason if not undefined; otherwise to an "AbortError" DOMException.
+   *  Docs: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/abort_static
+   *  Spec: https://dom.spec.whatwg.org/#dom-abortsignal-abort
+   */
+  static abort(reason: unknown): AbortSignal {
+    const signal = createAbortSignal();
+    abortSignal(reason, signal);
+    return signal;
+  }
+
+  /**
+   *  AbortSignal.timeout static method
+   *   Docs: https:developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static
+   *   Spec: https://dom.spec.whatwg.org/#dom-abortsignal-timeout
+   */
+  static timeout(timeInMs: number): AbortSignal {
+    if (!(timeInMs >= 0)) {
+      throw new TypeError(
+        "Failed to execute 'timeout' on 'AbortSignal': The provided value has to be a non-negative number.",
+      );
+    }
+    const controller = new AbortController();
+    setTimeout(
+      () =>
+        controller.abort(new DOMException('signal timed out', 'TimeoutError')),
+      timeInMs,
+    );
+    return controller.signal;
+  }
+
+  /**
+   * 3. AbortSignal.any static method
+   *  Docs: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static
+   *  Spec: https://dom.spec.whatwg.org/#dom-abortsignal-any
+   */
+  static any(signals: AbortSignal[]): AbortSignal {
+    if (!Array.isArray(signals)) {
+      throw new TypeError('The signals value must be an instance of Array');
+    }
+
+    const controller = new AbortController();
+    const listeners = [];
+    const cleanup = () => listeners.forEach(unsubscribe => unsubscribe());
+
+    for (let i = 0; i < signals.length; i++) {
+      const signal = signals[i];
+
+      // Validate that each item is an AbortSignal
+      if (!(signal instanceof AbortSignal)) {
+        cleanup(); // Remove all listeners added so far
+        throw new Error(
+          'The "signals[' +
+            i +
+            ']" argument must be an instance of AbortSignal',
+        );
+      }
+
+      // Abort immediately if one of the signals is already aborted
+      if (signal.aborted) {
+        cleanup(); // Remove all listeners added so far
+        controller.abort(signal.reason);
+        break;
+      }
+
+      const onAbort = () => {
+        controller.abort(signal.reason);
+        cleanup();
+      };
+      signal.addEventListener('abort', onAbort);
+      listeners.push(() => signal.removeEventListener('abort', onAbort));
+    }
+    return controller.signal;
+  }
+
   /**
    * AbortSignal cannot be constructed directly.
    */
   constructor() {
     super();
-    throw new TypeError('AbortSignal cannot be constructed directly');
+    abortedFlags.set(this, false);
   }
 
   /**
    * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
    */
-  // $FlowExpectedError[unsafe-getters-setters]
   get aborted(): boolean {
     const aborted = abortedFlags.get(this);
     if (typeof aborted !== 'boolean') {
@@ -36,79 +146,91 @@ export class AbortSignal extends EventTarget {
     }
     return aborted;
   }
-}
 
-const listeners = new WeakMap<AbortSignal, (()=> void)>();
-Object.defineProperty(AbortSignal.prototype, `onabort`, {
-  enumerable: true,
-  configurable: true,
-  get() {
-    // $FlowExpectedError[object-this-reference]
-    return listeners.get(this) || null;
-  },
-  // $FlowExpectedError[missing-local-annot]
-  set(value) {
-    // $FlowExpectedError[object-this-reference]
-    const currentListener = listeners.get(this);
-    if (currentListener === value) return; // same handler? do nothing!
-    if (currentListener) {
-      // Before setting a new listener, remove the old one if exists
-      // $FlowExpectedError[object-this-reference]
-      this.removeEventListener('abort', currentListener);
-    }
-    if (typeof value === 'function') {
-      // $FlowExpectedError[object-this-reference]
-      listeners.set(this, value);
-      // $FlowExpectedError[object-this-reference]
-      this.addEventListener('abort', value);
-    } else {
-      // $FlowExpectedError[object-this-reference]
-      listeners.delete(this);
-    }
-  },
-});
+  get reason(): unknown {
+    return reasons.get(this);
+  }
+
+  get onabort(): EventCallback | null {
+    return getEventHandlerAttribute(this, 'abort');
+  }
 
+  set onabort(listener: ?EventCallback): void {
+    setEventHandlerAttribute(this, 'abort', listener);
+  }
+
+  throwIfAborted(): void {
+    if (this.aborted) {
+      throw this.reason;
+    }
+  }
+}
 
 /**
  * Create an AbortSignal object.
  */
 export function createAbortSignal(): AbortSignal {
-  const signal = Object.create(AbortSignal.prototype);
-  // $FlowExpectedError[incompatible-type]
-  EventTarget.call(signal);
-  abortedFlags.set(signal, false);
-  return signal;
+  return new AbortSignal();
 }
 
 /**
  * Abort a given signal.
  */
-export function abortSignal(signal: AbortSignal): void {
+export function abortSignal(
+  reason: unknown | void = new DOMException(
+    'signal is aborted without reason',
+    'AbortError',
+  ),
+  signal: AbortSignal,
+): void {
   if (abortedFlags.get(signal) !== false) {
     return;
   }
 
   abortedFlags.set(signal, true);
-  // $FlowExpectedError[incompatible-type]
+  reasons.set(signal, reason);
   signal.dispatchEvent(new Event('abort'));
 }
 
 /**
  * Aborted flag for each instances.
  */
-const abortedFlags = new WeakMap<AbortSignal, boolean>()
+const abortedFlags = new WeakMap<AbortSignal, boolean>();
 
 // Properties should be enumerable.
 //$FlowExpectedError[cannot-write]
 Object.defineProperties(AbortSignal.prototype, {
   aborted: {enumerable: true},
+  reason: {enumerable: true},
+  onabort: {enumerable: true},
+  throwIfAborted: {enumerable: true},
 });
 
-
 // `toString()` should return `"[object AbortSignal]"`
-if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
-  Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
-    configurable: true,
-    value: "AbortSignal",
-  })
-}
+Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+  configurable: true,
+  value: 'AbortSignal',
+});
+
+export const AbortSignal_public: typeof AbortSignal =
+  /* eslint-disable no-shadow */
+  // $FlowExpectedError[incompatible-type]
+  function AbortSignal() {
+    throw new TypeError(
+      "Failed to construct 'AbortSignal': Illegal constructor",
+    );
+  };
+
+// $FlowExpectedError[prop-missing]
+AbortSignal_public.prototype = AbortSignal.prototype;
+// Copy static properties so that callers accessing them via the public constructor (e.g. `AbortSignal.timeout(0)`) still work.
+// $FlowFixMe[unsafe-object-assign]
+// $FlowFixMe[not-an-object]
+['timeout', 'abort', 'any'].forEach(methodName => {
+  Object.defineProperty(
+    AbortSignal_public,
+    methodName,
+    // $FlowExpectedError[incompatible-type]
+    Object.getOwnPropertyDescriptor(AbortSignal, methodName),
+  );
+});