Merge branch 'ClipboardEventInit' of github.com:Brcrwilliams/TSJS-lib-generator into Brcrwilliams-ClipboardEventInit

Author: sandersn

baselines/dom.generated.d.ts

@@ -183,6 +183,10 @@ interface ClientQueryOptions {
     type?: ClientTypes;
 }
 
+interface ClipboardEventInit extends EventInit {
+    clipboardData?: DataTransfer | null;
+}
+
 interface CloseEventInit extends EventInit {
     code?: number;
     reason?: string;
@@ -3260,20 +3264,26 @@ declare var ClientRectList: {
     new(): ClientRectList;
 };
 
+interface Clipboard extends EventTarget {
+    readText(): Promise<string>;
+    writeText(data: string): Promise<void>;
+}
+
+declare var Clipboard: {
+    prototype: Clipboard;
+    new(): Clipboard;
+};
+
 /** The ClipboardEvent interface represents events providing information related to modification of the clipboard, that is cut, copy, and paste events. */
 interface ClipboardEvent extends Event {
-    readonly clipboardData: DataTransfer;
+    readonly clipboardData: DataTransfer | null;
 }
 
 declare var ClipboardEvent: {
     prototype: ClipboardEvent;
     new(type: string, eventInitDict?: ClipboardEventInit): ClipboardEvent;
 };
 
-interface ClipboardEventInit extends EventInit {
-    data?: string;
-    dataType?: string;
-}
 
 /** A CloseEvent is sent to clients using WebSockets when the connection is closed. This is delivered to the listener indicated by the WebSocket object's onclose attribute. */
 interface CloseEvent extends Event {
@@ -10494,6 +10504,7 @@ declare var NavigationPreloadManager: {
 interface Navigator extends NavigatorID, NavigatorOnLine, NavigatorContentUtils, NavigatorStorageUtils, MSNavigatorDoNotTrack, MSFileSaver, NavigatorBeacon, NavigatorConcurrentHardware, NavigatorUserMedia, NavigatorLanguage, NavigatorStorage, NavigatorAutomationInformation {
     readonly activeVRDisplays: ReadonlyArray<VRDisplay>;
     readonly authentication: WebAuthentication;
+    readonly clipboard: Clipboard;
     readonly cookieEnabled: boolean;
     readonly doNotTrack: string | null;
     gamepadInputEmulation: GamepadInputEmulationType;

inputfiles/addedTypes.json

@@ -832,26 +832,6 @@
                     }
                 }
             },
-            "ClipboardEventInit": {
-                "exposed": "Window",
-                "name": "ClipboardEventInit",
-                "extends": "EventInit",
-                "properties": {
-                    "property": {
-                        "data": {
-                            "name": "data",
-                            "override-type": "string",
-                            "required": 0
-                        },
-                        "dataType": {
-                            "name": "dataType",
-                            "override-type": "string",
-                            "required": 0
-                        }
-                    }
-                },
-                "no-interface-object": "1"
-            },
             "IDBArrayKey": {
                 "name": "IDBArrayKey",
                 "extends": "Array<IDBValidKey>",

inputfiles/idl/Clipboard.widl

@@ -0,0 +1,23 @@
+dictionary ClipboardEventInit : EventInit {
+  DataTransfer? clipboardData = null;
+};
+
+[Constructor(DOMString type, optional ClipboardEventInit eventInitDict), Exposed=Window]
+interface ClipboardEvent : Event {
+  readonly attribute DataTransfer? clipboardData;
+};
+
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute Clipboard clipboard;
+};
+
+[SecureContext, Exposed=Window] interface Clipboard : EventTarget {
+  Promise<DataTransfer> read();
+  Promise<DOMString> readText();
+  Promise<void> write(DataTransfer data);
+  Promise<void> writeText(DOMString data);
+};
+
+dictionary ClipboardPermissionDescriptor : PermissionDescriptor {
+  boolean allowWithoutGesture = false;
+};

inputfiles/idl/DOM.commentmap.json

@@ -79,7 +79,7 @@
     "document-createcdatasection": "Returns a CDATASection node whose data is data.",
     "document-createcomment": "Returns a Comment node whose data is data.",
     "document-createprocessinginstruction": "Returns a ProcessingInstruction node whose target is target and data is data.\nIf target does not match the Name production an\n\"InvalidCharacterError\" DOMException will be thrown.\nIf data contains \"?>\" an\n\"InvalidCharacterError\" DOMException will be thrown.",
-    "document-importnode": "",
+    "document-importnode": "Returns a copy of node. If deep is true, the copy also includes the node's descendants.\nIf node is a document or a shadow root, throws a\n\"NotSupportedError\" DOMException.",
     "document-adoptnode": "Moves node from another document and returns it.\nIf node is a document, throws a \"NotSupportedError\" DOMException or, if node is a shadow root, throws a\n\"HierarchyRequestError\" DOMException.",
     "documentfragment-documentfragment": "Returns a new DocumentFragment node.",
     "element-namespaceuri": "Returns the namespace.",

inputfiles/idl/Encoding.commentmap.json

@@ -1,10 +1,14 @@
 {
     "textdecoder": "Returns a new TextDecoder object.\nIf label is either not a label or is a label for replacement, throws a RangeError.",
     "textdecoder-encoding": "Returns encoding's name, lowercased.",
-    "textdecoder-fatal": "Returns true if error mode is \"fatal\", and false\notherwise.",
-    "textdecoder-ignorebom": "Returns true if ignore BOM flag is set, and false otherwise.",
-    "textdecoder-decode": "Returns the result of running encoding's decoder. The\nmethod can be invoked zero or more times with options's stream set to\ntrue, and then once without options's stream (or set to false), to process\na fragmented stream. If the invocation without options's stream (or set to\nfalse) has no input, it's clearest to omit both arguments.\nvar string = \"\", decoder = new TextDecoder(encoding), buffer;\nwhile(buffer = next_chunk()) {\nstring += decoder.decode(buffer, {stream:true});\n}\nstring += decoder.decode(); // end-of-stream\nIf the error mode is \"fatal\" and encoding's decoder returns error, throws a TypeError.",
+    "textdecoder-fatal": "Returns true if error mode is \"fatal\", and\nfalse otherwise.",
+    "textdecoder-ignorebom": "Returns true if ignore BOM flag is set, and false\notherwise.",
+    "textdecoder-decode": "Returns the result of running encoding's decoder.\nThe method can be invoked zero or more times with options's stream set to\ntrue, and then once without options's stream (or set to false), to process\na fragmented stream. If the invocation without options's stream (or set to\nfalse) has no input, it's clearest to omit both arguments.\nvar string = \"\", decoder = new TextDecoder(encoding), buffer;\nwhile(buffer = next_chunk()) {\nstring += decoder.decode(buffer, {stream:true});\n}\nstring += decoder.decode(); // end-of-stream\nIf the error mode is \"fatal\" and encoding's decoder returns error, throws a TypeError.",
     "textencoder": "Returns a new TextEncoder object.",
     "textencoder-encoding": "Returns \"utf-8\".",
-    "textencoder-encode": "Returns the result of running UTF-8's encoder."
+    "textencoder-encode": "Returns the result of running UTF-8's encoder.",
+    "textencoder-encodeinto": "Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as a dictionary whereby read is the number of converted code units of source and written is the number of bytes modified in destination.",
+    "textdecoderstream": "Returns a new TextDecoderStream object.\nIf label is either not a label or is a label for replacement, throws a RangeError.",
+    "generictransformstream-writable": "Returns a writable stream which accepts string chunks and runs them through UTF-8's encoder before making them available to readable.\nTypically this will be used via the pipeThrough() method on a ReadableStream source.\ntextReadable\n.pipeThrough(new TextEncoderStream())\n.pipeTo(byteWritable);",
+    "textencoderstream": "Returns a new TextEncoderStream object."
 }

inputfiles/idl/Encoding.widl

@@ -1,3 +1,9 @@
+interface mixin TextDecoderCommon {
+  readonly attribute DOMString encoding;
+  readonly attribute boolean fatal;
+  readonly attribute boolean ignoreBOM;
+};
+
 dictionary TextDecoderOptions {
   boolean fatal = false;
   boolean ignoreBOM = false;
@@ -10,15 +16,42 @@ dictionary TextDecodeOptions {
 [Constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options),
  Exposed=(Window,Worker)]
 interface TextDecoder {
-  readonly attribute DOMString encoding;
-  readonly attribute boolean fatal;
-  readonly attribute boolean ignoreBOM;
   USVString decode(optional BufferSource input, optional TextDecodeOptions options);
 };
+TextDecoder includes TextDecoderCommon;
+
+interface mixin TextEncoderCommon {
+  readonly attribute DOMString encoding;
+};
+
+dictionary TextEncoderEncodeIntoResult {
+  unsigned long long read;
+  unsigned long long written;
+};
 
 [Constructor,
  Exposed=(Window,Worker)]
 interface TextEncoder {
-  readonly attribute DOMString encoding;
   [NewObject] Uint8Array encode(optional USVString input = "");
+  TextEncoderEncodeIntoResult encodeInto(USVString source, Uint8Array destination);
+};
+TextEncoder includes TextEncoderCommon;
+
+interface mixin GenericTransformStream {
+  readonly attribute ReadableStream readable;
+  readonly attribute WritableStream writable;
+};
+
+[Constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options),
+ Exposed=(Window,Worker)]
+interface TextDecoderStream {
+};
+TextDecoderStream includes TextDecoderCommon;
+TextDecoderStream includes GenericTransformStream;
+
+[Constructor,
+ Exposed=(Window,Worker)]
+interface TextEncoderStream {
 };
+TextEncoderStream includes TextEncoderCommon;
+TextEncoderStream includes GenericTransformStream;

inputfiles/idl/Fetch.widl

@@ -92,7 +92,7 @@ Response includes Body;
 
 dictionary ResponseInit {
   unsigned short status = 200;
-  ByteString statusText = "OK";
+  ByteString statusText = "";
   HeadersInit headers;
 };
 

inputfiles/idl/Fullscreen.commentmap.json

@@ -1,5 +1,5 @@
 {
-    "element-requestfullscreen": "Displays element fullscreen and resolves promise when done.",
+    "element-requestfullscreen": "Displays element fullscreen and resolves promise when done.\nWhen supplied, options's navigationUI member indicates whether showing\nnavigation UI while in fullscreen is preferred or not. If set to \"show\", navigation\nsimplicity is preferred over screen space, and if set to \"hide\", more screen space\nis preferred. User agents are always free to honor user preference over the application's. The\ndefault value \"auto\" indicates no application preference.",
     "document-fullscreenenabled": "Returns true if document has the ability to display elements fullscreen\nand fullscreen is supported, or false otherwise.",
     "document-exitfullscreen": "Stops document's fullscreen element from being displayed fullscreen and\nresolves promise when done.",
     "document-fullscreenelement": "Returns shadowroot's fullscreen element."

inputfiles/idl/Fullscreen.widl

@@ -1,5 +1,15 @@
+enum FullscreenNavigationUI {
+  "auto",
+  "show",
+  "hide"
+};
+
+dictionary FullscreenOptions {
+  FullscreenNavigationUI navigationUI = "auto";
+};
+
 partial interface Element {
-  Promise<void> requestFullscreen();
+  Promise<void> requestFullscreen(optional FullscreenOptions options);
 
   attribute EventHandler onfullscreenchange;
   attribute EventHandler onfullscreenerror;
@@ -15,6 +25,6 @@ partial interface Document {
   attribute EventHandler onfullscreenerror;
 };
 
-partial interface DocumentOrShadowRoot {
+partial interface mixin DocumentOrShadowRoot {
   [LenientSetter] readonly attribute Element? fullscreenElement;
 };

inputfiles/idl/Geometry Interfaces.widl

@@ -151,6 +151,8 @@ interface DOMMatrixReadOnly {
                                 optional unrestricted double originX = 0,
                                 optional unrestricted double originY = 0,
                                 optional unrestricted double originZ = 0);
+    [NewObject] DOMMatrix scaleNonUniform(optional unrestricted double scaleX = 1,
+                                          optional unrestricted double scaleY = 1);
     [NewObject] DOMMatrix scale3d(optional unrestricted double scale = 1,
                                   optional unrestricted double originX = 0,
                                   optional unrestricted double originY = 0,

inputfiles/idl/HTML - Canvas.commentmap.json

@@ -14,7 +14,7 @@
     "imagebitmaprenderingcontext-canvas": "Returns the canvas element that the context is bound to.",
     "imagebitmaprenderingcontext-transferfromimagebitmap": "Replaces contents of the canvas element to which context\nis bound with a transparent black bitmap whose size corresponds to the width and height\ncontent attributes of the canvas element.",
     "offscreencanvas": "",
-    "offscreencanvas-getcontext": "Returns an object that exposes an API for drawing on the OffscreenCanvas\nobject. contextId specifies the desired API: \"2d\" or \"webgl\". options is handled by that\nAPI.\nThis specification defines the \"2d\" context below,\nwhich is similar but distinct from the \"2d\"\ncontext that is created from a canvas element. There is also a specification that\ndefines a \"webgl\" context. [WEBGL]\nReturns null if the canvas has already been initialized with another context type (e.g.,\ntrying to get a \"2d\" context after getting a\n\"webgl\" context).",
+    "offscreencanvas-getcontext": "Returns an object that exposes an API for drawing on the OffscreenCanvas\nobject. contextId specifies the desired API: \"2d\", \"webgl\", or \"webgl2\". options is handled by that\nAPI.\nThis specification defines the \"2d\" context below,\nwhich is similar but distinct from the \"2d\"\ncontext that is created from a canvas element. The WebGL specifications define the\n\"webgl\" and \"webgl2\" contexts. [WEBGL]\nReturns null if the canvas has already been initialized with another context type (e.g.,\ntrying to get a \"2d\" context after getting a\n\"webgl\" context).",
     "offscreencanvas-height": "These attributes return the dimensions of the OffscreenCanvas object's bitmap.\nThey can be set, to replace the bitmap with a\nnew, transparent black bitmap of the specified dimensions (effectively resizing\nit).",
     "offscreencanvas-converttoblob": "Returns a promise that will fulfill with a new Blob object representing a file\ncontaining the image in the OffscreenCanvas object.\nThe argument, if provided, is a dictionary that controls the encoding options of the image\nfile to be created. The type\nfield specifies the file format and has a default value of \"image/png\"; that type\nis also used if the requested type isn't supported. If the image format supports variable\nquality (such as \"image/jpeg\"), then the quality field is a number in the range 0.0\nto 1.0 inclusive indicating the desired quality level for the resulting image.",
     "offscreencanvas-transfertoimagebitmap": "Returns a newly created ImageBitmap object with the image in the\nOffscreenCanvas object. The image in the OffscreenCanvas object is\nreplaced with a new blank image."

inputfiles/idl/HTML - Canvas.widl

@@ -1,4 +1,4 @@
-typedef (CanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext) RenderingContext;
+typedef (CanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext) RenderingContext;
 
 [Exposed=Window,
  HTMLConstructor]
@@ -36,6 +36,8 @@ enum ImageSmoothingQuality { "low", "medium", "high" };
 interface CanvasRenderingContext2D {
   // back-reference to the canvas
   readonly attribute HTMLCanvasElement canvas;
+
+  CanvasRenderingContext2DSettings getContextAttributes();
 };
 CanvasRenderingContext2D includes CanvasState;
 CanvasRenderingContext2D includes CanvasTransform;
@@ -260,20 +262,19 @@ dictionary ImageBitmapRenderingContextSettings {
   boolean alpha = true;
 };
 
-typedef (OffscreenCanvasRenderingContext2D or
-        WebGLRenderingContext) OffscreenRenderingContext;
+typedef (OffscreenCanvasRenderingContext2D or WebGLRenderingContext or WebGL2RenderingContext) OffscreenRenderingContext;
 
 dictionary ImageEncodeOptions {
   DOMString type = "image/png";
   unrestricted double quality = 1.0;
 };
 
-enum OffscreenRenderingContextId { "2d", "webgl" };
+enum OffscreenRenderingContextId { "2d", "webgl", "webgl2" };
 
 [Constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height), Exposed=(Window,Worker), Transferable]
 interface OffscreenCanvas : EventTarget {
-  attribute unsigned long long width;
-  attribute unsigned long long height;
+  attribute [EnforceRange] unsigned long long width;
+  attribute [EnforceRange] unsigned long long height;
 
   OffscreenRenderingContext? getContext(OffscreenRenderingContextId contextId, optional any options = null);
   ImageBitmap transferToImageBitmap();

inputfiles/idl/HTML - Embedded content.commentmap.json

@@ -3,7 +3,6 @@
     "img-naturalheight": "These attributes return the intrinsic dimensions of the image,\nor zero if the dimensions are not known.",
     "img-complete": "Returns true if the image has been completely downloaded or if\nno image is specified; otherwise, returns false.",
     "img-currentsrc": "Returns the image's absolute URL.",
-    "img-decoding": "Returns the image decoding hint set for this image.",
     "img-decode": "This method causes the user agent to decode the\nimage in parallel, returning a promise that fulfills when decoding is complete.\nThe promise will be rejected with an \"EncodingError\"\nDOMException if the image cannot be decoded.",
     "image": "Returns a new img element, with the width and height attributes set to the values\npassed in the relevant arguments, if applicable."
 }

inputfiles/idl/HTML - Form control infrastructure.commentmap.json

@@ -6,5 +6,6 @@
     "cva-validity": "Returns true if the element's value has no validity problems; false otherwise.",
     "cva-checkvalidity": "Returns true if the element's value has no validity problems; false otherwise. Fires an invalid event at the element in the latter case.",
     "cva-reportvalidity": "Returns true if the element's value has no validity problems; otherwise, returns false, fires\nan invalid event at the element, and (if the event isn't\ncanceled) reports the problem to the user.",
-    "cva-validationmessage": "Returns the error message that would be shown to the user if the element was to be checked\nfor validity."
+    "cva-validationmessage": "Returns the error message that would be shown to the user if the element was to be checked\nfor validity.",
+    "formdataevent-formdata": "Returns a FormData object representing names and values of elements associated\nto the target form. Operations on the FormData object will affect\nform data to be submitted."
 }

inputfiles/idl/HTML - Form control infrastructure.widl

@@ -19,3 +19,13 @@ interface ValidityState {
   readonly attribute boolean customError;
   readonly attribute boolean valid;
 };
+
+[Exposed=Window,
+ Constructor(DOMString type, optional FormDataEventInit eventInitDict)]
+interface FormDataEvent : Event {
+  readonly attribute FormData formData;
+};
+
+dictionary FormDataEventInit : EventInit {
+  required FormData formData;
+};

inputfiles/idl/HTML - ImageBitmap and animations.widl

@@ -22,3 +22,12 @@ dictionary ImageBitmapOptions {
   [EnforceRange] unsigned long resizeHeight;
   ResizeQuality resizeQuality = "low";
 };
+
+callback FrameRequestCallback = void (DOMHighResTimeStamp time);
+
+interface mixin AnimationFrameProvider {
+  unsigned long requestAnimationFrame(FrameRequestCallback callback);
+  void cancelAnimationFrame(unsigned long handle);
+};
+Window includes AnimationFrameProvider;
+DedicatedWorkerGlobalScope includes AnimationFrameProvider;

inputfiles/idl/HTML - Obsolete features.widl

@@ -286,8 +286,7 @@ partial interface Window {
   [Replaceable, SameObject] readonly attribute External external;
 };
 
-[Exposed=Window,
- NoInterfaceObject]
+[Exposed=Window]
 interface External {
   void AddSearchProvider();
   void IsSearchProviderInstalled();

inputfiles/idl/HTML - Offline Web applications.widl

@@ -1,4 +1,5 @@
-[Exposed=Window]
+[SecureContext,
+ Exposed=Window]
 interface ApplicationCache : EventTarget {
 
   // update status

inputfiles/idl/HTML - User interaction.widl

@@ -4,6 +4,7 @@ dictionary FocusOptions {
 
 interface mixin ElementContentEditable {
   [CEReactions] attribute DOMString contentEditable;
+  [CEReactions] attribute DOMString enterKeyHint;
   readonly attribute boolean isContentEditable;
   [CEReactions] attribute DOMString inputMode;
 };