diff options
Diffstat (limited to 'cli/tsc/dts/lib.deno.shared_globals.d.ts')
| -rw-r--r-- | cli/tsc/dts/lib.deno.shared_globals.d.ts | 684 |
1 files changed, 684 insertions, 0 deletions
diff --git a/cli/tsc/dts/lib.deno.shared_globals.d.ts b/cli/tsc/dts/lib.deno.shared_globals.d.ts new file mode 100644 index 000000000..5b30c0a87 --- /dev/null +++ b/cli/tsc/dts/lib.deno.shared_globals.d.ts @@ -0,0 +1,684 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. + +// Documentation partially adapted from [MDN](https://developer.mozilla.org/), +// by Mozilla Contributors, which is licensed under CC-BY-SA 2.5. + +/// <reference no-default-lib="true" /> +/// <reference lib="esnext" /> +/// <reference lib="deno.console" /> +/// <reference lib="deno.url" /> +/// <reference lib="deno.web" /> +/// <reference lib="deno.fetch" /> +/// <reference lib="deno.websocket" /> +/// <reference lib="deno.crypto" /> +/// <reference lib="deno.broadcast_channel" /> + +/** @category WebAssembly */ +declare namespace WebAssembly { + /** + * The `WebAssembly.CompileError` object indicates an error during WebAssembly decoding or validation. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError) + * + * @category WebAssembly + */ + export class CompileError extends Error { + /** Creates a new `WebAssembly.CompileError` object. */ + constructor(message?: string, options?: ErrorOptions); + } + + /** + * A `WebAssembly.Global` object represents a global variable instance, accessible from + * both JavaScript and importable/exportable across one or more `WebAssembly.Module` + * instances. This allows dynamic linking of multiple modules. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global) + * + * @category WebAssembly + */ + export class Global { + /** Creates a new `Global` object. */ + constructor(descriptor: GlobalDescriptor, v?: any); + + /** + * The value contained inside the global variable — this can be used to directly set + * and get the global's value. + */ + value: any; + + /** Old-style method that returns the value contained inside the global variable. */ + valueOf(): any; + } + + /** + * A `WebAssembly.Instance` object is a stateful, executable instance of a `WebAssembly.Module`. + * Instance objects contain all the Exported WebAssembly functions that allow calling into + * WebAssembly code from JavaScript. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance) + * + * @category WebAssembly + */ + export class Instance { + /** Creates a new Instance object. */ + constructor(module: Module, importObject?: Imports); + + /** + * Returns an object containing as its members all the functions exported from the + * WebAssembly module instance, to allow them to be accessed and used by JavaScript. + * Read-only. + */ + readonly exports: Exports; + } + + /** + * The `WebAssembly.LinkError` object indicates an error during module instantiation + * (besides traps from the start function). + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError) + * + * @category WebAssembly + */ + export class LinkError extends Error { + /** Creates a new WebAssembly.LinkError object. */ + constructor(message?: string, options?: ErrorOptions); + } + + /** + * The `WebAssembly.Memory` object is a resizable `ArrayBuffer` or `SharedArrayBuffer` that + * holds the raw bytes of memory accessed by a WebAssembly Instance. + * + * A memory created by JavaScript or in WebAssembly code will be accessible and mutable + * from both JavaScript and WebAssembly. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) + * + * @category WebAssembly + */ + export class Memory { + /** Creates a new `Memory` object. */ + constructor(descriptor: MemoryDescriptor); + + /** An accessor property that returns the buffer contained in the memory. */ + readonly buffer: ArrayBuffer | SharedArrayBuffer; + + /** + * Increases the size of the memory instance by a specified number of WebAssembly + * pages (each one is 64KB in size). + */ + grow(delta: number): number; + } + + /** + * A `WebAssembly.Module` object contains stateless WebAssembly code that has already been compiled + * by the browser — this can be efficiently shared with Workers, and instantiated multiple times. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Module) + * + * @category WebAssembly + */ + export class Module { + /** Creates a new `Module` object. */ + constructor(bytes: BufferSource); + + /** + * Given a `Module` and string, returns a copy of the contents of all custom sections in the + * module with the given string name. + */ + static customSections( + moduleObject: Module, + sectionName: string, + ): ArrayBuffer[]; + + /** Given a `Module`, returns an array containing descriptions of all the declared exports. */ + static exports(moduleObject: Module): ModuleExportDescriptor[]; + + /** Given a `Module`, returns an array containing descriptions of all the declared imports. */ + static imports(moduleObject: Module): ModuleImportDescriptor[]; + } + + /** + * The `WebAssembly.RuntimeError` object is the error type that is thrown whenever WebAssembly + * specifies a trap. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/RuntimeError) + * + * @category WebAssembly + */ + export class RuntimeError extends Error { + /** Creates a new `WebAssembly.RuntimeError` object. */ + constructor(message?: string, options?: ErrorOptions); + } + + /** + * The `WebAssembly.Table()` object is a JavaScript wrapper object — an array-like structure + * representing a WebAssembly Table, which stores function references. A table created by + * JavaScript or in WebAssembly code will be accessible and mutable from both JavaScript + * and WebAssembly. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Table) + * + * @category WebAssembly + */ + export class Table { + /** Creates a new `Table` object. */ + constructor(descriptor: TableDescriptor); + + /** Returns the length of the table, i.e. the number of elements. */ + readonly length: number; + + /** Accessor function — gets the element stored at a given index. */ + get(index: number): Function | null; + + /** Increases the size of the `Table` instance by a specified number of elements. */ + grow(delta: number): number; + + /** Sets an element stored at a given index to a given value. */ + set(index: number, value: Function | null): void; + } + + /** The `GlobalDescriptor` describes the options you can pass to + * `new WebAssembly.Global()`. + * + * @category WebAssembly + */ + export interface GlobalDescriptor { + mutable?: boolean; + value: ValueType; + } + + /** The `MemoryDescriptor` describes the options you can pass to + * `new WebAssembly.Memory()`. + * + * @category WebAssembly + */ + export interface MemoryDescriptor { + initial: number; + maximum?: number; + shared?: boolean; + } + + /** A `ModuleExportDescriptor` is the description of a declared export in a + * `WebAssembly.Module`. + * + * @category WebAssembly + */ + export interface ModuleExportDescriptor { + kind: ImportExportKind; + name: string; + } + + /** A `ModuleImportDescriptor` is the description of a declared import in a + * `WebAssembly.Module`. + * + * @category WebAssembly + */ + export interface ModuleImportDescriptor { + kind: ImportExportKind; + module: string; + name: string; + } + + /** The `TableDescriptor` describes the options you can pass to + * `new WebAssembly.Table()`. + * + * @category WebAssembly + */ + export interface TableDescriptor { + element: TableKind; + initial: number; + maximum?: number; + } + + /** The value returned from `WebAssembly.instantiate`. + * + * @category WebAssembly + */ + export interface WebAssemblyInstantiatedSource { + /* A `WebAssembly.Instance` object that contains all the exported WebAssembly functions. */ + instance: Instance; + + /** + * A `WebAssembly.Module` object representing the compiled WebAssembly module. + * This `Module` can be instantiated again, or shared via postMessage(). + */ + module: Module; + } + + /** @category WebAssembly */ + export type ImportExportKind = "function" | "global" | "memory" | "table"; + /** @category WebAssembly */ + export type TableKind = "anyfunc"; + /** @category WebAssembly */ + export type ValueType = "f32" | "f64" | "i32" | "i64"; + /** @category WebAssembly */ + export type ExportValue = Function | Global | Memory | Table; + /** @category WebAssembly */ + export type Exports = Record<string, ExportValue>; + /** @category WebAssembly */ + export type ImportValue = ExportValue | number; + /** @category WebAssembly */ + export type ModuleImports = Record<string, ImportValue>; + /** @category WebAssembly */ + export type Imports = Record<string, ModuleImports>; + + /** + * The `WebAssembly.compile()` function compiles WebAssembly binary code into a + * `WebAssembly.Module` object. This function is useful if it is necessary to compile + * a module before it can be instantiated (otherwise, the `WebAssembly.instantiate()` + * function should be used). + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compile) + * + * @category WebAssembly + */ + export function compile(bytes: BufferSource): Promise<Module>; + + /** + * The `WebAssembly.compileStreaming()` function compiles a `WebAssembly.Module` + * directly from a streamed underlying source. This function is useful if it is + * necessary to a compile a module before it can be instantiated (otherwise, the + * `WebAssembly.instantiateStreaming()` function should be used). + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/compileStreaming) + * + * @category WebAssembly + */ + export function compileStreaming( + source: Response | Promise<Response>, + ): Promise<Module>; + + /** + * The WebAssembly.instantiate() function allows you to compile and instantiate + * WebAssembly code. + * + * This overload takes the WebAssembly binary code, in the form of a typed + * array or ArrayBuffer, and performs both compilation and instantiation in one step. + * The returned Promise resolves to both a compiled WebAssembly.Module and its first + * WebAssembly.Instance. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate) + * + * @category WebAssembly + */ + export function instantiate( + bytes: BufferSource, + importObject?: Imports, + ): Promise<WebAssemblyInstantiatedSource>; + + /** + * The WebAssembly.instantiate() function allows you to compile and instantiate + * WebAssembly code. + * + * This overload takes an already-compiled WebAssembly.Module and returns + * a Promise that resolves to an Instance of that Module. This overload is useful + * if the Module has already been compiled. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiate) + * + * @category WebAssembly + */ + export function instantiate( + moduleObject: Module, + importObject?: Imports, + ): Promise<Instance>; + + /** + * The `WebAssembly.instantiateStreaming()` function compiles and instantiates a + * WebAssembly module directly from a streamed underlying source. This is the most + * efficient, optimized way to load wasm code. + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming) + * + * @category WebAssembly + */ + export function instantiateStreaming( + response: Response | PromiseLike<Response>, + importObject?: Imports, + ): Promise<WebAssemblyInstantiatedSource>; + + /** + * The `WebAssembly.validate()` function validates a given typed array of + * WebAssembly binary code, returning whether the bytes form a valid wasm + * module (`true`) or not (`false`). + * + * [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/validate) + * + * @category WebAssembly + */ + export function validate(bytes: BufferSource): boolean; +} + +/** Sets a timer which executes a function once after the timer expires. Returns + * an id which may be used to cancel the timeout. + * + * ```ts + * setTimeout(() => { console.log('hello'); }, 500); + * ``` + * + * @category Timers + */ +declare function setTimeout( + /** callback function to execute when timer expires */ + cb: (...args: any[]) => void, + /** delay in ms */ + delay?: number, + /** arguments passed to callback function */ + ...args: any[] +): number; + +/** Repeatedly calls a function , with a fixed time delay between each call. + * + * ```ts + * // Outputs 'hello' to the console every 500ms + * setInterval(() => { console.log('hello'); }, 500); + * ``` + * + * @category Timers + */ +declare function setInterval( + /** callback function to execute when timer expires */ + cb: (...args: any[]) => void, + /** delay in ms */ + delay?: number, + /** arguments passed to callback function */ + ...args: any[] +): number; + +/** Cancels a timed, repeating action which was previously started by a call + * to `setInterval()` + * + * ```ts + * const id = setInterval(() => {console.log('hello');}, 500); + * // ... + * clearInterval(id); + * ``` + * + * @category Timers + */ +declare function clearInterval(id?: number): void; + +/** Cancels a scheduled action initiated by `setTimeout()` + * + * ```ts + * const id = setTimeout(() => {console.log('hello');}, 500); + * // ... + * clearTimeout(id); + * ``` + * + * @category Timers + */ +declare function clearTimeout(id?: number): void; + +/** @category Scheduling */ +interface VoidFunction { + (): void; +} + +/** A microtask is a short function which is executed after the function or + * module which created it exits and only if the JavaScript execution stack is + * empty, but before returning control to the event loop being used to drive the + * script's execution environment. This event loop may be either the main event + * loop or the event loop driving a web worker. + * + * ```ts + * queueMicrotask(() => { console.log('This event loop stack is complete'); }); + * ``` + * + * @category Scheduling + */ +declare function queueMicrotask(func: VoidFunction): void; + +/** Dispatches an event in the global scope, synchronously invoking any + * registered event listeners for this event in the appropriate order. Returns + * false if event is cancelable and at least one of the event handlers which + * handled this event called Event.preventDefault(). Otherwise it returns true. + * + * ```ts + * dispatchEvent(new Event('unload')); + * ``` + * + * @category DOM Events + */ +declare function dispatchEvent(event: Event): boolean; + +/** @category DOM APIs */ +interface DOMStringList { + /** Returns the number of strings in strings. */ + readonly length: number; + /** Returns true if strings contains string, and false otherwise. */ + contains(string: string): boolean; + /** Returns the string with index index from strings. */ + item(index: number): string | null; + [index: number]: string; +} + +/** @category Typed Arrays */ +type BufferSource = ArrayBufferView | ArrayBuffer; + +/** @category Console and Debugging */ +declare var console: Console; + +/** @category DOM Events */ +interface ErrorEventInit extends EventInit { + message?: string; + filename?: string; + lineno?: number; + colno?: number; + error?: any; +} + +/** @category DOM Events */ +declare class ErrorEvent extends Event { + readonly message: string; + readonly filename: string; + readonly lineno: number; + readonly colno: number; + readonly error: any; + constructor(type: string, eventInitDict?: ErrorEventInit); +} + +/** @category Observability */ +interface PromiseRejectionEventInit extends EventInit { + promise: Promise<any>; + reason?: any; +} + +/** @category Observability */ +declare class PromiseRejectionEvent extends Event { + readonly promise: Promise<any>; + readonly reason: any; + constructor(type: string, eventInitDict?: PromiseRejectionEventInit); +} + +/** @category Web Workers */ +interface AbstractWorkerEventMap { + "error": ErrorEvent; +} + +/** @category Web Workers */ +interface WorkerEventMap extends AbstractWorkerEventMap { + "message": MessageEvent; + "messageerror": MessageEvent; +} + +/** @category Web Workers */ +interface WorkerOptions { + type?: "classic" | "module"; + name?: string; +} + +/** @category Web Workers */ +declare class Worker extends EventTarget { + onerror?: (e: ErrorEvent) => void; + onmessage?: (e: MessageEvent) => void; + onmessageerror?: (e: MessageEvent) => void; + constructor( + specifier: string | URL, + options?: WorkerOptions, + ); + postMessage(message: any, transfer: Transferable[]): void; + postMessage(message: any, options?: StructuredSerializeOptions): void; + addEventListener<K extends keyof WorkerEventMap>( + type: K, + listener: (this: Worker, ev: WorkerEventMap[K]) => any, + options?: boolean | AddEventListenerOptions, + ): void; + addEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | AddEventListenerOptions, + ): void; + removeEventListener<K extends keyof WorkerEventMap>( + type: K, + listener: (this: Worker, ev: WorkerEventMap[K]) => any, + options?: boolean | EventListenerOptions, + ): void; + removeEventListener( + type: string, + listener: EventListenerOrEventListenerObject, + options?: boolean | EventListenerOptions, + ): void; + terminate(): void; +} + +/** @category Performance */ +declare type PerformanceEntryList = PerformanceEntry[]; + +/** @category Performance */ +declare class Performance extends EventTarget { + /** Returns a timestamp representing the start of the performance measurement. */ + readonly timeOrigin: number; + constructor(); + + /** Removes the stored timestamp with the associated name. */ + clearMarks(markName?: string): void; + + /** Removes stored timestamp with the associated name. */ + clearMeasures(measureName?: string): void; + + getEntries(): PerformanceEntryList; + getEntriesByName(name: string, type?: string): PerformanceEntryList; + getEntriesByType(type: string): PerformanceEntryList; + + /** Stores a timestamp with the associated name (a "mark"). */ + mark(markName: string, options?: PerformanceMarkOptions): PerformanceMark; + + /** Stores the `DOMHighResTimeStamp` duration between two marks along with the + * associated name (a "measure"). */ + measure( + measureName: string, + options?: PerformanceMeasureOptions, + ): PerformanceMeasure; + /** Stores the `DOMHighResTimeStamp` duration between two marks along with the + * associated name (a "measure"). */ + measure( + measureName: string, + startMark?: string, + endMark?: string, + ): PerformanceMeasure; + + /** Returns a current time from Deno's start in milliseconds. + * + * Use the permission flag `--allow-hrtime` return a precise value. + * + * ```ts + * const t = performance.now(); + * console.log(`${t} ms since start!`); + * ``` + * + * @tags allow-hrtime + */ + now(): number; + + /** Returns a JSON representation of the performance object. */ + toJSON(): any; +} + +/** @category Performance */ +declare var performance: Performance; + +/** @category Performance */ +declare interface PerformanceMarkOptions { + /** Metadata to be included in the mark. */ + detail?: any; + + /** Timestamp to be used as the mark time. */ + startTime?: number; +} + +declare interface PerformanceMeasureOptions { + /** Metadata to be included in the measure. */ + detail?: any; + + /** Timestamp to be used as the start time or string to be used as start + * mark. */ + start?: string | number; + + /** Duration between the start and end times. */ + duration?: number; + + /** Timestamp to be used as the end time or string to be used as end mark. */ + end?: string | number; +} + +/** Encapsulates a single performance metric that is part of the performance + * timeline. A performance entry can be directly created by making a performance + * mark or measure (for example by calling the `.mark()` method) at an explicit + * point in an application. + * + * @category Performance + */ +declare class PerformanceEntry { + readonly duration: number; + readonly entryType: string; + readonly name: string; + readonly startTime: number; + toJSON(): any; +} + +/** `PerformanceMark` is an abstract interface for `PerformanceEntry` objects + * with an entryType of `"mark"`. Entries of this type are created by calling + * `performance.mark()` to add a named `DOMHighResTimeStamp` (the mark) to the + * performance timeline. + * + * @category Performance + */ +declare class PerformanceMark extends PerformanceEntry { + readonly detail: any; + readonly entryType: "mark"; + constructor(name: string, options?: PerformanceMarkOptions); +} + +/** `PerformanceMeasure` is an abstract interface for `PerformanceEntry` objects + * with an entryType of `"measure"`. Entries of this type are created by calling + * `performance.measure()` to add a named `DOMHighResTimeStamp` (the measure) + * between two marks to the performance timeline. + * + * @category Performance + */ +declare class PerformanceMeasure extends PerformanceEntry { + readonly detail: any; + readonly entryType: "measure"; +} + +/** @category DOM Events */ +declare interface CustomEventInit<T = any> extends EventInit { + detail?: T; +} + +/** @category DOM Events */ +declare class CustomEvent<T = any> extends Event { + constructor(typeArg: string, eventInitDict?: CustomEventInit<T>); + /** Returns any custom data event was created with. Typically used for + * synthetic events. */ + readonly detail: T; +} + +/** @category DOM APIs */ +interface ErrorConstructor { + /** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */ + captureStackTrace(error: Object, constructor?: Function): void; + // TODO(nayeemrmn): Support `Error.prepareStackTrace()`. We currently use this + // internally in a way that makes it unavailable for users. +} |