@tothalex/cloud 0.0.40

package/src/dns.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The `dns` module enables name resolution. For example, use it to look up IP
+ * addresses of host names.
+ *
+ * Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the
+ * DNS protocol for lookups. {@link lookup} uses the operating system
+ * facilities to perform name resolution. It may not need to perform any network
+ * communication. To perform name resolution the way other applications on the same
+ * system do, use {@link lookup}.
+ *
+ * ```js
+ * import dns from 'dns';
+ *
+ * dns.lookup('example.org', (err, address, family) => {
+ *   console.log('address: %j family: IPv%s', address, family);
+ * });
+ * // address: "93.184.216.34" family: IPv4
+ * ```
+ *
+ */
+declare module "dns" {
+  export interface LookupOptions {
+    /**
+     * The record family. Must be `4`, `6`, or `0`.
+     * The value 0 indicates that either an IPv4 or IPv6 address is returned.
+     * @default 0
+     */
+    family?: number | undefined;
+  }
+  export interface LookupAddress {
+    /**
+     * A string representation of an IPv4 or IPv6 address.
+     */
+    address: string;
+    /**
+     * `4` or `6`, denoting the family of `address`, or `0` if the address is not an IPv4 or IPv6 address. `0` is a likely indicator of a
+     * bug in the name resolution service used by the operating system.
+     */
+    family: number;
+  }
+  /**
+   * Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or
+   * AAAA (IPv6) record. All `option` properties are optional. If `options` is an
+   * integer, then it must be `4` or `6` – if `options` is `0` or not provided, then
+   * IPv4 and IPv6 addresses are both returned if found.
+   *
+   * On error, `err` is an `Error` object, where `err.code` is the error code.
+   * Keep in mind that `err.code` will be set to `'ENOTFOUND'` not only when
+   * the host name does not exist but also when the lookup fails in other ways
+   * such as no available file descriptors.
+   *
+   * `dns.lookup()` does not necessarily have anything to do with the DNS protocol.
+   * The implementation uses an operating system facility that can associate names
+   * with addresses and vice versa.
+   *
+   * Example usage:
+   *
+   * ```js
+   * import dns from 'dns';
+   * const options = {
+   *   family: 6,
+   * };
+   * dns.lookup('example.com', options, (err, address, family) =>
+   *   console.log('address: %j family: IPv%s', address, family));
+   * // address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6
+   *
+   * ```
+   *
+   */
+  export function lookup(
+    hostname: string,
+    family: number,
+    callback: (
+      err: DOMException | null,
+      address: string,
+      family: number
+    ) => void
+  ): void;
+  export function lookup(
+    hostname: string,
+    options: LookupOptions,
+    callback: (
+      err: DOMException | null,
+      address: string | LookupAddress[],
+      family: number
+    ) => void
+  ): void;
+  export function lookup(
+    hostname: string,
+    callback: (
+      err: DOMException | null,
+      address: string,
+      family: number
+    ) => void
+  ): void;
+}
+declare module "dns" {
+  export * from "dns";
+}

package/src/events.d.ts

@@ -0,0 +1,245 @@
+declare module "events" {
+  type EventMap<T> = Record<keyof T, any[]> | DefaultEventMap;
+  type DefaultEventMap = [never];
+  type AnyRest = [...args: any[]];
+  type Args<K, T> = T extends DefaultEventMap
+    ? AnyRest
+    : K extends keyof T
+      ? T[K]
+      : never;
+  type Key<K, T> = T extends DefaultEventMap ? EventKey : K | keyof T;
+  type Key2<K, T> = T extends DefaultEventMap ? EventKey : K & keyof T;
+  type Listener<K, T, F> = T extends DefaultEventMap
+    ? F
+    : K extends keyof T
+      ? T[K] extends unknown[]
+        ? (...args: T[K]) => void
+        : never
+      : never;
+  type Listener1<K, T> = Listener<K, T, (...args: any[]) => void>;
+
+  export class EventEmitter<T extends EventMap<T> = DefaultEventMap> {
+    constructor();
+
+    /**
+     * Alias for `emitter.on(eventName, listener)`.
+     */
+    addListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+
+    /**
+     * Adds the `listener` function to the end of the listeners array for the event
+     * named `eventName`. No checks are made to see if the `listener` has already
+     * been added. Multiple calls passing the same combination of `eventName` and
+     * `listener` will result in the `listener` being added, and called, multiple times.
+     *
+     * ```js
+     * server.on('connection', (stream) => {
+     *   console.log('someone connected!');
+     * });
+     * ```
+     *
+     * Returns a reference to the `EventEmitter`, so that calls can be chained.
+     *
+     * By default, event listeners are invoked in the order they are added. The `emitter.prependListener()` method can be used as an alternative to add the
+     * event listener to the beginning of the listeners array.
+     *
+     * ```js
+     * import { EventEmitter } from 'events';
+     * const myEE = new EventEmitter();
+     * myEE.on('foo', () => console.log('a'));
+     * myEE.prependListener('foo', () => console.log('b'));
+     * myEE.emit('foo');
+     * // Prints:
+     * //   b
+     * //   a
+     * ```
+     * @param eventName The name of the event.
+     * @param listener The callback function
+     */
+    on<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+
+    /**
+     * Adds a **one-time** `listener` function for the event named `eventName`. The
+     * next time `eventName` is triggered, this listener is removed and then invoked.
+     *
+     * Returns a reference to the `EventEmitter`, so that calls can be chained.
+     *
+     * By default, event listeners are invoked in the order they are added. The `emitter.prependOnceListener()` method can be used as an alternative to add the
+     * event listener to the beginning of the listeners array.
+     *
+     * ```js
+     * import { EventEmitter } from 'events';
+     * const myEE = new EventEmitter();
+     * myEE.once('foo', () => console.log('a'));
+     * myEE.prependOnceListener('foo', () => console.log('b'));
+     * myEE.emit('foo');
+     * // Prints:
+     * //   b
+     * //   a
+     * ```
+     * @since v0.3.0
+     * @param eventName The name of the event.
+     * @param listener The callback function
+     */
+    once<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+
+    /**
+     * Removes the specified `listener` from the listener array for the event named `eventName`.
+     *
+     * `removeListener()` will remove, at most, one instance of a listener from the
+     * listener array. If any single listener has been added multiple times to the
+     * listener array for the specified `eventName`, then `removeListener()` must be
+     * called multiple times to remove each instance.
+     *
+     * Once an event is emitted, all listeners attached to it at the time of emitting are called in order.
+     * This implies that any `removeListener()` calls _after_ emitting and _before_ the last listener finishes execution
+     * will not remove them from `emit()` in progress. Subsequent events behave as expected.
+     *
+     * ```js
+     * import { EventEmitter } from 'events';
+     * class MyEmitter extends EventEmitter {}
+     * const myEmitter = new MyEmitter();
+     *
+     * const callbackA = () => {
+     *   console.log('A');
+     *   myEmitter.removeListener('event', callbackB);
+     * };
+     *
+     * const callbackB = () => {
+     *   console.log('B');
+     * };
+     *
+     * myEmitter.on('event', callbackA);
+     *
+     * myEmitter.on('event', callbackB);
+     *
+     * // callbackA removes listener callbackB but it will still be called.
+     * // Internal listener array at time of emit [callbackA, callbackB]
+     * myEmitter.emit('event');
+     * // Prints:
+     * //   A
+     * //   B
+     *
+     * // callbackB is now removed.
+     * // Internal listener array [callbackA]
+     * myEmitter.emit('event');
+     * // Prints:
+     * //   A
+     * ```
+     *
+     * Because listeners are managed using an internal array, calling this will
+     * change the position indices of any listener registered _after_ the listener
+     * being removed. This will not impact the order in which listeners are called,
+     * but it means that any copies of the listener array as returned by
+     * the `emitter.listeners()` method will need to be recreated.
+     *
+     * When a single function has been added as a handler multiple times for a single
+     * event (as in the example below), `removeListener()` will remove the most
+     * recently added instance. In the example the `once('ping')` listener is removed:
+     *
+     * ```js
+     * import { EventEmitter } from 'events';
+     * const ee = new EventEmitter();
+     *
+     * function pong() {
+     *   console.log('pong');
+     * }
+     *
+     * ee.on('ping', pong);
+     * ee.once('ping', pong);
+     * ee.removeListener('ping', pong);
+     *
+     * ee.emit('ping');
+     * ee.emit('ping');
+     * ```
+     *
+     * Returns a reference to the `EventEmitter`, so that calls can be chained.
+     */
+    removeListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+
+    /**
+     * Alias for `emitter.removeListener()`.
+     */
+    off<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+
+    /**
+     * Synchronously calls each of the listeners registered for the event named `eventName`, in the order they were registered, passing the supplied arguments
+     * to each.
+     *
+     * ```js
+     * import { EventEmitter } from 'events';
+     * const myEmitter = new EventEmitter();
+     *
+     * // First listener
+     * myEmitter.on('event', function firstListener() {
+     *   console.log('Helloooo! first listener');
+     * });
+     * // Second listener
+     * myEmitter.on('event', function secondListener(arg1, arg2) {
+     *   console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
+     * });
+     * // Third listener
+     * myEmitter.on('event', function thirdListener(...args) {
+     *   const parameters = args.join(', ');
+     *   console.log(`event with parameters ${parameters} in third listener`);
+     * });
+     *
+     * myEmitter.emit('event', 1, 2, 3, 4, 5);
+     *
+     * // Prints:
+     * // Helloooo! first listener
+     * // event with parameters 1, 2 in second listener
+     * // event with parameters 1, 2, 3, 4, 5 in third listener
+     * ```
+     */
+    emit<K>(eventName: Key<K, T>, ...args: Args<K, T>): void;
+
+    /**
+     * Adds the `listener` function to the _beginning_ of the listeners array for the
+     * event named `eventName`. No checks are made to see if the `listener` has
+     * already been added. Multiple calls passing the same combination of `eventName`
+     * and `listener` will result in the `listener` being added, and called, multiple times.
+     *
+     *
+     * Returns a reference to the `EventEmitter`, so that calls can be chained.
+     * @param eventName The name of the event.
+     * @param listener The callback function
+     */
+    prependListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
+
+    /**
+     * Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array.
+     * The next time `eventName` is triggered, this listener is removed, and then invoked.
+     *
+     * Returns a reference to the `EventEmitter`, so that calls can be chained.
+     * @param eventName The name of the event.
+     * @param listener The callback function
+     */
+    prependOnceListener<K>(
+      eventName: Key<K, T>,
+      listener: Listener1<K, T>
+    ): this;
+
+    /**
+     * Returns an array listing the events for which the emitter has registered
+     * listeners. The values in the array are strings or `Symbol`s.
+     *
+     * ```js
+     * import { EventEmitter } from 'events';
+     *
+     * const myEE = new EventEmitter();
+     * myEE.on('foo', () => {});
+     * myEE.on('bar', () => {});
+     *
+     * const sym = Symbol('symbol');
+     * myEE.on(sym, () => {});
+     *
+     * console.log(myEE.eventNames());
+     * // Prints: [ 'foo', 'bar', Symbol(symbol) ]
+     * ```
+     */
+    eventNames(): Array<EventKey & Key2<unknown, T>>;
+  }
+
+  export default EventEmitter;
+}

package/src/exceptions.d.ts

@@ -0,0 +1,26 @@
+export {};
+
+declare global {
+  interface Error {
+    name: string;
+    message: string;
+    stack?: string;
+  }
+
+  interface ErrorConstructor {
+    new (message?: string): Error;
+    (message?: string): Error;
+    readonly prototype: Error;
+  }
+
+  interface DOMException extends Error {
+    readonly message: string;
+    readonly name: string;
+    readonly stack: string;
+  }
+  var Error: ErrorConstructor;
+  var DOMException: {
+    prototype: DOMException;
+    new (message?: string, name?: string): DOMException;
+  };
+}

package/src/http.d.ts

@@ -0,0 +1,325 @@
+export {};
+
+declare global {
+  interface BlobOpts {
+    /**
+     * One of either `'transparent'` or `'native'`. When set to `'native'`, line endings in string source parts
+     * will be converted to the platform native line-ending as specified by `import { EOL } from 'os'`.
+     */
+    endings?: "transparent" | "native";
+    /**
+     * The Blob content-type. The intent is for `type` to convey the MIME media type of the data,
+     * however no validation of the type format is performed.
+     */
+    type?: string | undefined;
+  }
+
+  /**
+   * The `Body` of a {@link Response} or {@link Request}.
+   * Currently NOT a `ReadableStream`.
+   */
+  type Body = QuickJS.ArrayBufferView | Blob | null;
+
+  /**
+   * A [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) encapsulates immutable, raw data.
+   */
+  class Blob {
+    /**
+     * Creates a new `Blob` object containing a concatenation of the given sources.
+     *
+     * {ArrayBuffer}, and {Blob} sources are copied into the 'Blob' and can therefore be
+     * safely modified after the 'Blob' is created.
+     *
+     * String sources are also copied into the `Blob`.
+     */
+    constructor(parts: Array<ArrayBuffer | string | Blob>, opts?: BlobOpts);
+    /**
+     * The total size of the `Blob` in bytes.
+     */
+    readonly size: number;
+    /**
+     * The content-type of the `Blob`.
+     */
+    readonly type: string;
+    /**
+     * Returns a promise that fulfills with an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) containing a copy of
+     * the `Blob` data.
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Creates and returns a new `Blob` containing a subset of this `Blob` objects
+     * data. The original `Blob` is not altered.
+     * @param start The starting index.
+     * @param end The ending index.
+     * @param type The content-type for the new `Blob`
+     */
+    slice(start?: number, end?: number, type?: string): Blob;
+    /**
+     * Returns a promise that fulfills with the contents of the `Blob` decoded as a UTF-8 string.
+     */
+    text(): Promise<string>;
+    /**
+     * Returns a promise that resolves with an Uint8Array containing the contents of the Blob.
+     */
+    bytes(): Promise<Uint8Array>;
+  }
+
+  interface FileOpts extends BlobOpts {
+    /**
+     * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight).
+     * Files without a known last modified date return the current date.
+     */
+    lastModified?: number;
+  }
+
+  class File extends Blob {
+    /**
+     * Returns a newly constructed File.
+     */
+    constructor(
+      data: Array<ArrayBuffer | string | Blob>,
+      fileName: string,
+      opts?: FileOpts
+    );
+    /**
+     * Name of the file referenced by the File object.
+     */
+    readonly name: string;
+    /**
+     * The last modified date of the file as the number of milliseconds since the Unix epoch (January 1, 1970 at midnight).
+     * Files without a known last modified date return the current date.
+     */
+    readonly lastModified: number;
+  }
+
+  type HeadersLike = Record<string, string> | Headers;
+
+  type HeadersOpts = string[][] | HeadersLike;
+
+  class Headers implements Iterable<[string, string]> {
+    /**
+     * Creates a new Headers object.
+     */
+    constructor(opts?: HeadersOpts);
+    /**
+     * Appends a new value onto an existing header inside a Headers object, or adds the header if it does not already exist.
+     */
+    readonly append: (name: string, value: string) => void;
+    /**
+     * Deletes a header from a Headers object.
+     */
+    readonly delete: (name: string) => void;
+    /**
+     * A String sequence representing the values of the retrieved header or null if this header is not set.
+     */
+    readonly get: (name: string) => string | null;
+    /**
+     * Returns a boolean stating whether a Headers object contains a certain header.
+     */
+    readonly has: (name: string) => boolean;
+    /**
+     * Sets a new value for an existing header inside a Headers object, or adds the header if it does not already exist.
+     */
+    readonly set: (name: string, value: string) => void;
+    /**
+     * Returns an array containing the values of all Set-Cookie headers associated with a response.
+     */
+    readonly getSetCookie: () => string[];
+    /**
+     * Executes a provided function once for each key/value pair in this Headers object.
+     */
+    readonly forEach: (
+      callbackfn: (value: string, key: string) => void
+    ) => void;
+    /**
+     * Returns an iterator allowing you to go through all keys of the key/value pairs contained in this object.
+     */
+    readonly keys: () => IterableIterator<string>;
+    /**
+     * Returns an iterator allowing you to go through all values of the key/value pairs contained in this object.
+     */
+    readonly values: () => IterableIterator<string>;
+    /**
+     * Returns an iterator allowing to go through all key/value pairs contained in this object.
+     */
+    readonly entries: () => IterableIterator<[string, string]>;
+    readonly [Symbol.iterator]: () => Iterator<[string, string]>;
+  }
+
+  interface RequestOpts {
+    url?: string;
+    method?: string;
+    signal?: AbortSignal;
+    body?: Blob;
+    headers?: HeadersLike;
+  }
+
+  type RequestCache = "no-cache";
+
+  type RequestMode = "navigate";
+
+  /**
+   * The Request interface of the Fetch API represents a resource request.
+   */
+  class Request {
+    /**
+     * Creates a new Request object.
+     */
+    constructor(input: string | URL | Request, init?: RequestOpts);
+    /**
+     * Contains the cache mode of the request
+     */
+    readonly cache: RequestCache;
+    /**
+     * Contains the associated Headers object of the request.
+     */
+    readonly headers: Headers;
+    /**
+     * Contains the request's method (GET, POST, etc.)
+     */
+    readonly method: string;
+    /**
+     * Contains the mode of the request
+     */
+    readonly mode: RequestMode;
+    /**
+     * Contains the URL of the request.
+     */
+    readonly url: string;
+    /**
+     * Contains the request's keepalive setting (true or false), which indicates whether llrt will
+     * keep the associated connection alive.
+     */
+    readonly keepalive: boolean;
+    /**
+     * Returns the {@link AbortSignal} associated with the request
+     */
+    readonly signal: AbortSignal;
+    /**
+     * The body content.
+     */
+    readonly body: Body;
+    /**
+     * Stores true or false to indicate whether or not the body has been used in a request yet.
+     */
+    readonly bodyUsed: boolean;
+    /**
+     * Returns a promise that resolves with an ArrayBuffer representation of the request body.
+     */
+    readonly arrayBuffer: () => Promise<ArrayBuffer>;
+    /**
+     * Returns a promise that resolves with a {@link Blob} representation of the request body.
+     */
+    readonly blob: () => Promise<Blob>;
+    /**
+     * Returns a promise that resolves with a {@link Uint8Array} representation of the request body.
+     */
+    readonly bytes: () => Promise<Uint8Array>;
+    /**
+     * Returns a promise that resolves with the result of parsing the request body as JSON.
+     */
+    readonly json: () => Promise<unknown>;
+    /**
+     * Returns a promise that resolves with a text representation of the request body.
+     */
+    readonly text: () => Promise<string>;
+    /**
+     * Creates a copy of the current {@link Request} object.
+     */
+    readonly clone: () => Request;
+  }
+
+  type ResponseType = "basic" | "error";
+
+  interface ResponseInit {
+    readonly status?: number;
+    readonly statusText?: string;
+    readonly headers?: HeadersLike;
+  }
+
+  interface ResponseOpts extends ResponseInit {
+    readonly url?: string;
+    readonly signal?: AbortSignal;
+  }
+
+  /**
+   * The Response interface of the Fetch API represents the response to a request.
+   */
+  class Response {
+    /**
+     * Creates a new Response object.
+     */
+    constructor(body?: Body, opts?: ResponseOpts);
+
+    /**
+     * The {@link Headers} object associated with the response.
+     */
+    readonly headers: Headers;
+    /**
+     * A boolean indicating whether the response was successful (status in the range 200 – 299) or not.
+     */
+    readonly ok: boolean;
+    /**
+     * The status code of the response. (This will be 200 for a success).
+     */
+    readonly status: number;
+    /**
+     * The status message corresponding to the status code. (e.g., OK for 200).
+     */
+    readonly statusText: string;
+    /**
+     * The type of the response.
+     */
+    readonly type: ResponseType;
+    readonly url: string;
+    /**
+     * Indicates whether or not the response is the result of a redirect (that is, its URL list has more than one entry).
+     */
+    readonly redirected: boolean;
+    /**
+     * The body content (NOT IMPLEMENTED YET).
+     */
+    readonly body: null;
+    /**
+     * Stores a boolean value that declares whether the body has been used in a response yet.
+     */
+    readonly bodyUsed: boolean;
+    /**
+     * Returns a promise that resolves with an {@link ArrayBuffer} representation of the response body.
+     */
+    readonly arrayBuffer: () => Promise<ArrayBuffer>;
+    /**
+     * Returns a promise that resolves with a {@link Blob} representation of the response body.
+     */
+    readonly blob: () => Promise<Blob>;
+    /**
+     * Returns a promise that resolves with the result of parsing the response body text as JSON.
+     */
+    readonly json: () => Promise<unknown>;
+    /**
+     * Returns a promise that resolves with a text representation of the response body.
+     */
+    readonly text: () => Promise<string>;
+    /**
+     * Creates a clone of a {@link Response} object.
+     */
+    readonly clone: () => Response;
+    /**
+     * Returns a new {@link Response} object associated with a network error.
+     */
+    static error(): Response;
+    /**
+     * Returns a new {@link Response} object for returning the provided JSON encoded data.
+     */
+    static json(data: any, init?: ResponseInit): Response;
+    /**
+     * Returns a new {@link Response} with a different URL.
+     */
+    static redirect(url: string | URL, status?: number): Response;
+  }
+
+  function fetch(
+    input: string | URL | Request,
+    init?: RequestOpts
+  ): Promise<Response>;
+}