diff options
Diffstat (limited to 'ext/web')
| -rw-r--r-- | ext/web/lib.deno_web.d.ts | 426 |
1 files changed, 309 insertions, 117 deletions
diff --git a/ext/web/lib.deno_web.d.ts b/ext/web/lib.deno_web.d.ts index e1ffdc329..331c9536b 100644 --- a/ext/web/lib.deno_web.d.ts +++ b/ext/web/lib.deno_web.d.ts @@ -5,16 +5,71 @@ /// <reference no-default-lib="true" /> /// <reference lib="esnext" /> -/** @category DOM Events */ -declare class DOMException extends Error { - constructor(message?: string, name?: string); +/** @category Web APIs */ +declare interface DOMException extends Error { readonly name: string; readonly message: string; readonly code: number; + readonly INDEX_SIZE_ERR: 1; + readonly DOMSTRING_SIZE_ERR: 2; + readonly HIERARCHY_REQUEST_ERR: 3; + readonly WRONG_DOCUMENT_ERR: 4; + readonly INVALID_CHARACTER_ERR: 5; + readonly NO_DATA_ALLOWED_ERR: 6; + readonly NO_MODIFICATION_ALLOWED_ERR: 7; + readonly NOT_FOUND_ERR: 8; + readonly NOT_SUPPORTED_ERR: 9; + readonly INUSE_ATTRIBUTE_ERR: 10; + readonly INVALID_STATE_ERR: 11; + readonly SYNTAX_ERR: 12; + readonly INVALID_MODIFICATION_ERR: 13; + readonly NAMESPACE_ERR: 14; + readonly INVALID_ACCESS_ERR: 15; + readonly VALIDATION_ERR: 16; + readonly TYPE_MISMATCH_ERR: 17; + readonly SECURITY_ERR: 18; + readonly NETWORK_ERR: 19; + readonly ABORT_ERR: 20; + readonly URL_MISMATCH_ERR: 21; + readonly QUOTA_EXCEEDED_ERR: 22; + readonly TIMEOUT_ERR: 23; + readonly INVALID_NODE_TYPE_ERR: 24; + readonly DATA_CLONE_ERR: 25; } +/** @category Web APIs */ +declare var DOMException: { + readonly prototype: DOMException; + new (message?: string, name?: string): DOMException; + readonly INDEX_SIZE_ERR: 1; + readonly DOMSTRING_SIZE_ERR: 2; + readonly HIERARCHY_REQUEST_ERR: 3; + readonly WRONG_DOCUMENT_ERR: 4; + readonly INVALID_CHARACTER_ERR: 5; + readonly NO_DATA_ALLOWED_ERR: 6; + readonly NO_MODIFICATION_ALLOWED_ERR: 7; + readonly NOT_FOUND_ERR: 8; + readonly NOT_SUPPORTED_ERR: 9; + readonly INUSE_ATTRIBUTE_ERR: 10; + readonly INVALID_STATE_ERR: 11; + readonly SYNTAX_ERR: 12; + readonly INVALID_MODIFICATION_ERR: 13; + readonly NAMESPACE_ERR: 14; + readonly INVALID_ACCESS_ERR: 15; + readonly VALIDATION_ERR: 16; + readonly TYPE_MISMATCH_ERR: 17; + readonly SECURITY_ERR: 18; + readonly NETWORK_ERR: 19; + readonly ABORT_ERR: 20; + readonly URL_MISMATCH_ERR: 21; + readonly QUOTA_EXCEEDED_ERR: 22; + readonly TIMEOUT_ERR: 23; + readonly INVALID_NODE_TYPE_ERR: 24; + readonly DATA_CLONE_ERR: 25; +}; + /** @category DOM Events */ -interface EventInit { +declare interface EventInit { bubbles?: boolean; cancelable?: boolean; composed?: boolean; @@ -24,8 +79,7 @@ interface EventInit { * * @category DOM Events */ -declare class Event { - constructor(type: string, eventInitDict?: EventInit); +declare interface Event { /** Returns true or false depending on how event was initialized. True if * event goes through its target's ancestors in reverse tree order, and * false otherwise. */ @@ -80,19 +134,28 @@ declare class Event { readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number; readonly NONE: number; - static readonly AT_TARGET: number; - static readonly BUBBLING_PHASE: number; - static readonly CAPTURING_PHASE: number; - static readonly NONE: number; } +/** An event which takes place in the DOM. + * + * @category DOM Events + */ +declare var Event: { + readonly prototype: Event; + new (type: string, eventInitDict?: EventInit): Event; + readonly AT_TARGET: number; + readonly BUBBLING_PHASE: number; + readonly CAPTURING_PHASE: number; + readonly NONE: number; +}; + /** * EventTarget is a DOM interface implemented by objects that can receive events * and may have listeners for them. * * @category DOM Events */ -declare class EventTarget { +declare interface EventTarget { /** Appends an event listener for events whose type attribute value is type. * The callback argument sets the callback that will be invoked when the event * is dispatched. @@ -134,13 +197,24 @@ declare class EventTarget { ): void; } +/** + * EventTarget is a DOM interface implemented by objects that can receive events + * and may have listeners for them. + * + * @category DOM Events + */ +declare var EventTarget: { + readonly prototype: EventTarget; + new (): EventTarget; +}; + /** @category DOM Events */ -interface EventListener { +declare interface EventListener { (evt: Event): void | Promise<void>; } /** @category DOM Events */ -interface EventListenerObject { +declare interface EventListenerObject { handleEvent(evt: Event): void | Promise<void>; } @@ -150,19 +224,19 @@ declare type EventListenerOrEventListenerObject = | EventListenerObject; /** @category DOM Events */ -interface AddEventListenerOptions extends EventListenerOptions { +declare interface AddEventListenerOptions extends EventListenerOptions { once?: boolean; passive?: boolean; signal?: AbortSignal; } /** @category DOM Events */ -interface EventListenerOptions { +declare interface EventListenerOptions { capture?: boolean; } /** @category DOM Events */ -interface ProgressEventInit extends EventInit { +declare interface ProgressEventInit extends EventInit { lengthComputable?: boolean; loaded?: number; total?: number; @@ -174,14 +248,25 @@ interface ProgressEventInit extends EventInit { * * @category DOM Events */ -declare class ProgressEvent<T extends EventTarget = EventTarget> extends Event { - constructor(type: string, eventInitDict?: ProgressEventInit); +declare interface ProgressEvent<T extends EventTarget = EventTarget> + extends Event { readonly lengthComputable: boolean; readonly loaded: number; readonly target: T | null; readonly total: number; } +/** Events measuring progress of an underlying process, like an HTTP request + * (for an XMLHttpRequest, or the loading of the underlying resource of an + * <img>, <audio>, <video>, <style> or <link>). + * + * @category DOM Events + */ +declare var ProgressEvent: { + readonly prototype: ProgressEvent; + new (type: string, eventInitDict?: ProgressEventInit): ProgressEvent; +}; + /** Decodes a string of data which has been encoded using base-64 encoding. * * ``` @@ -214,7 +299,7 @@ declare interface TextDecodeOptions { } /** @category Encoding API */ -interface TextDecoder { +declare interface TextDecoder { /** Returns encoding's name, lowercased. */ readonly encoding: string; /** Returns `true` if error mode is "fatal", and `false` otherwise. */ @@ -228,7 +313,7 @@ interface TextDecoder { /** @category Encoding API */ declare var TextDecoder: { - prototype: TextDecoder; + readonly prototype: TextDecoder; new (label?: string, options?: TextDecoderOptions): TextDecoder; }; @@ -239,7 +324,7 @@ declare interface TextEncoderEncodeIntoResult { } /** @category Encoding API */ -interface TextEncoder { +declare interface TextEncoder { /** Returns "utf-8". */ readonly encoding: "utf-8"; /** Returns the result of running UTF-8's encoder. */ @@ -249,12 +334,12 @@ interface TextEncoder { /** @category Encoding API */ declare var TextEncoder: { - prototype: TextEncoder; + readonly prototype: TextEncoder; new (): TextEncoder; }; /** @category Encoding API */ -interface TextDecoderStream { +declare interface TextDecoderStream { /** Returns encoding's name, lowercased. */ readonly encoding: string; /** Returns `true` if error mode is "fatal", and `false` otherwise. */ @@ -268,12 +353,12 @@ interface TextDecoderStream { /** @category Encoding API */ declare var TextDecoderStream: { - prototype: TextDecoderStream; + readonly prototype: TextDecoderStream; new (label?: string, options?: TextDecoderOptions): TextDecoderStream; }; /** @category Encoding API */ -interface TextEncoderStream { +declare interface TextEncoderStream { /** Returns "utf-8". */ readonly encoding: "utf-8"; readonly readable: ReadableStream<Uint8Array>; @@ -283,7 +368,7 @@ interface TextEncoderStream { /** @category Encoding API */ declare var TextEncoderStream: { - prototype: TextEncoderStream; + readonly prototype: TextEncoderStream; new (): TextEncoderStream; }; @@ -292,7 +377,7 @@ declare var TextEncoderStream: { * * @category Web APIs */ -declare class AbortController { +declare interface AbortController { /** Returns the AbortSignal object associated with this object. */ readonly signal: AbortSignal; /** Invoking this method will set this object's AbortSignal's aborted flag and @@ -300,8 +385,18 @@ declare class AbortController { abort(reason?: any): void; } +/** A controller object that allows you to abort one or more DOM requests as and + * when desired. + * + * @category Web APIs + */ +declare var AbortController: { + readonly prototype: AbortController; + new (): AbortController; +}; + /** @category Web APIs */ -interface AbortSignalEventMap { +declare interface AbortSignalEventMap { abort: Event; } @@ -310,7 +405,7 @@ interface AbortSignalEventMap { * * @category Web APIs */ -interface AbortSignal extends EventTarget { +declare interface AbortSignal extends EventTarget { /** Returns true if this AbortSignal's AbortController has signaled to abort, * and false otherwise. */ readonly aborted: boolean; @@ -344,14 +439,14 @@ interface AbortSignal extends EventTarget { /** @category Web APIs */ declare var AbortSignal: { - prototype: AbortSignal; - new (): AbortSignal; + readonly prototype: AbortSignal; + new (): never; abort(reason?: any): AbortSignal; timeout(milliseconds: number): AbortSignal; }; /** @category Web File API */ -interface FileReaderEventMap { +declare interface FileReaderEventMap { "abort": ProgressEvent<FileReader>; "error": ProgressEvent<FileReader>; "load": ProgressEvent<FileReader>; @@ -366,7 +461,7 @@ interface FileReaderEventMap { * * @category Web File API */ -interface FileReader extends EventTarget { +declare interface FileReader extends EventTarget { readonly error: DOMException | null; onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null; onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null; @@ -410,7 +505,7 @@ interface FileReader extends EventTarget { /** @category Web File API */ declare var FileReader: { - prototype: FileReader; + readonly prototype: FileReader; new (): FileReader; readonly DONE: number; readonly EMPTY: number; @@ -418,10 +513,10 @@ declare var FileReader: { }; /** @category Web File API */ -type BlobPart = BufferSource | Blob | string; +declare type BlobPart = BufferSource | Blob | string; /** @category Web File API */ -interface BlobPropertyBag { +declare interface BlobPropertyBag { type?: string; endings?: "transparent" | "native"; } @@ -433,9 +528,7 @@ interface BlobPropertyBag { * * @category Web File API */ -declare class Blob { - constructor(blobParts?: BlobPart[], options?: BlobPropertyBag); - +declare interface Blob { readonly size: number; readonly type: string; arrayBuffer(): Promise<ArrayBuffer>; @@ -444,8 +537,20 @@ declare class Blob { text(): Promise<string>; } +/** A file-like object of immutable, raw data. Blobs represent data that isn't + * necessarily in a JavaScript-native format. The File interface is based on + * Blob, inheriting blob functionality and expanding it to support files on the + * user's system. + * + * @category Web File API + */ +declare var Blob: { + readonly prototype: Blob; + new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob; +}; + /** @category Web File API */ -interface FilePropertyBag extends BlobPropertyBag { +declare interface FilePropertyBag extends BlobPropertyBag { lastModified?: number; } @@ -454,36 +559,40 @@ interface FilePropertyBag extends BlobPropertyBag { * * @category Web File API */ -declare class File extends Blob { - constructor( - fileBits: BlobPart[], - fileName: string, - options?: FilePropertyBag, - ); - +declare interface File extends Blob { readonly lastModified: number; readonly name: string; } +/** Provides information about files and allows JavaScript in a web page to + * access their content. + * + * @category Web File API + */ +declare var File: { + readonly prototype: File; + new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File; +}; + /** @category Streams API */ -interface ReadableStreamDefaultReadDoneResult { +declare interface ReadableStreamDefaultReadDoneResult { done: true; value?: undefined; } /** @category Streams API */ -interface ReadableStreamDefaultReadValueResult<T> { +declare interface ReadableStreamDefaultReadValueResult<T> { done: false; value: T; } /** @category Streams API */ -type ReadableStreamDefaultReadResult<T> = +declare type ReadableStreamDefaultReadResult<T> = | ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult; /** @category Streams API */ -interface ReadableStreamDefaultReader<R = any> { +declare interface ReadableStreamDefaultReader<R = any> { readonly closed: Promise<void>; cancel(reason?: any): Promise<void>; read(): Promise<ReadableStreamDefaultReadResult<R>>; @@ -492,29 +601,29 @@ interface ReadableStreamDefaultReader<R = any> { /** @category Streams API */ declare var ReadableStreamDefaultReader: { - prototype: ReadableStreamDefaultReader; + readonly prototype: ReadableStreamDefaultReader; new <R>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>; }; /** @category Streams API */ -interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> { +declare interface ReadableStreamBYOBReadDoneResult<V extends ArrayBufferView> { done: true; value?: V; } /** @category Streams API */ -interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> { +declare interface ReadableStreamBYOBReadValueResult<V extends ArrayBufferView> { done: false; value: V; } /** @category Streams API */ -type ReadableStreamBYOBReadResult<V extends ArrayBufferView> = +declare type ReadableStreamBYOBReadResult<V extends ArrayBufferView> = | ReadableStreamBYOBReadDoneResult<V> | ReadableStreamBYOBReadValueResult<V>; /** @category Streams API */ -interface ReadableStreamBYOBReader { +declare interface ReadableStreamBYOBReader { readonly closed: Promise<void>; cancel(reason?: any): Promise<void>; read<V extends ArrayBufferView>( @@ -525,24 +634,30 @@ interface ReadableStreamBYOBReader { /** @category Streams API */ declare var ReadableStreamBYOBReader: { - prototype: ReadableStreamBYOBReader; + readonly prototype: ReadableStreamBYOBReader; new (stream: ReadableStream<Uint8Array>): ReadableStreamBYOBReader; }; /** @category Streams API */ -interface ReadableStreamBYOBRequest { +declare interface ReadableStreamBYOBRequest { readonly view: ArrayBufferView | null; respond(bytesWritten: number): void; respondWithNewView(view: ArrayBufferView): void; } /** @category Streams API */ -interface ReadableByteStreamControllerCallback { +declare var ReadableStreamBYOBRequest: { + readonly prototype: ReadableStreamBYOBRequest; + new (): never; +}; + +/** @category Streams API */ +declare interface ReadableByteStreamControllerCallback { (controller: ReadableByteStreamController): void | PromiseLike<void>; } /** @category Streams API */ -interface UnderlyingByteSource { +declare interface UnderlyingByteSource { autoAllocateChunkSize?: number; cancel?: ReadableStreamErrorCallback; pull?: ReadableByteStreamControllerCallback; @@ -551,7 +666,7 @@ interface UnderlyingByteSource { } /** @category Streams API */ -interface UnderlyingSink<W = any> { +declare interface UnderlyingSink<W = any> { abort?: WritableStreamErrorCallback; close?: WritableStreamDefaultControllerCloseCallback; start?: WritableStreamDefaultControllerStartCallback; @@ -560,7 +675,7 @@ interface UnderlyingSink<W = any> { } /** @category Streams API */ -interface UnderlyingSource<R = any> { +declare interface UnderlyingSource<R = any> { cancel?: ReadableStreamErrorCallback; pull?: ReadableStreamDefaultControllerCallback<R>; start?: ReadableStreamDefaultControllerCallback<R>; @@ -568,17 +683,17 @@ interface UnderlyingSource<R = any> { } /** @category Streams API */ -interface ReadableStreamErrorCallback { +declare interface ReadableStreamErrorCallback { (reason: any): void | PromiseLike<void>; } /** @category Streams API */ -interface ReadableStreamDefaultControllerCallback<R> { +declare interface ReadableStreamDefaultControllerCallback<R> { (controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>; } /** @category Streams API */ -interface ReadableStreamDefaultController<R = any> { +declare interface ReadableStreamDefaultController<R = any> { readonly desiredSize: number | null; close(): void; enqueue(chunk: R): void; @@ -587,12 +702,12 @@ interface ReadableStreamDefaultController<R = any> { /** @category Streams API */ declare var ReadableStreamDefaultController: { - prototype: ReadableStreamDefaultController; - new (): ReadableStreamDefaultController; + readonly prototype: ReadableStreamDefaultController; + new (): never; }; /** @category Streams API */ -interface ReadableByteStreamController { +declare interface ReadableByteStreamController { readonly byobRequest: ReadableStreamBYOBRequest | null; readonly desiredSize: number | null; close(): void; @@ -602,12 +717,12 @@ interface ReadableByteStreamController { /** @category Streams API */ declare var ReadableByteStreamController: { - prototype: ReadableByteStreamController; - new (): ReadableByteStreamController; + readonly prototype: ReadableByteStreamController; + new (): never; }; /** @category Streams API */ -interface PipeOptions { +declare interface PipeOptions { preventAbort?: boolean; preventCancel?: boolean; preventClose?: boolean; @@ -615,12 +730,12 @@ interface PipeOptions { } /** @category Streams API */ -interface QueuingStrategySizeCallback<T = any> { +declare interface QueuingStrategySizeCallback<T = any> { (chunk: T): number; } /** @category Streams API */ -interface QueuingStrategy<T = any> { +declare interface QueuingStrategy<T = any> { highWaterMark?: number; size?: QueuingStrategySizeCallback<T>; } @@ -630,26 +745,27 @@ interface QueuingStrategy<T = any> { * * @category Streams API */ -interface CountQueuingStrategy extends QueuingStrategy { +declare interface CountQueuingStrategy extends QueuingStrategy { highWaterMark: number; size(chunk: any): 1; } /** @category Streams API */ declare var CountQueuingStrategy: { - prototype: CountQueuingStrategy; + readonly prototype: CountQueuingStrategy; new (options: { highWaterMark: number }): CountQueuingStrategy; }; /** @category Streams API */ -interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> { +declare interface ByteLengthQueuingStrategy + extends QueuingStrategy<ArrayBufferView> { highWaterMark: number; size(chunk: ArrayBufferView): number; } /** @category Streams API */ declare var ByteLengthQueuingStrategy: { - prototype: ByteLengthQueuingStrategy; + readonly prototype: ByteLengthQueuingStrategy; new (options: { highWaterMark: number }): ByteLengthQueuingStrategy; }; @@ -659,7 +775,7 @@ declare var ByteLengthQueuingStrategy: { * * @category Streams API */ -interface ReadableStream<R = any> { +declare interface ReadableStream<R = any> { readonly locked: boolean; cancel(reason?: any): Promise<void>; getReader(options: { mode: "byob" }): ReadableStreamBYOBReader; @@ -670,6 +786,9 @@ interface ReadableStream<R = any> { }, options?: PipeOptions): ReadableStream<T>; pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>; tee(): [ReadableStream<R>, ReadableStream<R>]; + values(options?: { + preventCancel?: boolean; + }): AsyncIterableIterator<R>; [Symbol.asyncIterator](options?: { preventCancel?: boolean; }): AsyncIterableIterator<R>; @@ -677,7 +796,7 @@ interface ReadableStream<R = any> { /** @category Streams API */ declare var ReadableStream: { - prototype: ReadableStream; + readonly prototype: ReadableStream; new ( underlyingSource: UnderlyingByteSource, strategy?: { highWaterMark?: number; size?: undefined }, @@ -686,20 +805,23 @@ declare var ReadableStream: { underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>, ): ReadableStream<R>; + from<R>( + asyncIterable: AsyncIterable<R> | Iterable<R | PromiseLike<R>>, + ): ReadableStream<R>; }; /** @category Streams API */ -interface WritableStreamDefaultControllerCloseCallback { +declare interface WritableStreamDefaultControllerCloseCallback { (): void | PromiseLike<void>; } /** @category Streams API */ -interface WritableStreamDefaultControllerStartCallback { +declare interface WritableStreamDefaultControllerStartCallback { (controller: WritableStreamDefaultController): void | PromiseLike<void>; } /** @category Streams API */ -interface WritableStreamDefaultControllerWriteCallback<W> { +declare interface WritableStreamDefaultControllerWriteCallback<W> { (chunk: W, controller: WritableStreamDefaultController): | void | PromiseLike< @@ -708,7 +830,7 @@ interface WritableStreamDefaultControllerWriteCallback<W> { } /** @category Streams API */ -interface WritableStreamErrorCallback { +declare interface WritableStreamErrorCallback { (reason: any): void | PromiseLike<void>; } @@ -718,7 +840,7 @@ interface WritableStreamErrorCallback { * * @category Streams API */ -interface WritableStream<W = any> { +declare interface WritableStream<W = any> { readonly locked: boolean; abort(reason?: any): Promise<void>; close(): Promise<void>; @@ -727,7 +849,7 @@ interface WritableStream<W = any> { /** @category Streams API */ declare var WritableStream: { - prototype: WritableStream; + readonly prototype: WritableStream; new <W = any>( underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>, @@ -741,13 +863,16 @@ declare var WritableStream: { * * @category Streams API */ -interface WritableStreamDefaultController { +declare interface WritableStreamDefaultController { signal: AbortSignal; error(error?: any): void; } /** @category Streams API */ -declare var WritableStreamDefaultController: WritableStreamDefaultController; +declare var WritableStreamDefaultController: { + readonly prototype: WritableStreamDefaultController; + new (): never; +}; /** This Streams API interface is the object returned by * WritableStream.getWriter() and once created locks the < writer to the @@ -756,7 +881,7 @@ declare var WritableStreamDefaultController: WritableStreamDefaultController; * * @category Streams API */ -interface WritableStreamDefaultWriter<W = any> { +declare interface WritableStreamDefaultWriter<W = any> { readonly closed: Promise<void>; readonly desiredSize: number | null; readonly ready: Promise<void>; @@ -768,19 +893,19 @@ interface WritableStreamDefaultWriter<W = any> { /** @category Streams API */ declare var WritableStreamDefaultWriter: { - prototype: WritableStreamDefaultWriter; - new (): WritableStreamDefaultWriter; + readonly prototype: WritableStreamDefaultWriter; + new <W>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>; }; /** @category Streams API */ -interface TransformStream<I = any, O = any> { +declare interface TransformStream<I = any, O = any> { readonly readable: ReadableStream<O>; readonly writable: WritableStream<I>; } /** @category Streams API */ declare var TransformStream: { - prototype: TransformStream; + readonly prototype: TransformStream; new <I = any, O = any>( transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, @@ -789,7 +914,7 @@ declare var TransformStream: { }; /** @category Streams API */ -interface TransformStreamDefaultController<O = any> { +declare interface TransformStreamDefaultController<O = any> { readonly desiredSize: number | null; enqueue(chunk: O): void; error(reason?: any): void; @@ -797,10 +922,13 @@ interface TransformStreamDefaultController<O = any> { } /** @category Streams API */ -declare var TransformStreamDefaultController: TransformStreamDefaultController; +declare var TransformStreamDefaultController: { + readonly prototype: TransformStreamDefaultController; + new (): never; +}; /** @category Streams API */ -interface Transformer<I = any, O = any> { +declare interface Transformer<I = any, O = any> { flush?: TransformStreamDefaultControllerCallback<O>; readableType?: undefined; start?: TransformStreamDefaultControllerCallback<O>; @@ -809,44 +937,54 @@ interface Transformer<I = any, O = any> { } /** @category Streams API */ -interface TransformStreamDefaultControllerCallback<O> { +declare interface TransformStreamDefaultControllerCallback<O> { (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>; } /** @category Streams API */ -interface TransformStreamDefaultControllerTransformCallback<I, O> { +declare interface TransformStreamDefaultControllerTransformCallback<I, O> { ( chunk: I, controller: TransformStreamDefaultController<O>, ): void | PromiseLike<void>; } -/** @category Streams API */ -interface MessageEventInit<T = any> extends EventInit { +/** @category DOM APIs */ +declare interface MessageEventInit<T = any> extends EventInit { data?: T; origin?: string; lastEventId?: string; } -/** @category Streams API */ -declare class MessageEvent<T = any> extends Event { +/** @category DOM APIs */ +declare interface MessageEvent<T = any> extends Event { /** * Returns the data of the message. */ readonly data: T; /** + * Returns the origin of the message, for server-sent events. + */ + readonly origin: string; + /** * Returns the last event ID string, for server-sent events. */ readonly lastEventId: string; + readonly source: null; /** * Returns transferred ports. */ readonly ports: ReadonlyArray<MessagePort>; - constructor(type: string, eventInitDict?: MessageEventInit); } /** @category DOM APIs */ -type Transferable = ArrayBuffer | MessagePort; +declare var MessageEvent: { + readonly prototype: MessageEvent; + new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>; +}; + +/** @category DOM APIs */ +declare type Transferable = ArrayBuffer | MessagePort; /** * This type has been renamed to StructuredSerializeOptions. Use that type for @@ -855,10 +993,10 @@ type Transferable = ArrayBuffer | MessagePort; * @deprecated use `StructuredSerializeOptions` instead. * @category DOM APIs */ -type PostMessageOptions = StructuredSerializeOptions; +declare type PostMessageOptions = StructuredSerializeOptions; /** @category DOM APIs */ -interface StructuredSerializeOptions { +declare interface StructuredSerializeOptions { transfer?: Transferable[]; } @@ -868,14 +1006,24 @@ interface StructuredSerializeOptions { * * @category DOM APIs */ -declare class MessageChannel { - constructor(); +declare interface MessageChannel { readonly port1: MessagePort; readonly port2: MessagePort; } +/** The MessageChannel interface of the Channel Messaging API allows us to + * create a new message channel and send data through it via its two MessagePort + * properties. + * + * @category DOM APIs + */ +declare var MessageChannel: { + readonly prototype: MessageChannel; + new (): MessageChannel; +}; + /** @category DOM APIs */ -interface MessagePortEventMap { +declare interface MessagePortEventMap { "message": MessageEvent; "messageerror": MessageEvent; } @@ -886,7 +1034,7 @@ interface MessagePortEventMap { * * @category DOM APIs */ -declare class MessagePort extends EventTarget { +declare interface MessagePort extends EventTarget { onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null; onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null; /** @@ -930,6 +1078,17 @@ declare class MessagePort extends EventTarget { ): void; } +/** The MessagePort interface of the Channel Messaging API represents one of the + * two ports of a MessageChannel, allowing messages to be sent from one port and + * listening out for them arriving at the other. + * + * @category DOM APIs + */ +declare var MessagePort: { + readonly prototype: MessagePort; + new (): never; +}; + /** * Creates a deep copy of a given value using the structured clone algorithm. * @@ -974,7 +1133,25 @@ declare function structuredClone( * * @category Compression Streams API */ -declare class CompressionStream { +declare interface CompressionStream { + readonly readable: ReadableStream<Uint8Array>; + readonly writable: WritableStream<Uint8Array>; +} + +/** + * An API for compressing a stream of data. + * + * @example + * ```ts + * await Deno.stdin.readable + * .pipeThrough(new CompressionStream("gzip")) + * .pipeTo(Deno.stdout.writable); + * ``` + * + * @category Compression Streams API + */ +declare var CompressionStream: { + readonly prototype: CompressionStream; /** * Creates a new `CompressionStream` object which compresses a stream of * data. @@ -982,8 +1159,25 @@ declare class CompressionStream { * Throws a `TypeError` if the format passed to the constructor is not * supported. */ - constructor(format: string); + new (format: string): CompressionStream; +}; +/** + * An API for decompressing a stream of data. + * + * @example + * ```ts + * const input = await Deno.open("./file.txt.gz"); + * const output = await Deno.create("./file.txt"); + * + * await input.readable + * .pipeThrough(new DecompressionStream("gzip")) + * .pipeTo(output.writable); + * ``` + * + * @category Compression Streams API + */ +declare interface DecompressionStream { readonly readable: ReadableStream<Uint8Array>; readonly writable: WritableStream<Uint8Array>; } @@ -1003,7 +1197,8 @@ declare class CompressionStream { * * @category Compression Streams API */ -declare class DecompressionStream { +declare var DecompressionStream: { + readonly prototype: DecompressionStream; /** * Creates a new `DecompressionStream` object which decompresses a stream of * data. @@ -1011,11 +1206,8 @@ declare class DecompressionStream { * Throws a `TypeError` if the format passed to the constructor is not * supported. */ - constructor(format: string); - - readonly readable: ReadableStream<Uint8Array>; - readonly writable: WritableStream<Uint8Array>; -} + new (format: string): DecompressionStream; +}; /** Dispatch an uncaught exception. Similar to a synchronous version of: * ```ts |