https://developer.mozilla.org/en-US/docs/Web/API/HTMLFieldSetElement#Specifications

// "Property 'elements' does not exist on type 'HTMLFieldSetElement'."
HTMLFieldSetElement.prototype.elements;

// (property) HTMLFormElement.elements: HTMLFormControlsCollection
// Retrieves a collection, in source order, of all controls in a given form.
HTMLFormElement.prototype.elements;

(https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement#Specifications)

it should probably be HTMLFormControlsCollection like the one in HTMLFormElement

In trying to fix, microsoft/TypeScript#14322,
Simply adding,

    {
        "kind": "typedef",
        "name": "IDBKeyPath",
        "type": "string | string[]"
    }

in overridingTypes.json should fix the problem, but when I do, the type isn't updated. The solution was to remove the type and then add it again, which seems less than ideal.

Need something to run before checking in, and also something to update the baseline when the changes are intended.

the WebGL spec lists variants of the uniform*[if]v() methods that take sequence<GLfloat or long>, for example:

void uniform1fv(WebGLUniformLocation? location, sequence<GLfloat> v);

these variants are missing from lib.d.ts, causing correct code to fail with

Argument of type 'number[]' is not assignable to parameter of type 'Float32Array'.

This isn't an issue but an idea I wanted to ask about.
I have a project where I want to use only the CSSStyleDeclaration type but not DOM types. I understand that I can just copy-paste into my own .d.ts file, but wanted to ask if there is value in doing this for TypeScript lib itself. One potential value add is that people may refer to a specific CSS implementation, like CSS2 or CSS3.

The new Fetch type definition included in TypeScript 2.2 defines everything in a overly simplified fashion, everything is just string or any:

interface Request extends Object, Body {
    readonly cache: string;
    readonly credentials: string;
    readonly destination: string;
    readonly headers: Headers;
    readonly integrity: string;
    readonly keepalive: boolean;
    readonly method: string;
    readonly mode: string;
    readonly redirect: string;
    readonly referrer: string;
    readonly referrerPolicy: string;
    readonly type: string;
    readonly url: string;
    clone(): Request;
}

declare var Request: {
    prototype: Request;
    new(input: Request | string, init?: RequestInit): Request;
}

interface RequestInit {
    method?: string;
    headers?: any;
    body?: any;
    referrer?: string;
    referrerPolicy?: string;
    mode?: string;
    credentials?: string;
    cache?: string;
    redirect?: string;
    integrity?: string;
    keepalive?: boolean;
    window?: any;
}

vs whatwg-fetch d.ts from DefinitelyTyped that has been carefully crafted and tested:

declare class Request {
    constructor(input: RequestInfo, init?: RequestInit);

    readonly method: string;
    readonly url: string;
    readonly headers: Headers;

    readonly type: RequestType
    readonly destination: RequestDestination;
    readonly referrer: string;
    readonly referrerPolicy: ReferrerPolicy;
    readonly mode: RequestMode;
    readonly credentials: RequestCredentials;
    readonly cache: RequestCache;
    readonly redirect: RequestRedirect;
    readonly integrity: string;
    readonly keepalive: boolean;

    clone(): Request;
}
interface Request extends Body {}
interface RequestInit {
    method?: string;
    headers?: HeadersInit;
    body?: BodyInit;
    referrer?: string;
    referrerPolicy?: ReferrerPolicy;
    mode?: RequestMode;
    credentials?: RequestCredentials;
    cache?: RequestCache;
    redirect?: RequestRedirect;
    integrity?: string;
    window?: null; // can only be set to null
}

type RequestType = "" | "audio" | "font" | "image" | "script" | "style" | "track" | "video";
type RequestDestination = "" | "document" | "embed" | "font" | "image" | "manifest" | "media" | "object" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "worker" | "xslt";
type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
type RequestCredentials = "omit" | "same-origin" | "include";
type RequestCache = "default" | "no-store" | "reload" | "no-cache" | "force-cache" | "only-if-cached";
type RequestRedirect = "follow" | "error" | "manual";

type ReferrerPolicy = "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";

I believe the function signature for HTMLCanvasElement.toBlob() is wrong. According to https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob, it is async and takes a callback plus optional media type / quality option arguments.

See #45.

Window's error event should come from https://github.com/Microsoft/TSJS-lib-generator/blob/master/inputfiles/browser.webidl.xml#L12798, but it is missing with the generated .d.ts file.

https://github.com/Microsoft/TSJS-lib-generator/blob/master/baselines/dom.generated.d.ts#L13045

@zhengbli Can you take a look?

cc @saschanaz for your pr.

TypeScript Version: 1.8.10

Expected behavior: According to the MDN (https://developer.mozilla.org/en-US/docs/Web/API/Element), insertAdjacent* methods should be part of the Element interface.

Actual behavior: insertAdjacent* methods are part of the HTMLElement interface.

In the WebIDL file, HTMLMediaElement.readyState is reported to be of type any. According to the specification however, it should be of type unsigned short (which translates to number in TypeScript).

Since these files are generated by Edge, I'm not sure if this is the right place to report this problem. I guess I could make a patch to add it to overridingTypes.json, but it would be nice if this was fixed upstream.

The IDL XML seems to think the parameter is optional with default of null, but it isn't according to the spec. Indeed browsers complain if calling it without any parameters.

This example worked in 2.0, but not in 2.1:

const input = document.createElement('input');
input.value; // OK
input.onchange = function() {
    this.value; // Error
}

The current definition for onchange in HTMLElement is: onchange: (this: HTMLElement, ev: Event) => any;. Maybe it should use this: this?

Add Array.prototype.includes

interface Array<T>{
    includes(value: T, index?: number): boolean
}

I came from microsoft/TypeScript#3027

This IDL is used as de-facto standard for all major browsers
https://dom.spec.whatwg.org/#idl-index

TypeScript should use this IDL to add and ship features from DOM early from Living Standard.

This is gated on: microsoft/TypeScript#6532

The webidl file already provide this information, we need to translate that in the script:

for instance read-only:
https://github.com/Microsoft/TSJS-lib-generator/blob/ea717dddb01dbeb6386b844f667194f71c7d7165/inputfiles/browser.webidl.xml#L408

and constant : https://github.com/Microsoft/TSJS-lib-generator/blob/ea717dddb01dbeb6386b844f667194f71c7d7165/inputfiles/browser.webidl.xml#L315

It seems like it will always throw an error, so perhaps we shouldn't mark it as constructable.

I'm trying to add FormData interface to webworker.d.ts (microsoft/TypeScript#14085). IIUC, I need to add to inputfiles/knownWorkerInterfaces.json. It generates:

interface FormData {
    append(name: any, value: any, blobName?: string): void;
}

declare var FormData: {
    prototype: FormData;
    new (form?: HTMLFormElement): FormData;
}

The problem is the FormData's constructor. Is there a way to add different constructors for DOM and Workers?

lib.d.ts currently shows HTMLInputElement as having a files attribute which is always a FileList.

According to the spec, files is only a FileList when the IDL attribute applies, and null when it does not. https://html.spec.whatwg.org/multipage/forms.html#dom-input-files

The files attribute only applies when the input's type is File Upload (file=type). https://html.spec.whatwg.org/multipage/forms.html#concept-input-apply

See rejected PR #74 for more information. Additionally, non-nullable types in TS may assist with making this change. microsoft/TypeScript#7140

I'm trying to override:

interface SpeechSynthesisEvent extends Event {
    readonly charIndex: number;
    readonly elapsedTime: number;
    readonly name: string;
    readonly utterance: SpeechSynthesisUtterance | null;
}

With:

interface SpeechSynthesisEvent extends Event {
    readonly charIndex?: number;
    readonly elapsedTime?: number;
    readonly name?: string;
    readonly utterance: SpeechSynthesisUtterance | null;
}

So far the best I could do was:

interface SpeechSynthesisEvent extends Event {
    readonly charIndex: number | undefined;
    readonly elapsedTime: number | undefined;
    readonly name: string | undefined;
    readonly utterance: SpeechSynthesisUtterance | null;
}

But I'm not sure if that conforms well to the style of the rest of the type definitions. I've tried several approaches but none of them worked:

• Trying to override the property names modified with? in overridingTypes.json didn't do anything.
• Redefining the entire interface in addedTypes.json simply created a duplicate.
• Trying to remove the original in removedTypes.json didn't do anything.

Is there any way to achieve this? Any ideas?

As discussed in microsoft/TypeScript#15175, the property on MediaTrackConstraintSet should be called echoCancellation but is currently misspelled as echoCancelation.

I tried to send a PR fixing this, but it seems to me like the generated interface comes from browser.webidl.xml (I couldn't find the specific property in any of the .json files) and the readme explicitly says to not edit this file.

Would this be an appropriate case to use the overridingTypes.json? Wouldn't it be better to fix this "upstream" in Edge itself?

Filed as microsoft/TypeScript#8202 but I think it belongs here.

As of 59dc049 (current master) in many cases the addEventListener("error", ...) code uses a different event type from the onerror code.

E.g. I think these should be using ErrorEvent for the onerror, not Event, to match addEventListener. (Perhaps it's intentional?)

interface MSBaseReader {
    onerror: (ev: Event) => any;
    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;

interface IDBDatabase extends EventTarget {
    onerror: (ev: Event) => any;
    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;

Please, update overridingTypes.json as folowing to fix
microsoft/TypeScript#14363 :

{
"kind": "indexer",
"interface": "HTMLCollectionOf",
"signatures": ["[index: number]: T"]
},

In browser.webidl.xml, HTMLElement.offsetParent has type Element. Type Element does not have an offsetParent property. Therefore it is not possible to chain offsetParent properties in Typescript like such as htmlelement.offsetParent.offsetParent.

This capability seems to broadly supported as the jQuery source uses this in its position function (CTRL+F for offsetParent: to find it).

Obviously the workaround is to cast the offsetParent property to HTMLElement. Not sure how easy this is to fix since browser.webidl.xml is from the Edge team, but regardless I thought I would call it out here.

Latest Edge does appear to support chaining calls to offsetParent in my tests.

TypeScript Version: 1.8.0

Dear Ladies and Gentlemen,

I would like to bring to your attention, that the following function / property is not defined in the "lib.es6.d.ts".

Attr.isId

The Attr.IsId is defined in the DOM-Leve3-Core specification which is available at the W3C.

W3C DOM Level3 Core

Here is the part of the "lib.es6.d.ts" which declares the "Attr" object.

Kind regards, Lord Saumagen.

By the spec, CSSStyleDeclaration.properttyName should only return a string value, not be null.

• https://www.w3.org/TR/cssom-1/#dom-cssstyledeclaration-getpropertyvalue
• https://www.w3.org/TR/cssom-1/#dom-cssstyledeclaration-camel-cased-attribute

But the current code in this repository defines them as properttyName: string | null. This is incorrect.

Found:

• here and
• here

Is this a bug?

Happy to contribute a PR, but I can't run build.sh on my Ubuntu box:

$ ./build.sh
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   599    0   599    0     0    839      0 --:--:-- --:--:-- --:--:--   838
100 30768  100 30768    0     0  19586      0  0:00:01  0:00:01 --:--:--  117k
Missing method Contains in assembly /home/myitcv/dev/TSJS-lib-generator/.paket/paket.bootstrapper.exe, type System.Linq.Enumerable

Unhandled Exception:
System.IO.FileNotFoundException: Could not load file or assembly 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' or one of its dependencies.
File name: 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
[ERROR] FATAL UNHANDLED EXCEPTION: System.IO.FileNotFoundException: Could not load file or assembly 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' or one of its dependencies.
File name: 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'

$ mono --version
Mono JIT compiler version 3.2.8 (Debian 3.2.8+dfsg-4ubuntu4)
Copyright (C) 2002-2014 Novell, Inc, Xamarin Inc and Contributors. www.mono-project.com
        TLS:           __thread
        SIGSEGV:       altstack
        Notifications: epoll
        Architecture:  amd64
        Disabled:      none
        Misc:          softdebug
        LLVM:          supported, not enabled.
        GC:            sgen

$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 15.10
Release:        15.10
Codename:       wily

Worth adding a Travis build to ensure this works for *nix users?

From microsoft/TypeScript#10695, for some reason TSJS-lib-generator is picking up .clear() on WeakMap, though the ChakraCore team indicate it is not exposed to JavaScript land (see microsoft/TypeScript#1539)

Now that we can extend both class instance type and static type, can we now directly emit classes? Is there any remaining blocking problems?

TypeScript Version: 2.0.6

Dear Ladies and Gentlemen,

I would like to bring to your attention, that the following interface is not conform to the specification in the "lib.es6.d.ts".

Currently defined as:

interface IteratorResult<T> {
done: boolean;
value: T;
}

The specification tells that the last IteratorResult returned form an iterator has the following values assigned:

done = true;
value = undefined,

So the correct interface definition would be:

interface IteratorResult<T> {
done: boolean;
value: T | undefined;
}

See the description ad MDN:

Kind regards,

Lord Saumagen.

Running node node_modules/tslint/bin/tslint src/lib/*.generated.d.ts in the TypeScript repo reveals a few errors.

TypeScript Version:

1.9.0-dev.20160225

Code

{
        "kind": "property",
        "interface": "HTMLTextAreaElement",
        "name": "autocomplete",
        "type": "\"on\" | \"off\""
}

Expected behavior:

generate following code.

interface HTMLTextAreaElement {
        autocomplete: "on" | "of";
}

Actual behavior:

generate nothing.

I'm trying to override

interface SpeechSynthesisUtteranceEventMap {
    "boundary": Event;
    "end": Event;
    "error": Event;
    "mark": Event;
    "pause": Event;
    "resume": Event;
    "start": Event;
}

with

interface SpeechSynthesisUtteranceEventMap {
    "boundary": SpeechSynthesisEvent;
    "end": SpeechSynthesisEvent;
    "error": SpeechSynthesisErrorEvent;
    "mark": SpeechSynthesisEvent;
    "pause": SpeechSynthesisEvent;
    "resume": SpeechSynthesisEvent;
    "start": SpeechSynthesisEvent;
}

Like in #191:

• Trying to override these with overridingTypes.json didn't do anything.
• I've tried to redefine the whole interface in addedTypes.json but it simply created a duplicate.
• I've tried to remove it with removedTypes.json but that didn't do anything.

Readonly keyword was added to TypeScript.
But, TSJS-Genrerator does not correspond to readonly keyword.
related PR: #66

Related to #53.

Ideally the added method overload signatures should be placed right before the most generic one, instead of at the end of the interface body.

Current definition:

addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
removeEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;

Should be something like:

interface AddEventListenerOptions {
  capture?: boolean;
  once?: boolean;
  passive?: boolean;
}

interface RemoveEventListenerOptions {
  capture?: boolean;
  passive?: boolean;
}

interface EventTarget {
  addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: AddEventListenerOptions): void;
  addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
  removeEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
  removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: RemoveEventListenerOptions): void;
}

listener is mandatory.

See addEventListener and removeEventListener:

target.addEventListener(type, listener[, options]);
target.addEventListener(type, listener[, useCapture]);

target.removeEventListener(type, listener[, options]);
target.removeEventListener(type, listener[, useCapture]);

Example:

var listener = function() {
  console.log('Hello!');
}

document.body.addEventListener('click', listener);

document.body.click(); // Hello!

document.body.removeEventListener('click'); // BOOM! =>
/* Under Chrome 55:
Uncaught TypeError: Failed to execute 'removeEventListener' on 'EventTarget': 2 arguments required, but only 1 present.
*/

/* Under Firefox 47
TypeError: Not enough arguments to EventTarget.removeEventListener.
*/

document.body.addEventListener('click'); // BOOM! =>
/* Under Chrome 55:
Uncaught TypeError: Failed to execute 'addEventListener' on 'EventTarget': 2 arguments required, but only 1 present.
*/

I'm not sure if that's the right place to raise that issue. Please tell me where else to post it when I'm wrong here.

I discovered that when specifying the lib "webworker" in a tsconfig file the performance property seems to be missing. According to MDN and a quick test in Chrome it is part of the WorkerGlobalScope. Shouldn't it be then also part of the "webworker" lib?

I'm new to TypeScript so there is a good chance I misunderstood something completely.

I want override ClipboardEvent.
So, I change overridingTypes.json and then run bat.
But, Nothing is occured.

{
        "kind": "method",
        "interface": "HTMLElement",
        "name": "onbeforecopy",
        "signatures": ["onbeforecopy: (ev: ClipboardEvent) => any"]
}

This promlem has occured at removeTypes.json.
Lib.d.ts addEventListener should specify ClipboardEvent payload for relevant events #5363

ValidityState is missing tooShort:

interface ValidityState {
    readonly badInput: boolean;
    readonly customError: boolean;
    readonly patternMismatch: boolean;
    readonly rangeOverflow: boolean;
    readonly rangeUnderflow: boolean;
    readonly stepMismatch: boolean;
    readonly tooLong: boolean;
    // missing => readonly tooShort: boolean;
    readonly typeMismatch: boolean;
    readonly valid: boolean;
    readonly valueMissing: boolean;
}

See https://github.com/Microsoft/TSJS-lib-generator/blob/475f27eacbec630695df8ae7b38ebeff2926b92f/baselines/dom.generated.d.ts#L11872

See MDN doc: https://developer.mozilla.org/en-US/docs/Web/API/ValidityState
See HTML 5.0 spec: https://www.w3.org/TR/html5/forms.html#validitystate
See HTML 5.2 spec (draft): https://www.w3.org/TR/html52/sec-forms.html#validitystate

There are several properties of HTMLSelectElement that could be typed more specifically. For example options is typed as HTMLCollection when it could be typed as HTMLOptionsCollection (which isn't currently typed) which it's index would be of type HTMLOptionElement. (see: MDN HTMLSelectElement)

I would also argue that HTMLCollection should actually return HTMLElement instead of Element.

Note, this "broke" some things with TS 1.8.2 because previously the index returned any thereby allowing a lot of code to "just compile".

I am attempting to update the WebCrypto interface definitions, where functions return Promises. If I declare these return values as Promises, tsc will fail to build. If I change this to PromiseLike, it builds fine, but if I am targeting es6 (or using the es6 library via other means), it would be nice to have the return values be actual Promises. Is there a way to specify separate signatures for es5 and es6 libraries?

It seems it was removed on April, shouldn't it be readded? The current Travis test does not ensure dom.generated.d.ts has correct TypeScript syntax and type structure.

How can I override extending targets of the interface?
https://github.com/Microsoft/TSJS-lib-generator/pull/51/files#diff-02015aece7bbbd0234e4c3c785287c1cR884

Please allow the trailing newline in tests. GitHub editor on browser add the trailing newline.

Currently we don't check the nullability of types for items in the overridingTypes.json. We should check the nullability of the corresponding types in the spec and complement the content.

The DefinitelyTyped definitions for this API have some differences that appear correct. SpeechSynthesisUtterance.onstart and other methods should have a SpeechSynthesisEvent as their event type, and not just Event. We already have a SpeechSynthesisEvent type defined in lib.dom.d.ts, but aren't using it everywhere we should.

Example:

new IntersectionObserver(() => {}); // no error
window.IntersectionObserver // error: Property 'IntersectionObserver' does not exist on type 'Window'.

Related issue: microsoft/TypeScript#16255

If I wanted to raise a PR to fix this, am I right in thinking that I need to add a property to the Window interface in addedTypes.json?

With microsoft/TypeScript#7140, we should emit null as valid type. Nullable types are marked with nullable="1". e.g. Element.getAttribte should be defined as:

getAttribute(name?: string): string | null;

DefinitelyTyped/DefinitelyTyped#9378

To quote @ryan-codingintrigue:

...global definitions like [UrlSearchParams] should be in TypeScript's lib.d.ts definition
(See https://github.com/Microsoft/TypeScript/blob/master/src/lib/dom.generated.d.ts#L11759)

But they only go into that once Microsoft Edge supports the feature and at present, URLSearchParams is not present in Edge.

The type definitions on DefinitelyTyped appear to get some things right that we don't.

• RTCSdpType: Should include "rollback"
• RTCSessionDescription: Properties should be readonly
• RTCSessionDescriptionInit: type should be required
• RTCIceCandidate:
  • properties should be readonly
  • sdpMid and spdMLineIndex should be optional
• RTCIceTransportPolicy: Shouldn't include "none"
• RTCIceTransportState: Should include "failed"
• RTCDtlsTransportState: Should include "failed"
• RTCRtpEncodingParameters: "maxFramerate" should be required
• RTCPeerConnection.canTrickleIceCandidates: should be optional (| undefined)
• RTCPeerConnection:
  • configuration should be optional
  • On the static side: Should have defaultIceServers and generateCertificate

Also, many of these RTC* types are in lib.es6.d.ts, but should probably be in lib.dom.d.ts.

The declaration of DOMImplementation in lib.d.ts includes the method:

createDocument(namespaceURI: string | null, qualifiedName: string | null, doctype: DocumentType): Document;

However, according to the DOM Specification the doctype parameter can be null. This accords with almost every use of this method that I have ever seen in JavaScript code.