Merge types_web back into TypeScript DOM lib generator

baselines/audioworklet.generated.d.ts

@@ -110,8 +110,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;
@@ -235,6 +233,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 {
     /**
@@ -252,15 +258,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: {
@@ -324,9 +330,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: {
@@ -649,6 +655,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;

inputfiles/addedTypes.json

@@ -577,6 +577,49 @@
                     }
                 }
             },
+            // This is used in many DT libraries, via ckeditor
+            "ClientRect": {
+                "name": "ClientRect",
+                "exposed": "Window",
+                "deprecated": true,
+                "extends": "DOMRect",
+                "noInterfaceObject": true
+            },
+            /*
+              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": {
@@ -601,6 +644,32 @@
                     }
                 }
             },
+            // This is used in the React d.ts files, and not including 
+            // it would force an update for anyone using React.
+            "StyleMedia": {
+                "name": "StyleMedia",
+                "exposed": "Window",
+                "noInterfaceObject": true,
+                "deprecated": true,
+                "properties": {
+                    "property": {
+                        "type": {
+                            "name": "type",
+                            "type": "DOMString"
+                        }
+                    }
+                },
+                "methods": {
+                    "method": {
+                        "matchMedium": {
+                            "name": "matchMedium",
+                            "overrideSignatures": [
+                                "matchMedium(mediaquery: string): boolean"
+                            ]
+                        }
+                    }
+                }
+            },
             "Navigator": {
                 "name": "Navigator",
                 "properties": {
@@ -1186,6 +1255,10 @@
                     }
                 ],
                 "overrideType": "ReadableStreamDefaultReader<T>"
+            },
+            {
+                "name": "EventListenerOrEventListenerObject",
+                "overrideType": "EventListener | EventListenerObject"
             }
         ]
     }

inputfiles/knownTypes.json

@@ -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",
@@ -43,13 +51,6 @@
         "RTCStatsType",
         "RTCIceRole",
         "RTCTransportStats",
-        "RsaHashedImportParams",
-        "RsaHashedKeyAlgorithm",
-        "RsaHashedKeyGenParams",
-        "RsaKeyAlgorithm",
-        "RsaKeyGenParams",
-        "RsaOaepParams",
-        "RsaPssParams",
         "Transferable",
         "VideoFacingModeEnum"
     ],
@@ -67,6 +68,7 @@
         "EcdsaParams",
         "EcKeyGenParams",
         "EcKeyImportParams",
+        "EventListenerOrEventListenerObject",
         "HashAlgorithmIdentifier",
         "HkdfParams",
         "HmacImportParams",
@@ -78,11 +80,12 @@
         "RsaHashedImportParams",
         "RsaHashedKeyGenParams",
         "RsaKeyGenParams",
-        "RsaPssParams",
         "RsaOaepParams",
+        "RsaPssParams",
         "Transferable"
     ],
     "Worklet": [
+        "EventListenerOrEventListenerObject",
         "Transferable"
     ]
 }

inputfiles/overridingTypes.json

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