@whatwg-node/node-fetch 0.3.3-rc-20230320123406-da3a60b → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.3.3-rc-20230320123406-da3a60b",
+  "version": "0.3.3",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "peerDependencies": {
@@ -20,21 +20,28 @@
   },
   "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/AbortController.d.cts

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

package/{AbortController.d.ts → typings/AbortController.d.ts}

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

package/typings/AbortError.d.ts

@@ -0,0 +1,4 @@
+export declare class PonyfillAbortError extends Error {
+    constructor(reason?: any);
+    get reason(): unknown;
+}

package/typings/AbortSignal.d.ts

@@ -0,0 +1,11 @@
+import { EventTarget } from '@whatwg-node/events';
+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);
+    abort(reason?: any): void;
+    static timeout(milliseconds: number): PonyfillAbortSignal;
+}

package/typings/Blob.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { BlobOptions } from 'buffer';
+export declare class PonyfillBlob implements Blob {
+    private blobParts;
+    type: string;
+    private encoding;
+    constructor(blobParts: BlobPart[], options?: BlobOptions);
+    buffer(): Promise<Buffer>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    get size(): number;
+    stream(): any;
+    slice(): any;
+}
+export interface PonyfillBlob {
+    prototype: Blob;
+    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+}

package/typings/Body.d.cts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { PonyfillBlob } from './Blob.cjs';
+import { PonyfillFormData } from './FormData.cjs';
+import { PonyfillReadableStream } from './ReadableStream.cjs';
+export type BodyPonyfillInit = XMLHttpRequestBodyInit | Readable | PonyfillReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+export interface FormDataLimits {
+    fieldNameSize?: number;
+    fieldSize?: number;
+    fields?: number;
+    fileSize?: number;
+    files?: number;
+    parts?: number;
+    headerSize?: number;
+}
+export interface PonyfillBodyOptions {
+    formDataLimits?: FormDataLimits;
+}
+export declare class PonyfillBody<TJSON = any> implements Body {
+    private bodyInit;
+    private options;
+    bodyUsed: boolean;
+    contentType: string | null;
+    contentLength: number | null;
+    constructor(bodyInit: BodyPonyfillInit | null, options?: PonyfillBodyOptions);
+    private bodyType?;
+    private _bodyFactory;
+    private _generatedBody;
+    private generateBody;
+    get body(): PonyfillReadableStream<Uint8Array> | null;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    _collectChunksFromReadable(): Promise<Uint8Array[]>;
+    blob(): Promise<PonyfillBlob>;
+    formData(opts?: {
+        formDataLimits: FormDataLimits;
+    }): Promise<PonyfillFormData>;
+    buffer(): Promise<Buffer>;
+    json(): Promise<TJSON>;
+    text(): Promise<string>;
+}

package/{Body.d.ts → typings/Body.d.ts}

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { Readable } from 'stream';
-import { PonyfillBlob } from './Blob';
-import { PonyfillFormData } from './FormData';
-import { PonyfillReadableStream } from './ReadableStream';
+import { PonyfillBlob } from './Blob.js';
+import { PonyfillFormData } from './FormData.js';
+import { PonyfillReadableStream } from './ReadableStream.js';
 export type BodyPonyfillInit = XMLHttpRequestBodyInit | Readable | PonyfillReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
 export interface FormDataLimits {
     fieldNameSize?: number;

package/typings/File.d.cts

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

package/{File.d.ts → typings/File.d.ts}

@@ -1,4 +1,4 @@
-import { PonyfillBlob } from './Blob';
+import { PonyfillBlob } from './Blob.js';
 export declare class PonyfillFile extends PonyfillBlob implements File {
     name: string;
     lastModified: number;

package/typings/FormData.d.cts

@@ -0,0 +1,17 @@
+import { PonyfillBlob } from './Blob.cjs';
+import { PonyfillReadableStream } from './ReadableStream.cjs';
+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;
+    [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
+    entries(): IterableIterator<[string, FormDataEntryValue]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<FormDataEntryValue>;
+    forEach(callback: (value: FormDataEntryValue, key: string, parent: this) => void): void;
+}
+export declare function getStreamFromFormData(formData: FormData, boundary?: string): PonyfillReadableStream<Uint8Array>;

package/{FormData.d.ts → typings/FormData.d.ts}

@@ -1,5 +1,5 @@
-import { PonyfillBlob } from './Blob';
-import { PonyfillReadableStream } from './ReadableStream';
+import { PonyfillBlob } from './Blob.js';
+import { PonyfillReadableStream } from './ReadableStream.js';
 export declare class PonyfillFormData implements FormData {
     private map;
     append(name: string, value: PonyfillBlob | string, fileName?: string): void;

package/typings/Headers.d.ts

@@ -0,0 +1,21 @@
+export type PonyfillHeadersInit = [string, string][] | Record<string, string | string[] | undefined> | Headers;
+export declare class PonyfillHeaders implements Headers {
+    private headersInit?;
+    private map;
+    private mapIsBuilt;
+    private objectNormalizedKeysOfHeadersInit;
+    private objectOriginalKeysOfHeadersInit;
+    constructor(headersInit?: PonyfillHeadersInit | undefined);
+    private _get;
+    private getMap;
+    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;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[string, string]>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+}

package/typings/ReadableStream.d.ts

@@ -0,0 +1,20 @@
+/// <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(options: {
+        mode: 'byob';
+    }): ReadableStreamBYOBReader;
+    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>;
+    static [Symbol.hasInstance](instance: unknown): instance is PonyfillReadableStream<unknown>;
+}

package/typings/Request.d.cts

@@ -0,0 +1,24 @@
+import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.cjs';
+import { PonyfillHeadersInit } from './Headers.cjs';
+export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body' | 'headers'> & {
+    body?: BodyPonyfillInit | null;
+    headers?: PonyfillHeadersInit;
+};
+export declare class PonyfillRequest<TJSON = any> extends PonyfillBody<TJSON> implements Request {
+    constructor(input: RequestInfo | URL, options?: RequestPonyfillInit);
+    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/{Request.d.ts → typings/Request.d.ts}

@@ -1,5 +1,5 @@
-import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body';
-import { PonyfillHeadersInit } from './Headers';
+import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.js';
+import { PonyfillHeadersInit } from './Headers.js';
 export type RequestPonyfillInit = PonyfillBodyOptions & Omit<RequestInit, 'body' | 'headers'> & {
     body?: BodyPonyfillInit | null;
     headers?: PonyfillHeadersInit;

package/typings/Response.d.cts

@@ -0,0 +1,22 @@
+import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.cjs';
+import { PonyfillHeadersInit } from './Headers.cjs';
+export type ResponsePonyfilInit = PonyfillBodyOptions & Omit<ResponseInit, 'headers'> & {
+    url?: string;
+    redirected?: boolean;
+    headers?: PonyfillHeadersInit;
+    type?: ResponseType;
+};
+export declare class PonyfillResponse<TJSON = any> extends PonyfillBody<TJSON> 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<any>;
+    static error(): PonyfillResponse<any>;
+    static redirect(url: string, status?: number): PonyfillResponse<any>;
+    static json<T = any>(data: T, init?: RequestInit): PonyfillResponse<T>;
+}

package/{Response.d.ts → typings/Response.d.ts}

@@ -1,5 +1,5 @@
-import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body';
-import { PonyfillHeadersInit } from './Headers';
+import { BodyPonyfillInit, PonyfillBody, PonyfillBodyOptions } from './Body.js';
+import { PonyfillHeadersInit } from './Headers.js';
 export type ResponsePonyfilInit = PonyfillBodyOptions & Omit<ResponseInit, 'headers'> & {
     url?: string;
     redirected?: boolean;

package/typings/TextEncoderDecoder.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+export declare class PonyfillTextEncoder implements TextEncoder {
+    encoding: BufferEncoding;
+    constructor(encoding?: BufferEncoding);
+    encode(input: string): Buffer;
+    encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
+}
+export declare class PonyfillTextDecoder implements TextDecoder {
+    encoding: BufferEncoding;
+    fatal: boolean;
+    ignoreBOM: boolean;
+    constructor(encoding: BufferEncoding, options: TextDecoderOptions);
+    decode(input: Uint8Array): string;
+}
+export declare function PonyfillBtoa(input: string): string;

package/typings/URL.d.cts

@@ -0,0 +1,14 @@
+import FastUrl from 'fast-url-parser';
+import { PonyfillURLSearchParams } from './URLSearchParams.cjs';
+export declare class PonyfillURL extends FastUrl implements URL {
+    constructor(url: string, base?: string | URL);
+    get origin(): string;
+    private _searchParams?;
+    get searchParams(): PonyfillURLSearchParams;
+    get username(): string;
+    set username(value: string);
+    get password(): string;
+    set password(value: string);
+    toString(): string;
+    toJSON(): string;
+}

package/{URL.d.ts → typings/URL.d.ts}

@@ -1,5 +1,5 @@
 import FastUrl from 'fast-url-parser';
-import { PonyfillURLSearchParams } from './URLSearchParams';
+import { PonyfillURLSearchParams } from './URLSearchParams.js';
 export declare class PonyfillURL extends FastUrl implements URL {
     constructor(url: string, base?: string | URL);
     get origin(): string;

package/typings/URLSearchParams.d.ts

@@ -0,0 +1,17 @@
+export declare class PonyfillURLSearchParams implements URLSearchParams {
+    private params;
+    constructor(init?: string | string[][] | Record<string, string> | URLSearchParams);
+    append(name: string, value: string): void;
+    delete(name: string): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+    sort(): void;
+    toString(): string;
+    keys(): IterableIterator<string>;
+    entries(): IterableIterator<[string, string]>;
+    values(): IterableIterator<string>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    forEach(callback: (value: string, key: string, parent: URLSearchParams) => void): void;
+}

package/typings/fetch.d.cts

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

package/{fetch.d.ts → typings/fetch.d.ts}

@@ -1,3 +1,3 @@
-import { PonyfillRequest, RequestPonyfillInit } from './Request';
-import { PonyfillResponse } from './Response';
+import { PonyfillRequest, RequestPonyfillInit } from './Request.js';
+import { PonyfillResponse } from './Response.js';
 export declare function fetchPonyfill<TResponseJSON = any, TRequestJSON = any>(info: string | PonyfillRequest<TRequestJSON> | URL, init?: RequestPonyfillInit): Promise<PonyfillResponse<TResponseJSON>>;

package/typings/index.d.cts

@@ -0,0 +1,15 @@
+export { fetchPonyfill as fetch } from './fetch.cjs';
+export { PonyfillHeaders as Headers } from './Headers.cjs';
+export { PonyfillBody as Body } from './Body.cjs';
+export { PonyfillRequest as Request, RequestPonyfillInit as RequestInit } from './Request.cjs';
+export { PonyfillResponse as Response, ResponsePonyfilInit as ResponseInit } from './Response.cjs';
+export { PonyfillReadableStream as ReadableStream } from './ReadableStream.cjs';
+export { PonyfillFile as File } from './File.cjs';
+export { PonyfillFormData as FormData } from './FormData.cjs';
+export { PonyfillAbortController as AbortController } from './AbortController.cjs';
+export { PonyfillAbortSignal as AbortSignal } from './AbortSignal.cjs';
+export { PonyfillAbortError as AbortError } from './AbortError.cjs';
+export { PonyfillBlob as Blob } from './Blob.cjs';
+export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder.cjs';
+export { PonyfillURL as URL } from './URL.cjs';
+export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams.cjs';

package/typings/index.d.ts

@@ -0,0 +1,15 @@
+export { fetchPonyfill as fetch } from './fetch.js';
+export { PonyfillHeaders as Headers } from './Headers.js';
+export { PonyfillBody as Body } from './Body.js';
+export { PonyfillRequest as Request, RequestPonyfillInit as RequestInit } from './Request.js';
+export { PonyfillResponse as Response, ResponsePonyfilInit as ResponseInit } from './Response.js';
+export { PonyfillReadableStream as ReadableStream } from './ReadableStream.js';
+export { PonyfillFile as File } from './File.js';
+export { PonyfillFormData as FormData } from './FormData.js';
+export { PonyfillAbortController as AbortController } from './AbortController.js';
+export { PonyfillAbortSignal as AbortSignal } from './AbortSignal.js';
+export { PonyfillAbortError as AbortError } from './AbortError.js';
+export { PonyfillBlob as Blob } from './Blob.js';
+export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder.js';
+export { PonyfillURL as URL } from './URL.js';
+export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams.js';

package/typings/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getHeadersObj(headers: Headers): Record<string, string>;
+export declare function uint8ArrayToArrayBuffer(uint8array: Uint8Array): ArrayBuffer;

package/index.d.ts

@@ -1,15 +0,0 @@
-export { fetchPonyfill as fetch } from './fetch';
-export { PonyfillHeaders as Headers } from './Headers';
-export { PonyfillBody as Body } from './Body';
-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';
-export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder';
-export { PonyfillURL as URL } from './URL';
-export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams';