Bring back the EventListenerOrEventListenerObject and EventListener as an extendable interface (#110)

* Bring back the EventListenerOrEventListenerObject and EventListener as an extendable interface

* Merge main

* Use th existing build infra to add the eventlistener

* Docs

* Eslint fix

* No circular reference

* Remove call signature code

* Final removal

* Remove the hack for EventListenerOrEventListenerObject

* Update src/build.ts

Co-authored-by: Kagami Sascha Rosylight <[email protected]>

* User override types for EventTarget

* Update src/build/emitter.ts

Co-authored-by: Kagami Sascha Rosylight <[email protected]>

Author: orta

README.md

@@ -67,3 +67,17 @@ Not yet. A small part of things still needs manual modification, which is done b
     ```sh
     npm test
     ```
+
+* For larger changes, create a split terminal with:
+
+  ```sh
+  npx tsc --watch
+  ```
+
+  Running in the background updating your TypeScript files. Then run:
+
+  ```sh
+  node ./lib/build.js && node ./lib/test.js
+  ```
+
+  To trigger the build and tests.

baselines/audioworklet.generated.d.ts

@@ -109,8 +109,6 @@ interface UnderlyingSource<R = any> {
     type?: undefined;
 }
 
-type EventListener = ((event: Event) => void) | { handleEvent(event: Event): void; };
-
 interface AudioWorkletGlobalScope extends WorkletGlobalScope {
     readonly currentFrame: number;
     readonly currentTime: number;
@@ -234,6 +232,14 @@ declare var Event: {
     readonly NONE: number;
 };
 
+interface EventListener {
+    (evt: Event): void;
+}
+
+interface EventListenerObject {
+    handleEvent(object: Event): void;
+}
+
 /** EventTarget is a DOM interface implemented by objects that can receive events and may have listeners for them. */
 interface EventTarget {
     /**
@@ -251,15 +257,15 @@ interface EventTarget {
      *
      * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
      */
-    addEventListener(type: string, callback: EventListener | null, options?: AddEventListenerOptions | boolean): void;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
     /**
      * Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
      */
     dispatchEvent(event: Event): boolean;
     /**
      * Removes the event listener in target's event listener list with the same type, callback, and options.
      */
-    removeEventListener(type: string, callback: EventListener | null, options?: EventListenerOptions | boolean): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
 }
 
 declare var EventTarget: {
@@ -323,9 +329,9 @@ interface MessagePort extends EventTarget {
      */
     start(): void;
     addEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, listener: EventListener, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListener, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
 }
 
 declare var MessagePort: {
@@ -648,6 +654,7 @@ declare var sampleRate: number;
 declare function registerProcessor(name: string, processorCtor: AudioWorkletProcessorConstructor): void;
 type BufferSource = ArrayBufferView | ArrayBuffer;
 type DOMHighResTimeStamp = number;
+type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 type MessageEventSource = MessagePort;
 type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
 type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;

baselines/dom.generated.d.ts

@@ -557,6 +557,41 @@
                     }
                 }
             },
+            /*
+              Keeping EventListener and EventListenerObject isn't the most elegant way to handle
+              the event listeners, but we need to keep the EventListener as an extendable interface
+              for libraries like angular.
+            */
+            "EventListener": {
+                "name": "EventListener",
+                "noInterfaceObject": true,
+                "methods": {
+                    "method": {
+                        // This is a hack to add a call signature, but I think it's reasonable
+                        // as it means we don't have to add a call signatures section to the
+                        // emitter for this one case.
+                        "callable": {
+                            "overrideSignatures": [
+                                "(evt: Event): void"
+                            ]
+                        }
+                    }
+                },
+
+            },
+            "EventListenerObject": {
+                "name": "EventListenerObject",
+                "noInterfaceObject": true,
+                "methods": {
+                    "method": {
+                        "handleEvent": {
+                            "overrideSignatures": [
+                                "handleEvent(object: Event): void"
+                            ]
+                        }
+                    }
+                },
+            },
             "Document": {
                 "methods": {
                     "method": {
@@ -1154,6 +1189,10 @@
                     }
                 ],
                 "overrideType": "ReadableStreamDefaultReader<T>"
+            },
+            {
+                "name": "EventListenerOrEventListenerObject",
+                "overrideType": "EventListener | EventListenerObject"
             }
         ]
     }

baselines/serviceworker.generated.d.ts

@@ -13,11 +13,12 @@
         "ComputedKeyframe",
         "CryptoKeyPair",
         "DisplayCaptureSurfaceType",
+        "EcdhKeyDeriveParams",
+        "EcdsaParams",
         "EcKeyAlgorithm",
         "EcKeyGenParams",
         "EcKeyImportParams",
-        "EcdhKeyDeriveParams",
-        "EcdsaParams",
+        "EventListenerOrEventListenerObject",
         "HashAlgorithmIdentifier",
         "HkdfParams",
         "HmacImportParams",
@@ -30,6 +31,13 @@
         "NamedCurve",
         "Pbkdf2Params",
         "PropertyIndexedKeyframes",
+        "RsaHashedImportParams",
+        "RsaHashedKeyAlgorithm",
+        "RsaHashedKeyGenParams",
+        "RsaKeyAlgorithm",
+        "RsaKeyGenParams",
+        "RsaOaepParams",
+        "RsaPssParams",
         "RTCCertificateExpiration",
         "RTCIceCandidatePairStats",
         "RTCInboundRtpStreamStats",
@@ -41,13 +49,6 @@
         "RTCStatsIceCandidatePairState",
         "RTCStatsType",
         "RTCTransportStats",
-        "RsaHashedImportParams",
-        "RsaHashedKeyAlgorithm",
-        "RsaHashedKeyGenParams",
-        "RsaKeyAlgorithm",
-        "RsaKeyGenParams",
-        "RsaOaepParams",
-        "RsaPssParams",
         "Transferable",
         "VideoFacingModeEnum"
     ],
@@ -66,6 +67,7 @@
         "EcdsaParams",
         "EcKeyGenParams",
         "EcKeyImportParams",
+        "EventListenerOrEventListenerObject",
         "HashAlgorithmIdentifier",
         "HkdfParams",
         "HmacImportParams",
@@ -77,11 +79,12 @@
         "RsaHashedImportParams",
         "RsaHashedKeyGenParams",
         "RsaKeyGenParams",
-        "RsaPssParams",
         "RsaOaepParams",
+        "RsaPssParams",
         "Transferable"
     ],
     "Worklet": [
+        "EventListenerOrEventListenerObject",
         "Transferable"
     ]
 }

baselines/sharedworker.generated.d.ts

@@ -2659,6 +2659,36 @@
                     }
                 }
             },
+            "EventTarget": {
+                "methods": {
+                    "method": {
+                        "addEventListener": {
+                            "signature": {
+                                "0": {
+                                    "param": [
+                                        {
+                                            "name": "callback",
+                                            "overrideType": "EventListenerOrEventListenerObject"
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                        "removeEventListener": {
+                            "signature": {
+                                "0": {
+                                    "param": [
+                                        {
+                                            "name": "callback",
+                                            "overrideType": "EventListenerOrEventListenerObject"
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                }
+            },
             "WorkerGlobalScope": {
                 "properties": {
                     "property": {