fix: Accept all HasEventHandling types when creating event Promise (#2550)

- Shouldn't have limited this function to just table types

Author: mofojed

packages/jsapi-utils/src/TableUtils.test.ts

@@ -2815,6 +2815,63 @@ describe('makeCancelableTableEventPromise', () => {
   });
 });
 
+describe('makeCancelableEventPromise', () => {
+  const DEFAULT_EVENT = 'DEFAULT_EVENT';
+  const DEFAULT_EMITTER = {
+    removeEventListener: jest.fn(),
+    addEventListener: jest.fn(() => DEFAULT_EMITTER.removeEventListener),
+  };
+  function makeCancelableEventPromise(
+    table = DEFAULT_EMITTER,
+    event = DEFAULT_EVENT,
+    timeout = 0,
+    matcher = undefined
+  ) {
+    const promise = TableUtils.makeCancelableEventPromise(table, event, {
+      timeout,
+      matcher,
+    });
+    promise.catch(() => null);
+    return promise;
+  }
+  beforeAll(() => {
+    jest.useFakeTimers();
+  });
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+  afterEach(() => {
+    jest.clearAllTimers();
+    DEFAULT_EMITTER.removeEventListener.mockClear();
+  });
+
+  it('Subscribes to a given event, returns a cancelable promise', () => {
+    const cancelablePromise = makeCancelableEventPromise();
+    expect(DEFAULT_EMITTER.addEventListener).toHaveBeenCalled();
+    expect(cancelablePromise).toBeInstanceOf(Promise);
+    expect(cancelablePromise).toHaveProperty('cancel');
+  });
+  it('Multiple cancel calls clean up subscription only once', () => {
+    const cancelablePromise = makeCancelableEventPromise();
+    cancelablePromise.cancel();
+    cancelablePromise.cancel();
+    expect(DEFAULT_EMITTER.removeEventListener).toHaveBeenCalledTimes(1);
+  });
+  it('Timeout rejects promise and cleans up subscription', () => {
+    const cancelablePromise = makeCancelableEventPromise();
+    jest.runOnlyPendingTimers();
+    expect.assertions(2);
+    expect(DEFAULT_EMITTER.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(cancelablePromise).rejects.not.toBeNull();
+  });
+  it('Cancel after timeout cleans up subscription only once', () => {
+    const cancelablePromise = makeCancelableEventPromise();
+    jest.runOnlyPendingTimers();
+    cancelablePromise.cancel();
+    expect(DEFAULT_EMITTER.removeEventListener).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe('converts filter type to appropriate string value for quick filters', () => {
   function testFilterType(filterType: FilterTypeValue, expectedResult: string) {
     expect(TableUtils.getFilterOperatorString(filterType)).toBe(expectedResult);

packages/jsapi-utils/src/TableUtils.ts

@@ -622,6 +622,7 @@ export class TableUtils {
    * @param eventName Event to listen for
    * @param timeout Event timeout in milliseconds, defaults to 0
    * @param matcher Optional function to determine if the promise can be resolved or stays pending
+   * @deprecated Use `makeCancelableEventPromise` instead.
    * @returns Resolves with the event data
    */
   static makeCancelableTableEventPromise<TEventDetails = unknown>(
@@ -630,6 +631,30 @@ export class TableUtils {
     timeout = 0,
     matcher: ((event: DhType.Event<TEventDetails>) => boolean) | null = null
   ): CancelablePromise<DhType.Event<TEventDetails>> {
+    return TableUtils.makeCancelableEventPromise(table, eventName, {
+      timeout,
+      matcher: matcher ?? undefined,
+    });
+  }
+
+  /**
+   * Make a cancelable promise for a one-shot event with a timeout.
+   * @param emitter The object emitting the event
+   * @param eventName Event to listen for
+   * @param options Optional options for listening
+   * @param options.timeout Event timeout in milliseconds, defaults to 0
+   * @param options.matcher Optional function to determine if the promise can be resolved or stays pending
+   * @returns Resolves with the event data
+   */
+  static makeCancelableEventPromise<TEventDetails = unknown>(
+    emitter: DhType.HasEventHandling,
+    eventName: string,
+    options: {
+      timeout?: number;
+      matcher?: (event: DhType.Event<TEventDetails>) => boolean;
+    } = {}
+  ): CancelablePromise<DhType.Event<TEventDetails>> {
+    const { timeout = 0, matcher } = options;
     let eventCleanup: () => void;
     let timeoutId: ReturnType<typeof setTimeout>;
     let isPending = true;
@@ -639,17 +664,20 @@ export class TableUtils {
         isPending = false;
         reject(new TimeoutError(`Event "${eventName}" timed out.`));
       }, timeout);
-      eventCleanup = table.addEventListener<TEventDetails>(eventName, event => {
-        if (matcher != null && !matcher(event)) {
-          log.debug2('Event triggered, but matcher returned false.');
-          return;
+      eventCleanup = emitter.addEventListener<TEventDetails>(
+        eventName,
+        event => {
+          if (matcher != null && !matcher(event)) {
+            log.debug2('Event triggered, but matcher returned false.');
+            return;
+          }
+          log.debug2('Event triggered, resolving.');
+          eventCleanup();
+          clearTimeout(timeoutId);
+          isPending = false;
+          resolve(event);
         }
-        log.debug2('Event triggered, resolving.');
-        eventCleanup();
-        clearTimeout(timeoutId);
-        isPending = false;
-        resolve(event);
-      });
+      );
     }) as CancelablePromise<DhType.Event<TEventDetails>>;
     wrappedPromise.cancel = () => {
       if (isPending) {