mirror of
https://github.com/denoland/deno.git
synced 2024-11-15 16:43:44 -05:00
adc2f08c17
This commit adds new option to "Worker" Web API that allows to configure permissions. New "Worker.deno.permissions" option can be used to define limited permissions to the worker thread by either: - inherit set of parent thread permissions - use limited subset of parent thread permissions - revoke all permissions (full sandbox) In order to achieve this functionality "CliModuleLoader" was modified to accept "initial permissions", which are used for top module loading (ie. uses parent thread permission set to load top level module of a worker).
887 lines
28 KiB
TypeScript
Vendored
887 lines
28 KiB
TypeScript
Vendored
// Copyright 2018-2020 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.web" />
|
||
/// <reference lib="deno.fetch" />
|
||
/// <reference lib="deno.websocket" />
|
||
|
||
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;
|
||
|
||
declare var crypto: Crypto;
|
||
|
||
/** 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 interface Console {
|
||
assert(condition?: boolean, ...data: any[]): void;
|
||
clear(): void;
|
||
count(label?: string): void;
|
||
countReset(label?: string): void;
|
||
debug(...data: any[]): void;
|
||
dir(item?: any, options?: any): void;
|
||
dirxml(...data: any[]): void;
|
||
error(...data: any[]): void;
|
||
group(...data: any[]): void;
|
||
groupCollapsed(...data: any[]): void;
|
||
groupEnd(): void;
|
||
info(...data: any[]): void;
|
||
log(...data: any[]): void;
|
||
table(tabularData?: any, properties?: string[]): void;
|
||
time(label?: string): void;
|
||
timeEnd(label?: string): void;
|
||
timeLog(label?: string, ...data: any[]): void;
|
||
timeStamp(label?: string): void;
|
||
trace(...data: any[]): void;
|
||
warn(...data: any[]): void;
|
||
}
|
||
|
||
declare var console: Console;
|
||
|
||
declare interface Crypto {
|
||
readonly subtle: null;
|
||
getRandomValues<
|
||
T extends
|
||
| Int8Array
|
||
| Int16Array
|
||
| Int32Array
|
||
| Uint8Array
|
||
| Uint16Array
|
||
| Uint32Array
|
||
| Uint8ClampedArray
|
||
| Float32Array
|
||
| Float64Array
|
||
| DataView
|
||
| null,
|
||
>(
|
||
array: T,
|
||
): T;
|
||
}
|
||
|
||
declare class URLSearchParams {
|
||
constructor(
|
||
init?: string[][] | Record<string, string> | string | URLSearchParams,
|
||
);
|
||
static toString(): string;
|
||
|
||
/** Appends a specified key/value pair as a new search parameter.
|
||
*
|
||
* ```ts
|
||
* let searchParams = new URLSearchParams();
|
||
* searchParams.append('name', 'first');
|
||
* searchParams.append('name', 'second');
|
||
* ```
|
||
*/
|
||
append(name: string, value: string): void;
|
||
|
||
/** Deletes the given search parameter and its associated value,
|
||
* from the list of all search parameters.
|
||
*
|
||
* ```ts
|
||
* let searchParams = new URLSearchParams([['name', 'value']]);
|
||
* searchParams.delete('name');
|
||
* ```
|
||
*/
|
||
delete(name: string): void;
|
||
|
||
/** Returns all the values associated with a given search parameter
|
||
* as an array.
|
||
*
|
||
* ```ts
|
||
* searchParams.getAll('name');
|
||
* ```
|
||
*/
|
||
getAll(name: string): string[];
|
||
|
||
/** Returns the first value associated to the given search parameter.
|
||
*
|
||
* ```ts
|
||
* searchParams.get('name');
|
||
* ```
|
||
*/
|
||
get(name: string): string | null;
|
||
|
||
/** Returns a Boolean that indicates whether a parameter with the
|
||
* specified name exists.
|
||
*
|
||
* ```ts
|
||
* searchParams.has('name');
|
||
* ```
|
||
*/
|
||
has(name: string): boolean;
|
||
|
||
/** Sets the value associated with a given search parameter to the
|
||
* given value. If there were several matching values, this method
|
||
* deletes the others. If the search parameter doesn't exist, this
|
||
* method creates it.
|
||
*
|
||
* ```ts
|
||
* searchParams.set('name', 'value');
|
||
* ```
|
||
*/
|
||
set(name: string, value: string): void;
|
||
|
||
/** Sort all key/value pairs contained in this object in place and
|
||
* return undefined. The sort order is according to Unicode code
|
||
* points of the keys.
|
||
*
|
||
* ```ts
|
||
* searchParams.sort();
|
||
* ```
|
||
*/
|
||
sort(): void;
|
||
|
||
/** Calls a function for each element contained in this object in
|
||
* place and return undefined. Optionally accepts an object to use
|
||
* as this when executing callback as second argument.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* params.forEach((value, key, parent) => {
|
||
* console.log(value, key, parent);
|
||
* });
|
||
* ```
|
||
*
|
||
*/
|
||
forEach(
|
||
callbackfn: (value: string, key: string, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
|
||
/** Returns an iterator allowing to go through all keys contained
|
||
* in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const key of params.keys()) {
|
||
* console.log(key);
|
||
* }
|
||
* ```
|
||
*/
|
||
keys(): IterableIterator<string>;
|
||
|
||
/** Returns an iterator allowing to go through all values contained
|
||
* in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const value of params.values()) {
|
||
* console.log(value);
|
||
* }
|
||
* ```
|
||
*/
|
||
values(): IterableIterator<string>;
|
||
|
||
/** Returns an iterator allowing to go through all key/value
|
||
* pairs contained in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const [key, value] of params.entries()) {
|
||
* console.log(key, value);
|
||
* }
|
||
* ```
|
||
*/
|
||
entries(): IterableIterator<[string, string]>;
|
||
|
||
/** Returns an iterator allowing to go through all key/value
|
||
* pairs contained in this object.
|
||
*
|
||
* ```ts
|
||
* const params = new URLSearchParams([["a", "b"], ["c", "d"]]);
|
||
* for (const [key, value] of params) {
|
||
* console.log(key, value);
|
||
* }
|
||
* ```
|
||
*/
|
||
[Symbol.iterator](): IterableIterator<[string, string]>;
|
||
|
||
/** Returns a query string suitable for use in a URL.
|
||
*
|
||
* ```ts
|
||
* searchParams.toString();
|
||
* ```
|
||
*/
|
||
toString(): string;
|
||
}
|
||
|
||
/** The URL interface represents an object providing static methods used for creating object URLs. */
|
||
declare class URL {
|
||
constructor(url: string, base?: string | URL);
|
||
createObjectURL(object: any): string;
|
||
revokeObjectURL(url: string): void;
|
||
|
||
hash: string;
|
||
host: string;
|
||
hostname: string;
|
||
href: string;
|
||
toString(): string;
|
||
readonly origin: string;
|
||
password: string;
|
||
pathname: string;
|
||
port: string;
|
||
protocol: string;
|
||
search: string;
|
||
readonly searchParams: URLSearchParams;
|
||
username: string;
|
||
toJSON(): string;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
declare class Worker extends EventTarget {
|
||
onerror?: (e: ErrorEvent) => void;
|
||
onmessage?: (e: MessageEvent) => void;
|
||
onmessageerror?: (e: MessageEvent) => void;
|
||
constructor(
|
||
specifier: string,
|
||
options?: {
|
||
type?: "classic" | "module";
|
||
name?: string;
|
||
/** UNSTABLE: New API.
|
||
*
|
||
* Set deno.namespace to `true` to make `Deno` namespace and all of its methods
|
||
* available to worker thread. The namespace is disabled by default.
|
||
*
|
||
* Configure deno.permissions options to change the level of access the worker will
|
||
* have. By default it will inherit the permissions of its parent thread. The permissions
|
||
* of a worker can't be extended beyond its parent's permissions reach.
|
||
* - "inherit" will take the permissions of the thread the worker is created in
|
||
* - You can disable/enable permissions all together by passing a boolean
|
||
* - You can provide a list of routes relative to the file the worker
|
||
* is created in to limit the access of the worker (read/write permissions only)
|
||
*
|
||
* Example:
|
||
*
|
||
* ```ts
|
||
* // mod.ts
|
||
* const worker = new Worker(
|
||
* new URL("deno_worker.ts", import.meta.url).href, {
|
||
* type: "module",
|
||
* deno: {
|
||
* namespace: true,
|
||
* permissions: {
|
||
* read: true,
|
||
* },
|
||
* },
|
||
* }
|
||
* );
|
||
* worker.postMessage({ cmd: "readFile", fileName: "./log.txt" });
|
||
*
|
||
* // deno_worker.ts
|
||
*
|
||
*
|
||
* self.onmessage = async function (e) {
|
||
* const { cmd, fileName } = e.data;
|
||
* if (cmd !== "readFile") {
|
||
* throw new Error("Invalid command");
|
||
* }
|
||
* const buf = await Deno.readFile(fileName);
|
||
* const fileContents = new TextDecoder().decode(buf);
|
||
* console.log(fileContents);
|
||
* }
|
||
* ```
|
||
*
|
||
* // log.txt
|
||
* hello world
|
||
* hello world 2
|
||
*
|
||
* // run program
|
||
* $ deno run --allow-read mod.ts
|
||
* hello world
|
||
* hello world2
|
||
*
|
||
*/
|
||
// TODO(Soremwar)
|
||
// `deno: true` is kept for backwards compatibility with the previous worker
|
||
// options implementation. Remove for 2.0
|
||
deno?: true | {
|
||
namespace?: boolean;
|
||
/** Set to false to disable all the permissions in the worker */
|
||
permissions?: "inherit" | false | {
|
||
env?: "inherit" | boolean;
|
||
hrtime?: "inherit" | boolean;
|
||
/**
|
||
* The format of the net access list must be `hostname[:port]`
|
||
* in order to be resolved
|
||
*
|
||
* ```
|
||
* net: ["https://deno.land", "localhost:8080"],
|
||
* ```
|
||
* */
|
||
net?: "inherit" | boolean | string[];
|
||
plugin?: "inherit" | boolean;
|
||
read?: "inherit" | boolean | Array<string | URL>;
|
||
run?: "inherit" | boolean;
|
||
write?: "inherit" | boolean | Array<string | URL>;
|
||
};
|
||
};
|
||
},
|
||
);
|
||
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.
|
||
}
|