mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 23:34:47 -05:00
161adfc51b
* split lib.deno_main.d.ts into: - lib.deno.shared_globals.d.ts - lib.deno.window.d.ts - lib.deno.worker.d.ts * remove no longer used libs: - lib.deno_main.d.ts - lib.deno_worker.d.ts * change module loading to use proper TS library for compilation * align to Worker API spec: - Worker.terminate() - self.close() - self.name
214 lines
6.9 KiB
TypeScript
214 lines
6.9 KiB
TypeScript
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
|
|
|
/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-interface, @typescript-eslint/no-explicit-any */
|
|
|
|
/// <reference no-default-lib="true" />
|
|
/// <reference lib="deno_ns" />
|
|
/// <reference lib="deno_shared_globals" />
|
|
/// <reference lib="esnext" />
|
|
|
|
declare interface Window extends WindowOrWorkerGlobalScope {
|
|
window: Window & WindowOrWorkerGlobalScope & typeof globalThis;
|
|
onload: Function | undefined;
|
|
onunload: Function | undefined;
|
|
crypto: Crypto;
|
|
Deno: typeof Deno;
|
|
}
|
|
|
|
declare const window: Window & WindowOrWorkerGlobalScope & typeof globalThis;
|
|
declare const onload: Function | undefined;
|
|
declare const onunload: Function | undefined;
|
|
declare const crypto: Crypto;
|
|
|
|
declare interface Crypto {
|
|
readonly subtle: null;
|
|
getRandomValues<
|
|
T extends
|
|
| Int8Array
|
|
| Int16Array
|
|
| Int32Array
|
|
| Uint8Array
|
|
| Uint16Array
|
|
| Uint32Array
|
|
| Uint8ClampedArray
|
|
| Float32Array
|
|
| Float64Array
|
|
| DataView
|
|
| null
|
|
>(
|
|
array: T
|
|
): T;
|
|
}
|
|
|
|
// This follows the WebIDL at: https://webassembly.github.io/spec/js-api/
|
|
// and: https://webassembly.github.io/spec/web-api/
|
|
|
|
declare namespace WebAssembly {
|
|
interface WebAssemblyInstantiatedSource {
|
|
module: Module;
|
|
instance: Instance;
|
|
}
|
|
|
|
/** Compiles a `WebAssembly.Module` from WebAssembly binary code. This
|
|
* function is useful if it is necessary to a compile a module before it can
|
|
* be instantiated (otherwise, the `WebAssembly.instantiate()` function
|
|
* should be used). */
|
|
function compile(bufferSource: __domTypes.BufferSource): Promise<Module>;
|
|
|
|
/** 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). */
|
|
function compileStreaming(
|
|
source: Promise<__domTypes.Response>
|
|
): Promise<Module>;
|
|
|
|
/** 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`. */
|
|
function instantiate(
|
|
bufferSource: __domTypes.BufferSource,
|
|
importObject?: object
|
|
): Promise<WebAssemblyInstantiatedSource>;
|
|
|
|
/** 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. */
|
|
function instantiate(
|
|
module: Module,
|
|
importObject?: object
|
|
): Promise<Instance>;
|
|
|
|
/** Compiles and instantiates a WebAssembly module directly from a streamed
|
|
* underlying source. This is the most efficient, optimized way to load wasm
|
|
* code. */
|
|
function instantiateStreaming(
|
|
source: Promise<__domTypes.Response>,
|
|
importObject?: object
|
|
): Promise<WebAssemblyInstantiatedSource>;
|
|
|
|
/** Validates a given typed array of WebAssembly binary code, returning
|
|
* whether the bytes form a valid wasm module (`true`) or not (`false`). */
|
|
function validate(bufferSource: __domTypes.BufferSource): boolean;
|
|
|
|
type ImportExportKind = "function" | "table" | "memory" | "global";
|
|
|
|
interface ModuleExportDescriptor {
|
|
name: string;
|
|
kind: ImportExportKind;
|
|
}
|
|
interface ModuleImportDescriptor {
|
|
module: string;
|
|
name: string;
|
|
kind: ImportExportKind;
|
|
}
|
|
|
|
class Module {
|
|
constructor(bufferSource: __domTypes.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[];
|
|
}
|
|
|
|
class Instance<T extends object = { [key: string]: any }> {
|
|
constructor(module: Module, importObject?: object);
|
|
|
|
/** 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. */
|
|
readonly exports: T;
|
|
}
|
|
|
|
interface MemoryDescriptor {
|
|
initial: number;
|
|
maximum?: number;
|
|
}
|
|
|
|
class Memory {
|
|
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;
|
|
}
|
|
|
|
type TableKind = "anyfunc";
|
|
|
|
interface TableDescriptor {
|
|
element: TableKind;
|
|
initial: number;
|
|
maximum?: number;
|
|
}
|
|
|
|
class Table {
|
|
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): (...args: any[]) => any;
|
|
|
|
/** 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: (...args: any[]) => any): void;
|
|
}
|
|
|
|
type ValueType = "i32" | "i64" | "f32" | "f64";
|
|
|
|
interface GlobalDescriptor {
|
|
value: ValueType;
|
|
mutable?: boolean;
|
|
}
|
|
|
|
/** 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. */
|
|
class Global {
|
|
constructor(descriptor: GlobalDescriptor, value?: any);
|
|
|
|
/** Old-style method that returns the value contained inside the global
|
|
* variable. */
|
|
valueOf(): any;
|
|
|
|
/** The value contained inside the global variable — this can be used to
|
|
* directly set and get the global's value. */
|
|
value: any;
|
|
}
|
|
|
|
/** Indicates an error during WebAssembly decoding or validation */
|
|
class CompileError extends Error {
|
|
constructor(message: string, fileName?: string, lineNumber?: string);
|
|
}
|
|
|
|
/** Indicates an error during module instantiation (besides traps from the
|
|
* start function). */
|
|
class LinkError extends Error {
|
|
constructor(message: string, fileName?: string, lineNumber?: string);
|
|
}
|
|
|
|
/** Is thrown whenever WebAssembly specifies a trap. */
|
|
class RuntimeError extends Error {
|
|
constructor(message: string, fileName?: string, lineNumber?: string);
|
|
}
|
|
}
|
|
/* eslint-enable @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-interface, @typescript-eslint/no-explicit-any */
|