1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-24 08:09:08 -05:00
denoland-deno/cli/dts/lib.deno.shared_globals.d.ts
2021-03-12 21:23:59 +01:00

600 lines
20 KiB
TypeScript
Vendored
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Copyright 2018-2021 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" />
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)
*/
export class CompileError extends Error {
/** Creates a new `WebAssembly.CompileError` object. */
constructor();
}
/**
* 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)
*/
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)
*/
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)
*/
export class LinkError extends Error {
/** Creates a new WebAssembly.LinkError object. */
constructor();
}
/**
* 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)
*/
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;
/**
* 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)
*/
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)
*/
export class RuntimeError extends Error {
/** Creates a new `WebAssembly.RuntimeError` object. */
constructor();
}
/**
* 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)
*/
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()`. */
export interface GlobalDescriptor {
mutable?: boolean;
value: ValueType;
}
/** The `MemoryDescriptor` describes the options you can pass to `new WebAssembly.Memory()`. */
export interface MemoryDescriptor {
initial: number;
maximum?: number;
}
/** A `ModuleExportDescriptor` is the description of a declared export in a `WebAssembly.Module`. */
export interface ModuleExportDescriptor {
kind: ImportExportKind;
name: string;
}
/** A `ModuleImportDescriptor` is the description of a declared import in a `WebAssembly.Module`. */
export interface ModuleImportDescriptor {
kind: ImportExportKind;
module: string;
name: string;
}
/** The `TableDescriptor` describes the options you can pass to `new WebAssembly.Table()`. */
export interface TableDescriptor {
element: TableKind;
initial: number;
maximum?: number;
}
/** The value returned from `WebAssembly.instantiate` and `WebAssembly.instantiateStreaming`. */
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;
}
export type ImportExportKind = "function" | "global" | "memory" | "table";
export type TableKind = "anyfunc";
export type ValueType = "f32" | "f64" | "i32" | "i64";
export type ExportValue = Function | Global | Memory | Table;
export type Exports = Record<string, ExportValue>;
export type ImportValue = ExportValue | number;
export type ModuleImports = Record<string, ImportValue>;
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)
*/
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)
*/
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)
*/
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)
*/
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 WebAssembly code.
*
* [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming)
*/
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)
*/
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.
*
* setTimeout(() => { console.log('hello'); }, 500);
*/
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.
*
* // Outputs 'hello' to the console every 500ms
* setInterval(() => { console.log('hello'); }, 500);
*/
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()`
*
* const id = setInterval(() => {console.log('hello');}, 500);
* ...
* clearInterval(id);
*/
declare function clearInterval(id?: number): void;
/** Cancels a scheduled action initiated by `setTimeout()`
*
* const id = setTimeout(() => {console.log('hello');}, 500);
* ...
* clearTimeout(id);
*/
declare function clearTimeout(id?: number): void;
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.
*
* queueMicrotask(() => { console.log('This event loop stack is complete'); });
*/
declare function queueMicrotask(func: VoidFunction): void;
/** Registers an event listener in the global scope, which will be called
* synchronously whenever the event `type` is dispatched.
*
* addEventListener('unload', () => { console.log('All finished!'); });
* ...
* dispatchEvent(new Event('unload'));
*/
declare function addEventListener(
type: string,
callback: EventListenerOrEventListenerObject | null,
options?: boolean | AddEventListenerOptions | undefined,
): 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.
*
* dispatchEvent(new Event('unload'));
*/
declare function dispatchEvent(event: Event): boolean;
/** Remove a previously registered event listener from the global scope
*
* const lstnr = () => { console.log('hello'); };
* addEventListener('load', lstnr);
* removeEventListener('load', lstnr);
*/
declare function removeEventListener(
type: string,
callback: EventListenerOrEventListenerObject | null,
options?: boolean | EventListenerOptions | undefined,
): void;
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;
}
type BufferSource = ArrayBufferView | ArrayBuffer;
declare var console: Console;
interface MessageEventInit<T = any> extends EventInit {
data?: T;
origin?: string;
lastEventId?: string;
}
declare class MessageEvent<T = any> extends Event {
/**
* Returns the data of the message.
*/
readonly data: T;
/**
* Returns the last event ID string, for server-sent events.
*/
readonly lastEventId: string;
constructor(type: string, eventInitDict?: MessageEventInit);
}
interface ErrorEventInit extends EventInit {
message?: string;
filename?: string;
lineno?: number;
colno?: number;
error?: any;
}
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);
}
interface PostMessageOptions {
transfer?: any[];
}
interface AbstractWorkerEventMap {
"error": ErrorEvent;
}
interface WorkerEventMap extends AbstractWorkerEventMap {
"message": MessageEvent;
"messageerror": MessageEvent;
}
interface WorkerOptions {
type?: "classic" | "module";
name?: string;
}
declare class Worker extends EventTarget {
onerror?: (e: ErrorEvent) => void;
onmessage?: (e: MessageEvent) => void;
onmessageerror?: (e: MessageEvent) => void;
constructor(
specifier: string,
options?: WorkerOptions,
);
postMessage(message: any, transfer: ArrayBuffer[]): void;
postMessage(message: any, options?: PostMessageOptions): 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;
}
declare type PerformanceEntryList = PerformanceEntry[];
declare class Performance {
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!`);
* ```
*/
now(): number;
}
declare var performance: 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. */
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. */
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. */
declare class PerformanceMeasure extends PerformanceEntry {
readonly detail: any;
readonly entryType: "measure";
}
declare interface CustomEventInit<T = any> extends EventInit {
detail?: T;
}
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;
}
interface ErrorConstructor {
/** See https://v8.dev/docs/stack-trace-api#stack-trace-collection-for-custom-exceptions. */
// eslint-disable-next-line @typescript-eslint/ban-types
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.
}