Merge branch 'master' into fullscreenoptions

Author: sandersn

README.md

@@ -1,6 +1,5 @@
 # TypeScript and JavaScript lib generator
 
-AppVeyor Status: [![Build status](https://ci.appveyor.com/api/projects/status/8oj3j7u6nvag1xvu/branch/master?svg=true)](https://ci.appveyor.com/project/zhengbli/tsjs-lib-generator/branch/master)
 Travis CI Status: [![Build Status](https://travis-ci.org/Microsoft/TSJS-lib-generator.svg?branch=master)](https://travis-ci.org/Microsoft/TSJS-lib-generator)
 
 This tool is used to generate `dom.generated.d.ts`, `webworker.generated.d.ts` and `dom.iterable.generated.d.ts` for TypeScript.
@@ -67,13 +66,14 @@ A "Living Standard" ([example](https://xhr.spec.whatwg.org/)) should be added he
 ## Code Structure
 
 - `src/index.ts`: handles the emitting of the `.d.ts` files.
-- `src/test.ts`: verifies the otuput by comparing the `generated/` and `baseline/` contents.
+- `src/test.ts`: verifies the output by comparing the `generated/` and `baseline/` contents.
 
 
 ## Input Files
 
 - `browser.webidl.preprocessed.json`: a JSON file generated by Microsoft Edge. **Do not edit this file**.
     - Due to the different update schedules between Edge and TypeScript, this may not be the most up-to-date version of the spec.
+- `mdn/apiDescriptions.json`: a JSON file generated by fetching API descriptions from [MDN](https://developer.mozilla.org/en-US/docs/Web/API). **Do not edit this file**.
 - `addedTypes.json`: types that should exist in either browser or webworker but are missing from the Edge spec. The format of the file mimics that of `browser.webidl.preprocessed.json`.
 - `overridingTypes.json`: types that are defined in the spec file but has a better or more up-to-date definitions in the json files.
 - `removedTypes.json`: types that are defined in the spec file but should be removed.

baselines/dom.generated.d.ts

@@ -4,6 +4,8 @@ Some files in this directory are generated.
 Please do not edit them.
 This specifically includes:
 
-* `browser.webidl.json`
+* `browser.webidl.preprocessed.json`
+* `idl/*`
+* `mdn/*`
 
-Feel free to send a pull request with changes to any other files.
+Feel free to send a pull request with changes to any other files.

baselines/webworker.generated.d.ts

@@ -1,6 +1,15 @@
 {
     "mixins": {
         "mixin": {
+            "DocumentOrShadowRoot": {
+                "properties": {
+                    "property": {
+                        "styleSheets": {
+                            "comment": "/**\r\n * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.\r\n */"
+                        }
+                    }
+                }
+            },
             "GlobalEventHandlers": {
                 "properties": {
                     "property": {
@@ -664,15 +673,6 @@
                     }
                 }
             },
-            "DocumentOrShadowRoot": {
-                "properties": {
-                    "property": {
-                        "styleSheets": {
-                            "comment": "/**\r\n * Retrieves a collection of styleSheet objects representing the style sheets that correspond to each instance of a link or style object in the document.\r\n */"
-                        }
-                    }
-                }
-            },
             "Document": {
                 "properties": {
                     "property": {

inputfiles/README.md

@@ -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/addedTypes.json

@@ -0,0 +1,32 @@
+enum GamepadHand {
+  "",  /* unknown, both hands, or not applicable */
+  "left",
+  "right"
+};
+
+interface GamepadHapticActuator {
+  readonly attribute GamepadHapticActuatorType type;
+  Promise<boolean> pulse(double value, double duration);
+};
+
+enum GamepadHapticActuatorType {
+  "vibration"
+};
+
+interface GamepadPose {
+          readonly attribute boolean hasOrientation;
+          readonly attribute boolean hasPosition;
+
+          readonly attribute Float32Array? position;
+          readonly attribute Float32Array? linearVelocity;
+          readonly attribute Float32Array? linearAcceleration;
+          readonly attribute Float32Array? orientation;
+          readonly attribute Float32Array? angularVelocity;
+          readonly attribute Float32Array? angularAcceleration;
+        };
+
+partial interface Gamepad {
+  readonly attribute GamepadHand hand;
+  readonly attribute FrozenArray<GamepadHapticActuator> hapticActuators;
+  readonly attribute GamepadPose? pose;
+};

inputfiles/comments.json

@@ -0,0 +1,37 @@
+[Exposed=Window]
+interface Gamepad {
+  readonly attribute DOMString id;
+  readonly attribute long index;
+  readonly attribute boolean connected;
+  readonly attribute DOMHighResTimeStamp timestamp;
+  readonly attribute GamepadMappingType mapping;
+  readonly attribute FrozenArray<double> axes;
+  readonly attribute FrozenArray<GamepadButton> buttons;
+};
+
+[Exposed=Window]
+interface GamepadButton {
+  readonly attribute boolean pressed;
+  readonly attribute boolean touched;
+  readonly attribute double value;
+};
+
+enum GamepadMappingType {
+  "",
+  "standard",
+};
+
+[Exposed=Window]
+partial interface Navigator {
+  sequence<Gamepad?> getGamepads();
+};
+
+[Constructor(DOMString type, GamepadEventInit eventInitDict), Exposed=Window]
+
+interface GamepadEvent : Event {
+  [SameObject] readonly attribute Gamepad gamepad;
+};
+
+dictionary GamepadEventInit : EventInit {
+  required Gamepad gamepad;
+};

inputfiles/idl/Clipboard.widl

@@ -0,0 +1,23 @@
+partial interface Element {
+  void requestPointerLock();
+};
+
+partial interface Document {
+  attribute EventHandler onpointerlockchange;
+  attribute EventHandler onpointerlockerror;
+  void exitPointerLock();
+};
+
+partial interface DocumentOrShadowRoot {
+  readonly attribute Element? pointerLockElement;
+};
+
+partial interface MouseEvent {
+  readonly attribute long movementX;
+  readonly attribute long movementY;
+};
+
+partial dictionary MouseEventInit {
+  long movementX = 0;
+  long movementY = 0;
+};

inputfiles/idl/Gamepad Extensions.widl

@@ -0,0 +1,3 @@
+# DANGER ZONE
+
+Everything here is autogenerated by `npm run fetch` and MUST NOT be changed in a manual way.

inputfiles/idl/Gamepad.widl

@@ -0,0 +1,181 @@
+[Constructor(optional UnderlyingSource underlyingSource, optional QueuingStrategy strategy),
+ Constructor(optional UnderlyingByteSource underlyingSource, optional QueuingStrategy strategy),
+ Exposed=(Window,Worker)]
+interface ReadableStream {
+    readonly attribute boolean locked;
+    Promise<void> cancel(optional any reason);
+    ReadableStreamBYOBReader getReader(any options);
+    ReadableStreamDefaultReader getReader();
+    any pipeThrough(any pair, optional PipeOptions options);
+    Promise<void> pipeTo(WritableStream dest, optional PipeOptions options);
+    [ReadableStream, ReadableStream] tee();
+};
+
+callback QueuingStrategySizeCallback = double (any chunk);
+
+dictionary QueuingStrategy {
+	unrestricted double? highWaterMark;
+	QueuingStrategySizeCallback? size;
+};
+
+callback ReadableByteStreamControllerCallback = any (ReadableByteStreamController controller);
+callback ReadableStreamDefaultControllerCallback = any (ReadableStreamDefaultController controller);
+callback ReadableStreamErrorCallback = any (any reason);
+
+dictionary UnderlyingSource {
+    ReadableStreamDefaultControllerCallback? start;
+    ReadableStreamDefaultControllerCallback? pull;
+    ReadableStreamErrorCallback? cancel;
+
+    any type;
+};
+
+dictionary UnderlyingByteSource {
+    ReadableByteStreamControllerCallback? start;
+    ReadableByteStreamControllerCallback? pull;
+    ReadableStreamErrorCallback? cancel;
+
+    required DOMString type;
+    unsigned long? autoAllocateChunkSize;
+};
+
+dictionary PipeOptions {
+    boolean? preventClose;
+    boolean? preventAbort;
+    boolean? preventCancel;
+};
+
+[Exposed=(Window,Worker)]
+interface ReadableStreamReadResult {
+    attribute boolean done;
+    attribute any value;
+};
+
+[Constructor(ReadableStream stream),
+ Exposed=(Window,Worker)]
+interface ReadableStreamDefaultReader {
+    readonly attribute Promise<void> closed;
+
+    Promise<void> cancel(optional any reason);
+    Promise<ReadableStreamReadResult> read();
+    void releaseLock();
+};
+
+[Constructor(ReadableStream stream),
+ Exposed=(Window,Worker)]
+interface ReadableStreamBYOBReader {
+    readonly attribute Promise<void> closed;
+
+    Promise<void> cancel(optional any reason);
+    Promise<ReadableStreamReadResult> read(ArrayBufferView view);
+    void releaseLock();
+};
+
+[Exposed=(Window,Worker)]
+interface ReadableStreamDefaultController {
+    readonly attribute unrestricted double? desiredSize;
+
+    void close();
+    void enqueue(any chunk);
+    void error(optional any error);
+};
+
+[Exposed=(Window,Worker)]
+interface ReadableByteStreamController {
+    readonly attribute ReadableStreamBYOBRequest byobRequest;
+    readonly attribute unrestricted double? desiredSize;
+
+    void close();
+    void enqueue(ArrayBufferView chunk);
+    void error(optional any error);
+};
+
+[Exposed=(Window,Worker)]
+interface ReadableStreamBYOBRequest {
+    readonly attribute ArrayBufferView view;
+
+    void respond(unsigned long bytesWritten);
+    void respondWithNewView(ArrayBufferView view);
+};
+
+[Constructor(optional UnderlyingSink underlyingSink, optional QueuingStrategy strategy),
+ Exposed=(Window,Worker)]
+interface WritableStream {
+    readonly attribute boolean locked;
+    Promise<void> abort(optional any reason);
+    WritableStreamDefaultWriter getWriter();
+};
+
+callback WritableStreamDefaultControllerStartCallback = any (WritableStreamDefaultController controller);
+callback WritableStreamDefaultControllerWriteCallback = any (any chunk, WritableStreamDefaultController controller);
+callback WritableStreamDefaultControllerCloseCallback = any ();
+callback WritableStreamErrorCallback = any (any reason);
+
+dictionary UnderlyingSink {
+    WritableStreamDefaultControllerStartCallback? start;
+    WritableStreamDefaultControllerWriteCallback? write;
+    WritableStreamDefaultControllerCloseCallback? close;
+    WritableStreamErrorCallback? abort;
+
+    any type;
+};
+
+[Constructor(ReadableStream stream),
+ Exposed=(Window,Worker)]
+interface WritableStreamDefaultWriter {
+    readonly attribute Promise<void> closed;
+    readonly attribute unrestricted double? desiredSize;
+    readonly attribute Promise<void> ready;
+
+    Promise<void> abort(optional any reason);
+    Promise<void> close();
+    void releaseLock();
+    Promise<void> write(any chunk);
+};
+
+[Exposed=(Window,Worker)]
+interface WritableStreamDefaultController {
+    void error(optional any error);
+};
+
+[Constructor(optional Transformer transformer, optional QueuingStrategy writableStrategy, optional QueuingStrategy readableStrategy),
+ Exposed=(Window,Worker)]
+interface TransformStream {
+    readonly attribute ReadableStream readable;
+    readonly attribute WritableStream writable;
+};
+
+callback TransformStreamDefaultControllerCallback = any (TransformStreamDefaultController controller);
+callback TransformStreamDefaultControllerTransformCallback = any (any chunk, TransformStreamDefaultController controller);
+
+dictionary Transformer {
+    TransformStreamDefaultControllerCallback? start;
+    TransformStreamDefaultControllerTransformCallback? transform;
+    TransformStreamDefaultControllerCallback? flush;
+
+    any readableType;
+    any writableType;
+};
+
+[Exposed=(Window,Worker)]
+interface TransformStreamDefaultController {
+    readonly attribute unrestricted double? desiredSize;
+
+    void enqueue(any chunk);
+    void error(optional any reason);
+    void terminate();
+};
+
+[Constructor(any options),
+ Exposed=(Window,Worker)]
+interface ByteLengthQueuingStrategy: QueuingStrategy {
+    attribute unrestricted double highWaterMark;
+    double size(ArrayBufferView chunk);
+};
+
+[Constructor(any options),
+ Exposed=(Window,Worker)]
+interface CountQueuingStrategy: QueuingStrategy {
+    attribute unrestricted double highWaterMark;
+    double size(any chunk);
+};