workers: proper TS libs, more spec-compliant APIs (#3812)

* 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

cli/js/lib.deno.window.d.ts

@@ -0,0 +1,214 @@
+// 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 */