@whatwg-node/node-fetch 0.0.1-alpha-20221005123855-1e2f172

package/AbortController.d.ts

@@ -0,0 +1,5 @@
+import { PonyfillAbortSignal } from "./AbortSignal";
+export declare class PonyfillAbortController implements AbortController {
+    signal: PonyfillAbortSignal;
+    abort(reason?: any): void;
+}

package/AbortError.d.ts

@@ -0,0 +1,3 @@
+export declare class PonyfillAbortError extends Error {
+    constructor();
+}

package/AbortSignal.d.ts

@@ -0,0 +1,8 @@
+export declare class PonyfillAbortSignal extends EventTarget implements AbortSignal {
+    aborted: boolean;
+    _onabort: ((this: AbortSignal, ev: Event) => any) | null;
+    reason: any;
+    throwIfAborted(): void;
+    get onabort(): ((this: AbortSignal, ev: Event) => any) | null;
+    set onabort(value: ((this: AbortSignal, ev: Event) => any) | null);
+}

package/Blob.d.ts

@@ -0,0 +1,5 @@
+export declare const PonyfillBlob: {
+    new (blobParts?: BlobPart[] | undefined, options?: BlobPropertyBag | undefined): Blob;
+    prototype: Blob;
+};
+export declare type PonyfillBlob = Blob;

package/Body.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { PonyfillBlob } from './Blob';
+import { Readable } from "stream";
+import { PonyfillFormData } from "./FormData";
+import { PonyfillReadableStream } from "./ReadableStream";
+export declare type BodyPonyfillInit = XMLHttpRequestBodyInit | Readable | PonyfillReadableStream<Uint8Array>;
+export declare class BodyPonyfill implements Body {
+    private bodyInit;
+    bodyUsed: boolean;
+    contentType: string | null;
+    contentLength: number | null;
+    constructor(bodyInit: BodyPonyfillInit | null);
+    private bodyType?;
+    private _bodyProcessed;
+    private _processedBody;
+    get body(): PonyfillReadableStream<Uint8Array> | null;
+    private processBody;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<PonyfillBlob>;
+    formData(): Promise<PonyfillFormData>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+    readable(): Readable | null;
+}

package/File.d.ts

@@ -0,0 +1,7 @@
+import { PonyfillBlob } from "./Blob";
+export declare class PonyfillFile extends PonyfillBlob implements File {
+    name: string;
+    lastModified: number;
+    constructor(fileBits: BlobPart[], name: string, options?: FilePropertyBag);
+    webkitRelativePath: string;
+}

package/FormData.d.ts

@@ -0,0 +1,12 @@
+import { PonyfillBlob } from './Blob';
+export declare class PonyfillFormData implements FormData {
+    private map;
+    append(name: string, value: PonyfillBlob | string, fileName?: string): void;
+    delete(name: string): void;
+    get(name: string): FormDataEntryValue | null;
+    getAll(name: string): FormDataEntryValue[];
+    has(name: string): boolean;
+    set(name: string, value: PonyfillBlob | string, fileName?: string): void;
+    private getNormalizedFile;
+    forEach(callback: (value: FormDataEntryValue, key: string, parent: this) => void): void;
+}

package/Headers.d.ts

@@ -0,0 +1,11 @@
+export declare type PonyfillHeadersInit = [string, string][] | Record<string, string | string[] | undefined> | Headers;
+export declare class PonyfillHeaders implements Headers {
+    private map;
+    constructor(headersInit?: PonyfillHeadersInit);
+    append(name: string, value: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    delete(name: string): void;
+    forEach(callback: (value: string, key: string, parent: Headers) => void): void;
+}

package/ReadableStream.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+export declare class PonyfillReadableStream<T> implements ReadableStream<T> {
+    readable: Readable;
+    constructor(underlyingSource?: UnderlyingSource<T> | Readable | ReadableStream<T> | PonyfillReadableStream<T>);
+    cancel(reason?: any): Promise<void>;
+    locked: boolean;
+    getReader(): ReadableStreamDefaultReader<T>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+    tee(): [ReadableStream<T>, ReadableStream<T>];
+    pipeTo(destination: WritableStream<T>): Promise<void>;
+    pipeThrough<T2>({ writable, readable }: {
+        writable: WritableStream<T>;
+        readable: ReadableStream<T2>;
+    }): ReadableStream<T2>;
+}

package/Request.d.ts

@@ -0,0 +1,27 @@
+import { BodyPonyfill, BodyPonyfillInit } from "./Body";
+import { PonyfillHeadersInit } from "./Headers";
+export declare type RequestPonyfillInit = Omit<RequestInit, 'body' | 'headers'> & {
+    body?: BodyPonyfillInit | null;
+    headers?: PonyfillHeadersInit;
+};
+export declare class PonyfillRequest extends BodyPonyfill implements Request {
+    constructor(input: RequestInfo | URL, options?: RequestPonyfillInit);
+    get body(): import("./ReadableStream").PonyfillReadableStream<Uint8Array> | null;
+    private postProcessedBody;
+    private postProcessBody;
+    cache: RequestCache;
+    credentials: RequestCredentials;
+    destination: RequestDestination;
+    headers: Headers;
+    integrity: string;
+    keepalive: boolean;
+    method: string;
+    mode: RequestMode;
+    priority: string;
+    redirect: RequestRedirect;
+    referrer: string;
+    referrerPolicy: ReferrerPolicy;
+    url: string;
+    signal: AbortSignal;
+    clone(): Request;
+}

package/Response.d.ts

@@ -0,0 +1,20 @@
+import { BodyPonyfill, BodyPonyfillInit } from "./Body";
+import { PonyfillHeadersInit } from "./Headers";
+export declare type ResponsePonyfilInit = Omit<ResponseInit, 'headers'> & {
+    url?: string;
+    redirected?: boolean;
+    headers?: PonyfillHeadersInit;
+};
+export declare class PonyfillResponse extends BodyPonyfill implements Response {
+    constructor(body?: BodyPonyfillInit | null, init?: ResponsePonyfilInit);
+    headers: Headers;
+    get ok(): boolean;
+    status: number;
+    statusText: string;
+    url: string;
+    redirected: boolean;
+    type: ResponseType;
+    clone(): PonyfillResponse;
+    static error(): PonyfillResponse;
+    static redirect(url: string, status?: number): PonyfillResponse;
+}

package/fetch.d.ts

@@ -0,0 +1,3 @@
+import { PonyfillRequest, RequestPonyfillInit } from "./Request";
+import { PonyfillResponse } from "./Response";
+export declare const fetchPonyfill: (info: string | PonyfillRequest | URL, init?: RequestPonyfillInit) => Promise<PonyfillResponse>;

package/index.d.ts

@@ -0,0 +1,11 @@
+export { fetchPonyfill as fetch } from './fetch';
+export { PonyfillHeaders as Headers } from './Headers';
+export { PonyfillRequest as Request, RequestPonyfillInit as RequestInit } from './Request';
+export { PonyfillResponse as Response, ResponsePonyfilInit as ResponseInit } from './Response';
+export { PonyfillReadableStream as ReadableStream } from './ReadableStream';
+export { PonyfillFile as File } from './File';
+export { PonyfillFormData as FormData } from './FormData';
+export { PonyfillAbortController as AbortController } from './AbortController';
+export { PonyfillAbortSignal as AbortSignal } from './AbortSignal';
+export { PonyfillAbortError as AbortError } from './AbortError';
+export { PonyfillBlob as Blob } from './Blob';