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

package/cjs/FormData.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamFromFormData = exports.PonyfillFormData = void 0;
+const File_js_1 = require("./File.js");
+const ReadableStream_js_1 = require("./ReadableStream.js");
+class PonyfillFormData {
+    constructor() {
+        this.map = new Map();
+    }
+    append(name, value, fileName) {
+        let values = this.map.get(name);
+        if (!values) {
+            values = [];
+            this.map.set(name, values);
+        }
+        const entry = isBlob(value)
+            ? getNormalizedFile(name, value, fileName)
+            : value;
+        values.push(entry);
+    }
+    delete(name) {
+        this.map.delete(name);
+    }
+    get(name) {
+        const values = this.map.get(name);
+        return values ? values[0] : null;
+    }
+    getAll(name) {
+        return this.map.get(name) || [];
+    }
+    has(name) {
+        return this.map.has(name);
+    }
+    set(name, value, fileName) {
+        const entry = isBlob(value)
+            ? getNormalizedFile(name, value, fileName)
+            : value;
+        this.map.set(name, [entry]);
+    }
+    *[Symbol.iterator]() {
+        for (const [key, values] of this.map) {
+            for (const value of values) {
+                yield [key, value];
+            }
+        }
+    }
+    entries() {
+        return this[Symbol.iterator]();
+    }
+    keys() {
+        return this.map.keys();
+    }
+    *values() {
+        for (const values of this.map.values()) {
+            for (const value of values) {
+                yield value;
+            }
+        }
+    }
+    forEach(callback) {
+        for (const [key, value] of this) {
+            callback(value, key, this);
+        }
+    }
+}
+exports.PonyfillFormData = PonyfillFormData;
+function getStreamFromFormData(formData, boundary = '---') {
+    const entries = [];
+    let sentInitialHeader = false;
+    return new ReadableStream_js_1.PonyfillReadableStream({
+        start: controller => {
+            formData.forEach((value, key) => {
+                if (!sentInitialHeader) {
+                    controller.enqueue(Buffer.from(`--${boundary}\r\n`));
+                    sentInitialHeader = true;
+                }
+                entries.push([key, value]);
+            });
+            if (!sentInitialHeader) {
+                controller.enqueue(Buffer.from(`--${boundary}--\r\n`));
+                controller.close();
+            }
+        },
+        pull: async (controller) => {
+            const entry = entries.shift();
+            if (entry) {
+                const [key, value] = entry;
+                if (typeof value === 'string') {
+                    controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
+                    controller.enqueue(Buffer.from(value));
+                }
+                else {
+                    let filenamePart = '';
+                    if (value.name) {
+                        filenamePart = `; filename="${value.name}"`;
+                    }
+                    controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
+                    controller.enqueue(Buffer.from(`Content-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`));
+                    const entryStream = value.stream();
+                    for await (const chunk of entryStream) {
+                        controller.enqueue(chunk);
+                    }
+                }
+                if (entries.length === 0) {
+                    controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(Buffer.from(`\r\n--${boundary}\r\n`));
+                }
+            }
+            else {
+                controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
+                controller.close();
+            }
+        },
+    });
+}
+exports.getStreamFromFormData = getStreamFromFormData;
+function getNormalizedFile(name, blob, fileName) {
+    if (blob instanceof File_js_1.PonyfillFile) {
+        if (fileName != null) {
+            return new File_js_1.PonyfillFile([blob], fileName, {
+                type: blob.type,
+                lastModified: blob.lastModified,
+            });
+        }
+        return blob;
+    }
+    return new File_js_1.PonyfillFile([blob], fileName || name, { type: blob.type });
+}
+function isBlob(value) {
+    return value != null && typeof value === 'object' && typeof value.arrayBuffer === 'function';
+}

package/cjs/Headers.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillHeaders = void 0;
+function isHeadersLike(headers) {
+    return headers && typeof headers.get === 'function';
+}
+class PonyfillHeaders {
+    constructor(headersInit) {
+        this.headersInit = headersInit;
+        this.map = new Map();
+        this.mapIsBuilt = false;
+        this.objectNormalizedKeysOfHeadersInit = [];
+        this.objectOriginalKeysOfHeadersInit = [];
+    }
+    // perf: we don't need to build `this.map` for Requests, as we can access the headers directly
+    _get(key) {
+        // If the map is built, reuse it
+        if (this.mapIsBuilt) {
+            return this.map.get(key.toLowerCase()) || null;
+        }
+        // If the map is not built, try to get the value from the this.headersInit
+        if (this.headersInit == null) {
+            return null;
+        }
+        const normalized = key.toLowerCase();
+        if (Array.isArray(this.headersInit)) {
+            return this.headersInit.find(header => header[0] === normalized);
+        }
+        else if (isHeadersLike(this.headersInit)) {
+            return this.headersInit.get(normalized);
+        }
+        else {
+            const initValue = this.headersInit[key] || this.headersInit[normalized];
+            if (initValue != null) {
+                return initValue;
+            }
+            if (!this.objectNormalizedKeysOfHeadersInit.length) {
+                Object.keys(this.headersInit).forEach(k => {
+                    this.objectOriginalKeysOfHeadersInit.push(k);
+                    this.objectNormalizedKeysOfHeadersInit.push(k.toLowerCase());
+                });
+            }
+            const index = this.objectNormalizedKeysOfHeadersInit.indexOf(normalized);
+            if (index === -1) {
+                return null;
+            }
+            const originalKey = this.objectOriginalKeysOfHeadersInit[index];
+            return this.headersInit[originalKey];
+        }
+    }
+    // perf: Build the map of headers lazily, only when we need to access all headers or write to it.
+    // I could do a getter here, but I'm too lazy to type `getter`.
+    getMap() {
+        if (this.mapIsBuilt) {
+            return this.map;
+        }
+        if (this.headersInit != null) {
+            if (Array.isArray(this.headersInit)) {
+                this.map = new Map(this.headersInit);
+            }
+            else if (isHeadersLike(this.headersInit)) {
+                this.headersInit.forEach((value, key) => {
+                    this.map.set(key, value);
+                });
+            }
+            else {
+                for (const initKey in this.headersInit) {
+                    const initValue = this.headersInit[initKey];
+                    if (initValue != null) {
+                        const normalizedValue = Array.isArray(initValue) ? initValue.join(', ') : initValue;
+                        const normalizedKey = initKey.toLowerCase();
+                        this.map.set(normalizedKey, normalizedValue);
+                    }
+                }
+            }
+        }
+        this.mapIsBuilt = true;
+        return this.map;
+    }
+    append(name, value) {
+        const key = name.toLowerCase();
+        const existingValue = this.getMap().get(key);
+        const finalValue = existingValue ? `${existingValue}, ${value}` : value;
+        this.getMap().set(key, finalValue);
+    }
+    get(name) {
+        const key = name.toLowerCase();
+        const value = this._get(key);
+        if (value == null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.join(', ');
+        }
+        return value;
+    }
+    has(name) {
+        const key = name.toLowerCase();
+        return !!this._get(key); // we might need to check if header exists and not just check if it's not nullable
+    }
+    set(name, value) {
+        const key = name.toLowerCase();
+        this.getMap().set(key, value);
+    }
+    delete(name) {
+        const key = name.toLowerCase();
+        this.getMap().delete(key);
+    }
+    forEach(callback) {
+        this.getMap().forEach((value, key) => {
+            callback(value, key, this);
+        });
+    }
+    keys() {
+        return this.getMap().keys();
+    }
+    values() {
+        return this.getMap().values();
+    }
+    entries() {
+        return this.getMap().entries();
+    }
+    [Symbol.iterator]() {
+        return this.getMap().entries();
+    }
+}
+exports.PonyfillHeaders = PonyfillHeaders;

package/cjs/ReadableStream.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillReadableStream = void 0;
+const stream_1 = require("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 = [];
+            }
+        },
+    };
+}
+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 stream_1.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 stream_1.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;
+    }
+}
+exports.PonyfillReadableStream = PonyfillReadableStream;

package/cjs/Request.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillRequest = void 0;
+const AbortController_js_1 = require("./AbortController.js");
+const Body_js_1 = require("./Body.js");
+const Headers_js_1 = require("./Headers.js");
+function isRequest(input) {
+    return input[Symbol.toStringTag] === 'Request';
+}
+class PonyfillRequest extends Body_js_1.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 Headers_js_1.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 AbortController_js_1.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);
+    }
+}
+exports.PonyfillRequest = PonyfillRequest;

package/cjs/Response.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillResponse = void 0;
+const http_1 = require("http");
+const Body_js_1 = require("./Body.js");
+const Headers_js_1 = require("./Headers.js");
+class PonyfillResponse extends Body_js_1.PonyfillBody {
+    constructor(body, init) {
+        super(body || null, init);
+        this.headers = new Headers_js_1.PonyfillHeaders();
+        this.status = 200;
+        this.statusText = 'OK';
+        this.url = '';
+        this.redirected = false;
+        this.type = 'default';
+        if (init) {
+            this.headers = new Headers_js_1.PonyfillHeaders(init.headers);
+            this.status = init.status || 200;
+            this.statusText = init.statusText || http_1.STATUS_CODES[this.status] || '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,
+            },
+        });
+    }
+}
+exports.PonyfillResponse = PonyfillResponse;

package/cjs/TextEncoderDecoder.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillBtoa = exports.PonyfillTextDecoder = exports.PonyfillTextEncoder = void 0;
+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,
+        };
+    }
+}
+exports.PonyfillTextEncoder = PonyfillTextEncoder;
+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);
+    }
+}
+exports.PonyfillTextDecoder = PonyfillTextDecoder;
+function PonyfillBtoa(input) {
+    return Buffer.from(input, 'binary').toString('base64');
+}
+exports.PonyfillBtoa = PonyfillBtoa;

package/cjs/URL.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillURL = void 0;
+const tslib_1 = require("tslib");
+const fast_querystring_1 = tslib_1.__importDefault(require("fast-querystring"));
+const fast_url_parser_1 = tslib_1.__importDefault(require("fast-url-parser"));
+const URLSearchParams_js_1 = require("./URLSearchParams.js");
+fast_url_parser_1.default.queryString = fast_querystring_1.default;
+class PonyfillURL extends fast_url_parser_1.default {
+    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 URLSearchParams_js_1.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();
+    }
+}
+exports.PonyfillURL = PonyfillURL;