diff --git a/Gulpfile.ts b/Gulpfile.ts index 054e99c80037e..ebd37f7b9e844 100644 --- a/Gulpfile.ts +++ b/Gulpfile.ts @@ -137,6 +137,7 @@ const es2017LibrarySourceMap = es2017LibrarySource.map(function(source) { }); const hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"]; +const es2015HostLibrarySources = ["dom.iterable.d.ts", "streams.d.ts", "fetch.d.ts"] const librarySourceMap = [ // Host library @@ -144,6 +145,8 @@ const librarySourceMap = [ { target: "lib.dom.iterable.d.ts", sources: ["header.d.ts", "dom.iterable.d.ts"] }, { target: "lib.webworker.d.ts", sources: ["header.d.ts", "webworker.generated.d.ts"] }, { target: "lib.scripthost.d.ts", sources: ["header.d.ts", "scripthost.d.ts"] }, + { target: "lib.streams.d.ts", sources: ["header.d.ts", "streams.d.ts"] }, + { target: "lib.fetch.d.ts", sources: ["header.d.ts", "fetch.d.ts"] }, // JavaScript library { target: "lib.es5.d.ts", sources: ["header.d.ts", "es5.d.ts"] }, @@ -153,7 +156,7 @@ const librarySourceMap = [ // JavaScript + all host library { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) }, - { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") } + { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, es2015HostLibrarySources) } ].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap); const libraryTargets = librarySourceMap.map(function(f) { diff --git a/Jakefile.js b/Jakefile.js index d327b5bb47ba6..2212f6eb39cd2 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -312,6 +312,7 @@ var es2017LibrarySourceMap = es2017LibrarySource.map(function (source) { }); var hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"]; +var es2015HostLibrarySources = ["dom.iterable.d.ts", "streams.d.ts", "fetch.d.ts"] var librarySourceMap = [ // Host library @@ -319,6 +320,8 @@ var librarySourceMap = [ { target: "lib.dom.iterable.d.ts", sources: ["header.d.ts", "dom.iterable.d.ts"] }, { target: "lib.webworker.d.ts", sources: ["header.d.ts", "webworker.generated.d.ts"] }, { target: "lib.scripthost.d.ts", sources: ["header.d.ts", "scripthost.d.ts"] }, + { target: "lib.streams.d.ts", sources: ["header.d.ts", "streams.d.ts"]}, + { target: "lib.fetch.d.ts", sources: ["header.d.ts", "fetch.d.ts"]}, // JavaScript library { target: "lib.es5.d.ts", sources: ["header.d.ts", "es5.d.ts"] }, @@ -328,7 +331,7 @@ var librarySourceMap = [ // JavaScript + all host library { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) }, - { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") } + { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, es2015HostLibrarySources) } ].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap); var libraryTargets = librarySourceMap.map(function (f) { diff --git a/src/lib/fetch.d.ts b/src/lib/fetch.d.ts new file mode 100644 index 0000000000000..7a74a706bdc18 --- /dev/null +++ b/src/lib/fetch.d.ts @@ -0,0 +1,129 @@ +/// The fetch API standard can be found at https://fetch.spec.whatwg.org/ +/// Definitions by: Ryan Graham , Kagami Sascha Rosylight , Robin Van den Broeck + +/// + +interface Window { + fetch(url: RequestInfo, init?: RequestInit): Promise; +} +declare var fetch: typeof window.fetch; + +declare type HeadersInit = Headers | string[][] | { [key: string]: string }; +declare class Headers { + constructor(init?: HeadersInit); + + append(name: string, value: string): void; + delete(name: string): void; + get(name: string): string | null; + has(name: string): boolean; + set(name: string, value: string): void; + + // WebIDL pair iterator: iterable + entries(): IterableIterator<[string, string]>; + forEach(callback: (value: string, index: number, headers: Headers) => void, thisArg?: any): void; + keys(): IterableIterator; + values(): IterableIterator; + [Symbol.iterator](): IterableIterator<[string, string]>; +} + +declare type BodyInit = Blob | ArrayBufferView | ArrayBuffer | FormData | URLSearchParams | string; +interface Body { + readonly bodyUsed: boolean; + arrayBuffer(): Promise; + blob(): Promise; + formData(): Promise; + json(): Promise; + text(): Promise; +} + +declare type RequestInfo = Request | string; +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?: any; +} + +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"; + +declare class Response { + constructor(body?: BodyInit, init?: ResponseInit); + + static error(): Response; + static redirect(url: string, status?: number): Response; + + readonly type: ResponseType; + readonly url: string; + readonly redirected: boolean; + readonly status: number; + readonly ok: boolean; + readonly statusText: string; + readonly headers: Headers; + // TODO: Readable stream implementation (I could not find the definitions of this type) + readonly body: ReadableStream | null; + readonly trailer: Promise; + + clone(): Response; +} +interface Response extends Body { } +interface ResponseInit { + status?: number; + statusText?: string; + headers?: HeadersInit; +} + +type ResponseType = "basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"; + +declare class URLSearchParams { + constructor(init?: string); + + append(name: string, value: string): void; + delete(name: string): void; + get(name: string): string | void; + getAll(name: string): string[]; + has(name: string): boolean; + set(name: string, value: string): void; + + entries(): IterableIterator<[string, string]>; + forEach(callback: (value: string, index: number, params: URLSearchParams) => void, thisArg?: any): void; + keys(): IterableIterator; + values(): IterableIterator; + [Symbol.iterator](): IterableIterator<[string, string]>; + + // TODO: stringifier +} diff --git a/src/lib/streams.d.ts b/src/lib/streams.d.ts new file mode 100644 index 0000000000000..eadb6e39b9ba2 --- /dev/null +++ b/src/lib/streams.d.ts @@ -0,0 +1,131 @@ +/// Definitions by: Kagami Sascha Rosylight + +interface ReadableStreamSource { + start?(controller: ReadableStreamDefaultController): void | Promise; + pull?(controller: ReadableStreamDefaultController): void | Promise; + cancel?(reason: string): void | Promise; +} + +interface ReadableByteStreamSource { + start?(controller: ReadableByteStreamController): void | Promise; + pull?(controller: ReadableByteStreamController): void | Promise; + cancel?(reason: string): void | Promise; + + type: "bytes"; +} + +interface QueuingStrategy { + highWaterMark?: number; + size?(chunk: ArrayBufferView): number; +} + +declare class ReadableStream { + constructor(underlyingSource?: ReadableStreamSource, strategy?: QueuingStrategy); + constructor(underlyingSource?: ReadableByteStreamSource, strategy?: QueuingStrategy); + + locked: boolean; + + cancel(reason: string): Promise; + getReader(): ReadableStreamDefaultReader; + getReader({ mode }: { mode: "byob" }): ReadableStreamBYOBReader; + pipeThrough({ writable, readable }: { writable: WritableStream, readable: T }): T; + pipeTo(dest: WritableStream, { preventClose, preventAbort, preventCancel }: { preventClose?: boolean, preventAbort?: boolean, preventCancel?: boolean }): Promise; + tee(): [ReadableStream, ReadableStream]; +} + +declare class ReadableStreamDefaultReader { + constructor(stream: ReadableStream); + + closed: Promise; + + cancel(reason: string): Promise; + read(): Promise>; + releaseLock(): void; +} + +declare class ReadableStreamBYOBReader { + constructor(stream: ReadableStream); + + closed: Promise; + + cancel(reason: string): Promise; + read(view: ArrayBufferView): Promise>; + releaseLock(): void; +} + +declare class ReadableStreamDefaultController { + constructor(stream: ReadableStream, underlyingSource: ReadableStreamSource, size: number, highWaterMark: number); + + desiredSize: number; + + close(): void; + enqueue(chunk: ArrayBufferView): number; + error(e: any): void; +} + +declare class ReadableByteStreamController { + constructor(stream: ReadableStream, underlyingSource: ReadableStreamSource, highWaterMark: number); + + byobRequest: ReadableStreamBYOBRequest; + desiredSize: number; + + close(): void; + enqueue(chunk: ArrayBufferView): number; + error(e: any): void; +} + +declare class ReadableStreamBYOBRequest { + constructor(controller: ReadableByteStreamController, view: ArrayBufferView); + + view: ArrayBufferView; + + respond(bytesWritten: number): void; + respondWithNewView(view: ArrayBufferView): void; +} + +interface WritableStreamSink { + start?(controller: WritableStreamDefaultController): void | Promise; + write?(chunk: any): void | Promise; + close?(): void | Promise; + abort?(reason: string): void | Promise; +} + +declare class WritableStream { + constructor(underlyingSink?: WritableStreamSink, strategy?: QueuingStrategy); + + locked: boolean; + + abort(reason: string): Promise; + getWriter(): WritableStreamDefaultWriter; +} + +declare class WritableStreamDefaultWriter { + constructor(stream: WritableStream); + + closed: Promise; + desiredSize: number; + ready: Promise; + + abort(reason: string): Promise; + close(): Promise; + releaseLock(): void; + write(chunk: any): Promise; +} + +declare class WritableStreamDefaultController { + constructor(stream: WritableStream, underlyingSink: WritableStreamSink, size: number, highWaterMark: number); + + error(e: any): void; +} + +declare class ByteLengthQueuingStrategy { + constructor({ highWaterMark }: { highWaterMark: number }); + + size(chunk: ArrayBufferView): number; +} + +declare class CountQueuingStrategy { + constructor({ highWaterMark }: { highWaterMark: number }); + + size(): number; // 1; +}