@whatwg-node/node-fetch 0.3.0 → 0.4.0-alpha-20230215085115-d099e0b

package/esm/ReadableStream.js

@@ -0,0 +1,168 @@
+import { Readable } from 'stream';
+function createController(desiredSize, readable) {
+    let chunks = [];
+    let _closed = false;
+    let flushed = false;
+    return {
+        desiredSize,
+        enqueue(chunk) {
+            const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            if (!flushed) {
+                chunks.push(buf);
+            }
+            else {
+                readable.push(buf);
+            }
+        },
+        close() {
+            if (chunks.length > 0) {
+                this._flush();
+            }
+            readable.push(null);
+            _closed = true;
+        },
+        error(error) {
+            if (chunks.length > 0) {
+                this._flush();
+            }
+            readable.destroy(error);
+        },
+        get _closed() {
+            return _closed;
+        },
+        _flush() {
+            flushed = true;
+            if (chunks.length > 0) {
+                const concatenated = Buffer.concat(chunks);
+                readable.push(concatenated);
+                chunks = [];
+            }
+        },
+    };
+}
+export class PonyfillReadableStream {
+    constructor(underlyingSource) {
+        this.locked = false;
+        if (underlyingSource instanceof PonyfillReadableStream) {
+            this.readable = underlyingSource.readable;
+        }
+        else if (underlyingSource && 'read' in underlyingSource) {
+            this.readable = underlyingSource;
+        }
+        else if (underlyingSource && 'getReader' in underlyingSource) {
+            let reader;
+            let started = false;
+            this.readable = new Readable({
+                read() {
+                    if (!started) {
+                        started = true;
+                        reader = underlyingSource.getReader();
+                    }
+                    reader
+                        .read()
+                        .then(({ value, done }) => {
+                        if (done) {
+                            this.push(null);
+                        }
+                        else {
+                            this.push(value);
+                        }
+                    })
+                        .catch(err => {
+                        this.destroy(err);
+                    });
+                },
+                destroy(err, callback) {
+                    reader.cancel(err).then(() => callback(err), callback);
+                },
+            });
+        }
+        else {
+            let started = false;
+            let ongoing = false;
+            this.readable = new Readable({
+                read(desiredSize) {
+                    if (ongoing) {
+                        return;
+                    }
+                    ongoing = true;
+                    return Promise.resolve().then(async () => {
+                        var _a, _b;
+                        if (!started) {
+                            const controller = createController(desiredSize, this);
+                            started = true;
+                            await ((_a = underlyingSource === null || underlyingSource === void 0 ? void 0 : underlyingSource.start) === null || _a === void 0 ? void 0 : _a.call(underlyingSource, controller));
+                            controller._flush();
+                            if (controller._closed) {
+                                return;
+                            }
+                        }
+                        const controller = createController(desiredSize, this);
+                        await ((_b = underlyingSource === null || underlyingSource === void 0 ? void 0 : underlyingSource.pull) === null || _b === void 0 ? void 0 : _b.call(underlyingSource, controller));
+                        controller._flush();
+                        ongoing = false;
+                    });
+                },
+                async destroy(err, callback) {
+                    var _a;
+                    try {
+                        await ((_a = underlyingSource === null || underlyingSource === void 0 ? void 0 : underlyingSource.cancel) === null || _a === void 0 ? void 0 : _a.call(underlyingSource, err));
+                        callback(null);
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+            });
+        }
+    }
+    cancel(reason) {
+        this.readable.destroy(reason);
+        return Promise.resolve();
+    }
+    getReader(_options) {
+        const iterator = this.readable[Symbol.asyncIterator]();
+        this.locked = true;
+        return {
+            read() {
+                return iterator.next();
+            },
+            releaseLock: () => {
+                var _a;
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+                this.locked = false;
+            },
+            cancel: async (reason) => {
+                var _a;
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator, reason));
+                this.locked = false;
+            },
+            closed: new Promise((resolve, reject) => {
+                this.readable.once('end', resolve);
+                this.readable.once('error', reject);
+            }),
+        };
+    }
+    [Symbol.asyncIterator]() {
+        return this.readable[Symbol.asyncIterator]();
+    }
+    tee() {
+        throw new Error('Not implemented');
+    }
+    async pipeTo(destination) {
+        const writer = destination.getWriter();
+        await writer.ready;
+        for await (const chunk of this.readable) {
+            await writer.write(chunk);
+        }
+        await writer.ready;
+        return writer.close();
+    }
+    pipeThrough({ writable, readable, }) {
+        this.pipeTo(writable);
+        return readable;
+    }
+    static [Symbol.hasInstance](instance) {
+        return instance != null && typeof instance === 'object' && 'getReader' in instance;
+    }
+}

package/esm/Request.js

@@ -0,0 +1,65 @@
+import { PonyfillAbortController } from './AbortController.js';
+import { PonyfillBody } from './Body.js';
+import { PonyfillHeaders } from './Headers.js';
+function isRequest(input) {
+    return input[Symbol.toStringTag] === 'Request';
+}
+export class PonyfillRequest extends PonyfillBody {
+    constructor(input, options) {
+        var _a;
+        let url;
+        let bodyInit = null;
+        let requestInit;
+        if (typeof input === 'string') {
+            url = input;
+        }
+        else if ('href' in input) {
+            url = input.toString();
+        }
+        else if (isRequest(input)) {
+            url = input.url;
+            bodyInit = input.body;
+            requestInit = input;
+        }
+        if (options != null) {
+            bodyInit = options.body || null;
+            requestInit = options;
+        }
+        super(bodyInit, options);
+        this.destination = '';
+        this.priority = 'auto';
+        this.cache = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.cache) || 'default';
+        this.credentials = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.credentials) || 'same-origin';
+        this.headers = new PonyfillHeaders(requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers);
+        this.integrity = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.integrity) || '';
+        this.keepalive = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.keepalive) != null ? requestInit === null || requestInit === void 0 ? void 0 : requestInit.keepalive : false;
+        this.method = ((_a = requestInit === null || requestInit === void 0 ? void 0 : requestInit.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'GET';
+        this.mode = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.mode) || 'cors';
+        this.redirect = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.redirect) || 'follow';
+        this.referrer = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.referrer) || 'about:client';
+        this.referrerPolicy = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.referrerPolicy) || 'no-referrer';
+        this.signal = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.signal) || new PonyfillAbortController().signal;
+        this.url = url || '';
+        const contentTypeInHeaders = this.headers.get('content-type');
+        if (!contentTypeInHeaders) {
+            if (this.contentType) {
+                this.headers.set('content-type', this.contentType);
+            }
+        }
+        else {
+            this.contentType = contentTypeInHeaders;
+        }
+        const contentLengthInHeaders = this.headers.get('content-length');
+        if (!contentLengthInHeaders) {
+            if (this.contentLength) {
+                this.headers.set('content-length', this.contentLength.toString());
+            }
+        }
+        else {
+            this.contentLength = parseInt(contentLengthInHeaders, 10);
+        }
+    }
+    clone() {
+        return new Request(this);
+    }
+}

package/esm/Response.js

@@ -0,0 +1,71 @@
+import { PonyfillBody } from './Body.js';
+import { PonyfillHeaders } from './Headers.js';
+export class PonyfillResponse extends PonyfillBody {
+    constructor(body, init) {
+        super(body || null, init);
+        this.headers = new PonyfillHeaders();
+        this.status = 200;
+        this.statusText = 'OK';
+        this.url = '';
+        this.redirected = false;
+        this.type = 'default';
+        if (init) {
+            this.headers = new PonyfillHeaders(init.headers);
+            this.status = init.status || 200;
+            this.statusText = init.statusText || 'OK';
+            this.url = init.url || '';
+            this.redirected = init.redirected || false;
+            this.type = init.type || 'default';
+        }
+        const contentTypeInHeaders = this.headers.get('content-type');
+        if (!contentTypeInHeaders) {
+            if (this.contentType) {
+                this.headers.set('content-type', this.contentType);
+            }
+        }
+        else {
+            this.contentType = contentTypeInHeaders;
+        }
+        const contentLengthInHeaders = this.headers.get('content-length');
+        if (!contentLengthInHeaders) {
+            if (this.contentLength) {
+                this.headers.set('content-length', this.contentLength.toString());
+            }
+        }
+        else {
+            this.contentLength = parseInt(contentLengthInHeaders, 10);
+        }
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+    clone() {
+        return new PonyfillResponse(this.body, this);
+    }
+    static error() {
+        return new PonyfillResponse(null, {
+            status: 500,
+            statusText: 'Internal Server Error',
+        });
+    }
+    static redirect(url, status = 301) {
+        if (status < 300 || status > 399) {
+            throw new RangeError('Invalid status code');
+        }
+        return new PonyfillResponse(null, {
+            headers: {
+                location: url,
+            },
+            status,
+        });
+    }
+    static json(data, init = {}) {
+        return new PonyfillResponse(JSON.stringify(data), {
+            ...init,
+            headers: {
+                'Content-Type': 'application/json',
+                ...init === null || init === void 0 ? void 0 : init.headers,
+            },
+        });
+    }
+}

package/esm/TextEncoderDecoder.js

@@ -0,0 +1,33 @@
+export class PonyfillTextEncoder {
+    constructor(encoding = 'utf-8') {
+        this.encoding = encoding;
+    }
+    encode(input) {
+        return Buffer.from(input, this.encoding);
+    }
+    encodeInto(source, destination) {
+        const buffer = this.encode(source);
+        const copied = buffer.copy(destination);
+        return {
+            read: copied,
+            written: copied,
+        };
+    }
+}
+export class PonyfillTextDecoder {
+    constructor(encoding = 'utf-8', options) {
+        this.encoding = encoding;
+        this.fatal = false;
+        this.ignoreBOM = false;
+        if (options) {
+            this.fatal = options.fatal || false;
+            this.ignoreBOM = options.ignoreBOM || false;
+        }
+    }
+    decode(input) {
+        return Buffer.from(input).toString(this.encoding);
+    }
+}
+export function PonyfillBtoa(input) {
+    return Buffer.from(input, 'binary').toString('base64');
+}

package/esm/URL.js

@@ -0,0 +1,50 @@
+import FastQuerystring from 'fast-querystring';
+import FastUrl from 'fast-url-parser';
+import { PonyfillURLSearchParams } from './URLSearchParams.js';
+FastUrl.queryString = FastQuerystring;
+export class PonyfillURL extends FastUrl {
+    constructor(url, base) {
+        super();
+        if (url.startsWith('data:')) {
+            this.protocol = 'data:';
+            this.pathname = url.slice('data:'.length);
+            return;
+        }
+        this.parse(url, false);
+        if (base) {
+            const baseParsed = typeof base === 'string' ? new PonyfillURL(base) : base;
+            this.protocol = this.protocol || baseParsed.protocol;
+            this.host = this.host || baseParsed.host;
+            this.pathname = this.pathname || baseParsed.pathname;
+        }
+    }
+    get origin() {
+        return `${this.protocol}//${this.host}`;
+    }
+    get searchParams() {
+        if (!this._searchParams) {
+            this._searchParams = new PonyfillURLSearchParams(this.query);
+        }
+        return this._searchParams;
+    }
+    get username() {
+        var _a;
+        return ((_a = this.auth) === null || _a === void 0 ? void 0 : _a.split(':')[0]) || '';
+    }
+    set username(value) {
+        this.auth = `${value}:${this.password}`;
+    }
+    get password() {
+        var _a;
+        return ((_a = this.auth) === null || _a === void 0 ? void 0 : _a.split(':')[1]) || '';
+    }
+    set password(value) {
+        this.auth = `${this.username}:${value}`;
+    }
+    toString() {
+        return this.format();
+    }
+    toJSON() {
+        return this.toString();
+    }
+}

package/esm/URLSearchParams.js

@@ -0,0 +1,98 @@
+import FastQuerystring from 'fast-querystring';
+export class PonyfillURLSearchParams {
+    constructor(init) {
+        if (init) {
+            if (typeof init === 'string') {
+                this.params = FastQuerystring.parse(init);
+            }
+            else if (Array.isArray(init)) {
+                this.params = {};
+                for (const [key, value] of init) {
+                    this.params[key] = value;
+                }
+            }
+            else if ('entries' in init) {
+                this.params = {};
+                for (const [key, value] of init.entries()) {
+                    this.params[key] = value;
+                }
+            }
+            else {
+                this.params = init;
+            }
+        }
+        else {
+            this.params = {};
+        }
+    }
+    append(name, value) {
+        const existingValue = this.params[name];
+        const finalValue = existingValue ? `${existingValue},${value}` : value;
+        this.params[name] = finalValue;
+    }
+    delete(name) {
+        delete this.params[name];
+    }
+    get(name) {
+        const value = this.params[name];
+        if (Array.isArray(value)) {
+            return value[0] || null;
+        }
+        return value || null;
+    }
+    getAll(name) {
+        const value = this.params[name];
+        if (!Array.isArray(value)) {
+            return value ? [value] : [];
+        }
+        return value;
+    }
+    has(name) {
+        return name in this.params;
+    }
+    set(name, value) {
+        this.params[name] = value;
+    }
+    sort() {
+        const sortedKeys = Object.keys(this.params).sort();
+        const sortedParams = {};
+        for (const key of sortedKeys) {
+            sortedParams[key] = this.params[key];
+        }
+        this.params = sortedParams;
+    }
+    toString() {
+        return FastQuerystring.stringify(this.params);
+    }
+    *keys() {
+        for (const key in this.params) {
+            yield key;
+        }
+    }
+    *entries() {
+        for (const key of this.keys()) {
+            const value = this.params[key];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    yield [key, item];
+                }
+            }
+            else {
+                yield [key, value];
+            }
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callback) {
+        for (const [key, value] of this) {
+            callback(value, key, this);
+        }
+    }
+}

package/esm/fetch.js

@@ -0,0 +1,123 @@
+import { createReadStream } from 'fs';
+import { request as httpRequest } from 'http';
+import { request as httpsRequest } from 'https';
+import { Readable } from 'stream';
+import { fileURLToPath } from 'url';
+import { PonyfillAbortError } from './AbortError.js';
+import { PonyfillBlob } from './Blob.js';
+import { PonyfillRequest } from './Request.js';
+import { PonyfillResponse } from './Response.js';
+import { PonyfillURL } from './URL.js';
+import { getHeadersObj } from './utils.js';
+function getResponseForFile(url) {
+    const path = fileURLToPath(url);
+    const readable = createReadStream(path);
+    return new PonyfillResponse(readable);
+}
+function getRequestFnForProtocol(protocol) {
+    switch (protocol) {
+        case 'http:':
+            return httpRequest;
+        case 'https:':
+            return httpsRequest;
+    }
+    throw new Error(`Unsupported protocol: ${protocol}`);
+}
+const BASE64_SUFFIX = ';base64';
+export function fetchPonyfill(info, init) {
+    if (typeof info === 'string' || 'href' in info) {
+        const ponyfillRequest = new PonyfillRequest(info, init);
+        return fetchPonyfill(ponyfillRequest);
+    }
+    const fetchRequest = info;
+    return new Promise((resolve, reject) => {
+        try {
+            const url = new PonyfillURL(fetchRequest.url, 'http://localhost');
+            if (url.protocol === 'data:') {
+                const [mimeType = 'text/plain', ...datas] = url.pathname.split(',');
+                const data = decodeURIComponent(datas.join(','));
+                if (mimeType.endsWith(BASE64_SUFFIX)) {
+                    const buffer = Buffer.from(data, 'base64url');
+                    const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
+                    const file = new PonyfillBlob([buffer], { type: realMimeType });
+                    const response = new PonyfillResponse(file, {
+                        status: 200,
+                        statusText: 'OK',
+                    });
+                    resolve(response);
+                    return;
+                }
+                const response = new PonyfillResponse(data, {
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {
+                        'content-type': mimeType,
+                    },
+                });
+                resolve(response);
+                return;
+            }
+            if (url.protocol === 'file:') {
+                const response = getResponseForFile(fetchRequest.url);
+                resolve(response);
+                return;
+            }
+            const requestFn = getRequestFnForProtocol(url.protocol);
+            const nodeReadable = (fetchRequest.body != null
+                ? 'pipe' in fetchRequest.body
+                    ? fetchRequest.body
+                    : Readable.from(fetchRequest.body)
+                : null);
+            const nodeHeaders = getHeadersObj(fetchRequest.headers);
+            const abortListener = function abortListener(event) {
+                nodeRequest.destroy();
+                const reason = event.detail;
+                reject(new PonyfillAbortError(reason));
+            };
+            fetchRequest.signal.addEventListener('abort', abortListener);
+            const nodeRequest = requestFn(fetchRequest.url, {
+                // signal: fetchRequest.signal will be added when v14 reaches EOL
+                method: fetchRequest.method,
+                headers: nodeHeaders,
+            });
+            nodeRequest.once('response', nodeResponse => {
+                if (nodeResponse.headers.location) {
+                    if (fetchRequest.redirect === 'error') {
+                        const redirectError = new Error('Redirects are not allowed');
+                        reject(redirectError);
+                        nodeResponse.resume();
+                        return;
+                    }
+                    if (fetchRequest.redirect === 'follow') {
+                        const redirectedUrl = new PonyfillURL(nodeResponse.headers.location, url);
+                        const redirectResponse$ = fetchPonyfill(redirectedUrl, info);
+                        resolve(redirectResponse$.then(redirectResponse => {
+                            redirectResponse.redirected = true;
+                            return redirectResponse;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                const responseHeaders = nodeResponse.headers;
+                const ponyfillResponse = new PonyfillResponse(nodeResponse, {
+                    status: nodeResponse.statusCode,
+                    statusText: nodeResponse.statusMessage,
+                    headers: responseHeaders,
+                    url: info.url,
+                });
+                resolve(ponyfillResponse);
+            });
+            nodeRequest.once('error', reject);
+            if (nodeReadable) {
+                nodeReadable.pipe(nodeRequest);
+            }
+            else {
+                nodeRequest.end();
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}

package/esm/index.js

@@ -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 } from './Request.js';
+export { PonyfillResponse as Response } 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/esm/utils.js

@@ -0,0 +1,13 @@
+export function getHeadersObj(headers) {
+    if (headers == null || !('forEach' in headers)) {
+        return headers;
+    }
+    const obj = {};
+    headers.forEach((value, key) => {
+        obj[key] = value;
+    });
+    return obj;
+}
+export function uint8ArrayToArrayBuffer(uint8array) {
+    return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.3.0",
+  "version": "0.4.0-alpha-20230215085115-d099e0b",
   "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"
   }
-}
+}