mirror of
https://github.com/denoland/deno.git
synced 2025-03-12 07:07:43 -04:00
e4b8fa5f4f
This commits moves all `.d.ts` files from `ext/*` to `cli/tsc/dts`. Due to TSC snapshot removal, `cargo publish` is now erroring out, unable to find the declaration files. These files were moved to "cli/tsc/dts", because it's much easier than keeping them in extension directories, while still providing them compressed or uncompressed depending on the build type.
498 lines
14 KiB
TypeScript
498 lines
14 KiB
TypeScript
// Copyright 2018-2025 the Deno authors. MIT license.
|
|
|
|
// deno-lint-ignore-file no-explicit-any no-var
|
|
|
|
/// <reference no-default-lib="true" />
|
|
/// <reference lib="esnext" />
|
|
|
|
/** @category Platform */
|
|
interface DomIterable<K, V> {
|
|
keys(): IterableIterator<K>;
|
|
values(): IterableIterator<V>;
|
|
entries(): IterableIterator<[K, V]>;
|
|
[Symbol.iterator](): IterableIterator<[K, V]>;
|
|
forEach(
|
|
callback: (value: V, key: K, parent: this) => void,
|
|
thisArg?: any,
|
|
): void;
|
|
}
|
|
|
|
/** @category Fetch */
|
|
type FormDataEntryValue = File | string;
|
|
|
|
/** Provides a way to easily construct a set of key/value pairs representing
|
|
* form fields and their values, which can then be easily sent using the
|
|
* XMLHttpRequest.send() method. It uses the same format a form would use if the
|
|
* encoding type were set to "multipart/form-data".
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
interface FormData extends DomIterable<string, FormDataEntryValue> {
|
|
append(name: string, value: string | Blob, fileName?: string): void;
|
|
delete(name: string): void;
|
|
get(name: string): FormDataEntryValue | null;
|
|
getAll(name: string): FormDataEntryValue[];
|
|
has(name: string): boolean;
|
|
set(name: string, value: string | Blob, fileName?: string): void;
|
|
}
|
|
|
|
/** @category Fetch */
|
|
declare var FormData: {
|
|
readonly prototype: FormData;
|
|
new (): FormData;
|
|
};
|
|
|
|
/** @category Fetch */
|
|
interface Body {
|
|
/** A simple getter used to expose a `ReadableStream` of the body contents. */
|
|
readonly body: ReadableStream<Uint8Array> | null;
|
|
/** Stores a `Boolean` that declares whether the body has been used in a
|
|
* response yet.
|
|
*/
|
|
readonly bodyUsed: boolean;
|
|
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
|
* that resolves with an `ArrayBuffer`.
|
|
*/
|
|
arrayBuffer(): Promise<ArrayBuffer>;
|
|
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
|
* that resolves with a `Blob`.
|
|
*/
|
|
blob(): Promise<Blob>;
|
|
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
|
* that resolves with a `Uint8Array`.
|
|
*/
|
|
bytes(): Promise<Uint8Array>;
|
|
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
|
* that resolves with a `FormData` object.
|
|
*/
|
|
formData(): Promise<FormData>;
|
|
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
|
* that resolves with the result of parsing the body text as JSON.
|
|
*/
|
|
json(): Promise<any>;
|
|
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
|
* that resolves with a `USVString` (text).
|
|
*/
|
|
text(): Promise<string>;
|
|
}
|
|
|
|
/** @category Fetch */
|
|
type HeadersInit = Iterable<string[]> | Record<string, string>;
|
|
|
|
/** This Fetch API interface allows you to perform various actions on HTTP
|
|
* request and response headers. These actions include retrieving, setting,
|
|
* adding to, and removing. A Headers object has an associated header list,
|
|
* which is initially empty and consists of zero or more name and value pairs.
|
|
* You can add to this using methods like append() (see Examples). In all
|
|
* methods of this interface, header names are matched by case-insensitive byte
|
|
* sequence.
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
interface Headers extends DomIterable<string, string> {
|
|
/** Appends a new value onto an existing header inside a `Headers` object, or
|
|
* adds the header if it does not already exist.
|
|
*/
|
|
append(name: string, value: string): void;
|
|
/** Deletes a header from a `Headers` object. */
|
|
delete(name: string): void;
|
|
/** Returns a `ByteString` sequence of all the values of a header within a
|
|
* `Headers` object with a given name.
|
|
*/
|
|
get(name: string): string | null;
|
|
/** Returns a boolean stating whether a `Headers` object contains a certain
|
|
* header.
|
|
*/
|
|
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.
|
|
*/
|
|
set(name: string, value: string): void;
|
|
/** Returns an array containing the values of all `Set-Cookie` headers
|
|
* associated with a response.
|
|
*/
|
|
getSetCookie(): string[];
|
|
}
|
|
|
|
/** This Fetch API interface allows you to perform various actions on HTTP
|
|
* request and response headers. These actions include retrieving, setting,
|
|
* adding to, and removing. A Headers object has an associated header list,
|
|
* which is initially empty and consists of zero or more name and value pairs.
|
|
* You can add to this using methods like append() (see Examples). In all
|
|
* methods of this interface, header names are matched by case-insensitive byte
|
|
* sequence.
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
declare var Headers: {
|
|
readonly prototype: Headers;
|
|
new (init?: HeadersInit): Headers;
|
|
};
|
|
|
|
/** @category Fetch */
|
|
type RequestInfo = Request | string;
|
|
/** @category Fetch */
|
|
type RequestCache =
|
|
| "default"
|
|
| "force-cache"
|
|
| "no-cache"
|
|
| "no-store"
|
|
| "only-if-cached"
|
|
| "reload";
|
|
/** @category Fetch */
|
|
type RequestCredentials = "include" | "omit" | "same-origin";
|
|
/** @category Fetch */
|
|
type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
|
|
/** @category Fetch */
|
|
type RequestRedirect = "error" | "follow" | "manual";
|
|
/** @category Fetch */
|
|
type ReferrerPolicy =
|
|
| ""
|
|
| "no-referrer"
|
|
| "no-referrer-when-downgrade"
|
|
| "origin"
|
|
| "origin-when-cross-origin"
|
|
| "same-origin"
|
|
| "strict-origin"
|
|
| "strict-origin-when-cross-origin"
|
|
| "unsafe-url";
|
|
/** @category Fetch */
|
|
type BodyInit =
|
|
| Blob
|
|
| BufferSource
|
|
| FormData
|
|
| URLSearchParams
|
|
| ReadableStream<Uint8Array>
|
|
| Iterable<Uint8Array>
|
|
| AsyncIterable<Uint8Array>
|
|
| string;
|
|
/** @category Fetch */
|
|
type RequestDestination =
|
|
| ""
|
|
| "audio"
|
|
| "audioworklet"
|
|
| "document"
|
|
| "embed"
|
|
| "font"
|
|
| "image"
|
|
| "manifest"
|
|
| "object"
|
|
| "paintworklet"
|
|
| "report"
|
|
| "script"
|
|
| "sharedworker"
|
|
| "style"
|
|
| "track"
|
|
| "video"
|
|
| "worker"
|
|
| "xslt";
|
|
|
|
/** @category Fetch */
|
|
interface RequestInit {
|
|
/**
|
|
* A BodyInit object or null to set request's body.
|
|
*/
|
|
body?: BodyInit | null;
|
|
/**
|
|
* A string indicating how the request will interact with the browser's cache
|
|
* to set request's cache.
|
|
*/
|
|
cache?: RequestCache;
|
|
/**
|
|
* A string indicating whether credentials will be sent with the request
|
|
* always, never, or only when sent to a same-origin URL. Sets request's
|
|
* credentials.
|
|
*/
|
|
credentials?: RequestCredentials;
|
|
/**
|
|
* A Headers object, an object literal, or an array of two-item arrays to set
|
|
* request's headers.
|
|
*/
|
|
headers?: HeadersInit;
|
|
/**
|
|
* A cryptographic hash of the resource to be fetched by request. Sets
|
|
* request's integrity.
|
|
*/
|
|
integrity?: string;
|
|
/**
|
|
* A boolean to set request's keepalive.
|
|
*/
|
|
keepalive?: boolean;
|
|
/**
|
|
* A string to set request's method.
|
|
*/
|
|
method?: string;
|
|
/**
|
|
* A string to indicate whether the request will use CORS, or will be
|
|
* restricted to same-origin URLs. Sets request's mode.
|
|
*/
|
|
mode?: RequestMode;
|
|
/**
|
|
* A string indicating whether request follows redirects, results in an error
|
|
* upon encountering a redirect, or returns the redirect (in an opaque
|
|
* fashion). Sets request's redirect.
|
|
*/
|
|
redirect?: RequestRedirect;
|
|
/**
|
|
* A string whose value is a same-origin URL, "about:client", or the empty
|
|
* string, to set request's referrer.
|
|
*/
|
|
referrer?: string;
|
|
/**
|
|
* A referrer policy to set request's referrerPolicy.
|
|
*/
|
|
referrerPolicy?: ReferrerPolicy;
|
|
/**
|
|
* An AbortSignal to set request's signal.
|
|
*/
|
|
signal?: AbortSignal | null;
|
|
/**
|
|
* Can only be null. Used to disassociate request from any Window.
|
|
*/
|
|
window?: any;
|
|
}
|
|
|
|
/** This Fetch API interface represents a resource request.
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
interface Request extends Body {
|
|
/**
|
|
* Returns the cache mode associated with request, which is a string
|
|
* indicating how the request will interact with the browser's cache when
|
|
* fetching.
|
|
*/
|
|
readonly cache: RequestCache;
|
|
/**
|
|
* Returns the credentials mode associated with request, which is a string
|
|
* indicating whether credentials will be sent with the request always, never,
|
|
* or only when sent to a same-origin URL.
|
|
*/
|
|
readonly credentials: RequestCredentials;
|
|
/**
|
|
* Returns the kind of resource requested by request, e.g., "document" or "script".
|
|
*/
|
|
readonly destination: RequestDestination;
|
|
/**
|
|
* Returns a Headers object consisting of the headers associated with request.
|
|
* Note that headers added in the network layer by the user agent will not be
|
|
* accounted for in this object, e.g., the "Host" header.
|
|
*/
|
|
readonly headers: Headers;
|
|
/**
|
|
* Returns request's subresource integrity metadata, which is a cryptographic
|
|
* hash of the resource being fetched. Its value consists of multiple hashes
|
|
* separated by whitespace. [SRI]
|
|
*/
|
|
readonly integrity: string;
|
|
/**
|
|
* Returns a boolean indicating whether or not request is for a history
|
|
* navigation (a.k.a. back-forward navigation).
|
|
*/
|
|
readonly isHistoryNavigation: boolean;
|
|
/**
|
|
* Returns a boolean indicating whether or not request is for a reload
|
|
* navigation.
|
|
*/
|
|
readonly isReloadNavigation: boolean;
|
|
/**
|
|
* Returns a boolean indicating whether or not request can outlive the global
|
|
* in which it was created.
|
|
*/
|
|
readonly keepalive: boolean;
|
|
/**
|
|
* Returns request's HTTP method, which is "GET" by default.
|
|
*/
|
|
readonly method: string;
|
|
/**
|
|
* Returns the mode associated with request, which is a string indicating
|
|
* whether the request will use CORS, or will be restricted to same-origin
|
|
* URLs.
|
|
*/
|
|
readonly mode: RequestMode;
|
|
/**
|
|
* Returns the redirect mode associated with request, which is a string
|
|
* indicating how redirects for the request will be handled during fetching. A
|
|
* request will follow redirects by default.
|
|
*/
|
|
readonly redirect: RequestRedirect;
|
|
/**
|
|
* Returns the referrer of request. Its value can be a same-origin URL if
|
|
* explicitly set in init, the empty string to indicate no referrer, and
|
|
* "about:client" when defaulting to the global's default. This is used during
|
|
* fetching to determine the value of the `Referer` header of the request
|
|
* being made.
|
|
*/
|
|
readonly referrer: string;
|
|
/**
|
|
* Returns the referrer policy associated with request. This is used during
|
|
* fetching to compute the value of the request's referrer.
|
|
*/
|
|
readonly referrerPolicy: ReferrerPolicy;
|
|
/**
|
|
* Returns the signal associated with request, which is an AbortSignal object
|
|
* indicating whether or not request has been aborted, and its abort event
|
|
* handler.
|
|
*/
|
|
readonly signal: AbortSignal;
|
|
/**
|
|
* Returns the URL of request as a string.
|
|
*/
|
|
readonly url: string;
|
|
clone(): Request;
|
|
}
|
|
|
|
/** This Fetch API interface represents a resource request.
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
declare var Request: {
|
|
readonly prototype: Request;
|
|
new (input: RequestInfo | URL, init?: RequestInit): Request;
|
|
};
|
|
|
|
/** @category Fetch */
|
|
interface ResponseInit {
|
|
headers?: HeadersInit;
|
|
status?: number;
|
|
statusText?: string;
|
|
}
|
|
|
|
/** @category Fetch */
|
|
type ResponseType =
|
|
| "basic"
|
|
| "cors"
|
|
| "default"
|
|
| "error"
|
|
| "opaque"
|
|
| "opaqueredirect";
|
|
|
|
/** This Fetch API interface represents the response to a request.
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
interface Response extends Body {
|
|
readonly headers: Headers;
|
|
readonly ok: boolean;
|
|
readonly redirected: boolean;
|
|
readonly status: number;
|
|
readonly statusText: string;
|
|
readonly type: ResponseType;
|
|
readonly url: string;
|
|
clone(): Response;
|
|
}
|
|
|
|
/** This Fetch API interface represents the response to a request.
|
|
*
|
|
* @category Fetch
|
|
*/
|
|
declare var Response: {
|
|
readonly prototype: Response;
|
|
new (body?: BodyInit | null, init?: ResponseInit): Response;
|
|
json(data: unknown, init?: ResponseInit): Response;
|
|
error(): Response;
|
|
redirect(url: string | URL, status?: number): Response;
|
|
};
|
|
|
|
/** Fetch a resource from the network. It returns a `Promise` that resolves to the
|
|
* `Response` to that `Request`, whether it is successful or not.
|
|
*
|
|
* ```ts
|
|
* const response = await fetch("http://my.json.host/data.json");
|
|
* console.log(response.status); // e.g. 200
|
|
* console.log(response.statusText); // e.g. "OK"
|
|
* const jsonData = await response.json();
|
|
* ```
|
|
*
|
|
* @tags allow-net, allow-read
|
|
* @category Fetch
|
|
*/
|
|
declare function fetch(
|
|
input: URL | Request | string,
|
|
init?: RequestInit,
|
|
): Promise<Response>;
|
|
|
|
/**
|
|
* @category Fetch
|
|
*/
|
|
interface EventSourceInit {
|
|
withCredentials?: boolean;
|
|
}
|
|
|
|
/**
|
|
* @category Fetch
|
|
*/
|
|
interface EventSourceEventMap {
|
|
"error": Event;
|
|
"message": MessageEvent;
|
|
"open": Event;
|
|
}
|
|
|
|
/**
|
|
* @category Fetch
|
|
*/
|
|
interface EventSource extends EventTarget {
|
|
onerror: ((this: EventSource, ev: Event) => any) | null;
|
|
onmessage: ((this: EventSource, ev: MessageEvent) => any) | null;
|
|
onopen: ((this: EventSource, ev: Event) => any) | null;
|
|
/**
|
|
* Returns the state of this EventSource object's connection. It can have the values described below.
|
|
*/
|
|
readonly readyState: number;
|
|
/**
|
|
* Returns the URL providing the event stream.
|
|
*/
|
|
readonly url: string;
|
|
/**
|
|
* Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
|
|
*/
|
|
readonly withCredentials: boolean;
|
|
/**
|
|
* Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
|
|
*/
|
|
close(): void;
|
|
readonly CONNECTING: 0;
|
|
readonly OPEN: 1;
|
|
readonly CLOSED: 2;
|
|
addEventListener<K extends keyof EventSourceEventMap>(
|
|
type: K,
|
|
listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
|
|
options?: boolean | AddEventListenerOptions,
|
|
): void;
|
|
addEventListener(
|
|
type: string,
|
|
listener: (this: EventSource, event: MessageEvent) => any,
|
|
options?: boolean | AddEventListenerOptions,
|
|
): void;
|
|
addEventListener(
|
|
type: string,
|
|
listener: EventListenerOrEventListenerObject,
|
|
options?: boolean | AddEventListenerOptions,
|
|
): void;
|
|
removeEventListener<K extends keyof EventSourceEventMap>(
|
|
type: K,
|
|
listener: (this: EventSource, ev: EventSourceEventMap[K]) => any,
|
|
options?: boolean | EventListenerOptions,
|
|
): void;
|
|
removeEventListener(
|
|
type: string,
|
|
listener: (this: EventSource, event: MessageEvent) => any,
|
|
options?: boolean | EventListenerOptions,
|
|
): void;
|
|
removeEventListener(
|
|
type: string,
|
|
listener: EventListenerOrEventListenerObject,
|
|
options?: boolean | EventListenerOptions,
|
|
): void;
|
|
}
|
|
|
|
/**
|
|
* @category Fetch
|
|
*/
|
|
declare var EventSource: {
|
|
prototype: EventSource;
|
|
new (url: string | URL, eventSourceInitDict?: EventSourceInit): EventSource;
|
|
readonly CONNECTING: 0;
|
|
readonly OPEN: 1;
|
|
readonly CLOSED: 2;
|
|
};
|