@whatwg-node/node-fetch 0.3.3-rc-20230320121450-923e939 → 0.3.3-rc-20230320124940-870b034

package/cjs/AbortController.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillAbortController = void 0;
+const AbortSignal_js_1 = require("./AbortSignal.js");
+// Will be removed after v14 reaches EOL
+class PonyfillAbortController {
+    constructor() {
+        this.signal = new AbortSignal_js_1.PonyfillAbortSignal();
+    }
+    abort(reason) {
+        this.signal.abort(reason);
+    }
+}
+exports.PonyfillAbortController = PonyfillAbortController;

package/cjs/AbortError.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillAbortError = void 0;
+// Will be removed after v14 reaches EOL
+class PonyfillAbortError extends Error {
+    constructor(reason) {
+        let message = 'The operation was aborted.';
+        if (reason) {
+            message += ` reason: ${reason}`;
+        }
+        super(message, {
+            cause: reason,
+        });
+        this.name = 'AbortError';
+    }
+    get reason() {
+        return this.cause;
+    }
+}
+exports.PonyfillAbortError = PonyfillAbortError;

package/cjs/AbortSignal.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillAbortSignal = void 0;
+// Will be removed after v14 reaches EOL
+const events_1 = require("@whatwg-node/events");
+const AbortError_js_1 = require("./AbortError.js");
+class PonyfillAbortSignal extends events_1.EventTarget {
+    constructor() {
+        super(...arguments);
+        this.aborted = false;
+        this._onabort = null;
+    }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw new AbortError_js_1.PonyfillAbortError();
+        }
+    }
+    get onabort() {
+        return this._onabort;
+    }
+    set onabort(value) {
+        if (this._onabort) {
+            this.removeEventListener('abort', this._onabort);
+        }
+        this.addEventListener('abort', value);
+    }
+    abort(reason) {
+        const abortEvent = new events_1.CustomEvent('abort', { detail: reason });
+        this.dispatchEvent(abortEvent);
+    }
+    static timeout(milliseconds) {
+        const signal = new PonyfillAbortSignal();
+        setTimeout(() => signal.abort(`timeout in ${milliseconds} ms`), milliseconds);
+        return signal;
+    }
+}
+exports.PonyfillAbortSignal = PonyfillAbortSignal;

package/cjs/Blob.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillBlob = void 0;
+const ReadableStream_js_1 = require("./ReadableStream.js");
+const utils_js_1 = require("./utils.js");
+function getBlobPartAsBuffer(blobPart) {
+    if (typeof blobPart === 'string') {
+        return Buffer.from(blobPart);
+    }
+    else if (Buffer.isBuffer(blobPart)) {
+        return blobPart;
+    }
+    else if (blobPart instanceof Uint8Array) {
+        return Buffer.from(blobPart);
+    }
+    else if ('buffer' in blobPart) {
+        return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
+    }
+    else {
+        return Buffer.from(blobPart);
+    }
+}
+function isBlob(obj) {
+    return obj != null && typeof obj === 'object' && obj.arrayBuffer != null;
+}
+// Will be removed after v14 reaches EOL
+// Needed because v14 doesn't have .stream() implemented
+class PonyfillBlob {
+    constructor(blobParts, options) {
+        this.blobParts = blobParts;
+        this.type = (options === null || options === void 0 ? void 0 : options.type) || 'application/octet-stream';
+        this.encoding = (options === null || options === void 0 ? void 0 : options.encoding) || 'utf8';
+    }
+    async buffer() {
+        const bufferChunks = [];
+        for (const blobPart of this.blobParts) {
+            if (isBlob(blobPart)) {
+                const arrayBuf = await blobPart.arrayBuffer();
+                const buf = Buffer.from(arrayBuf, undefined, blobPart.size);
+                bufferChunks.push(buf);
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                bufferChunks.push(buf);
+            }
+        }
+        return Buffer.concat(bufferChunks);
+    }
+    async arrayBuffer() {
+        const buffer = await this.buffer();
+        return (0, utils_js_1.uint8ArrayToArrayBuffer)(buffer);
+    }
+    async text() {
+        let text = '';
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                text += blobPart;
+            }
+            else if ('text' in blobPart) {
+                text += await blobPart.text();
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                text += buf.toString(this.encoding);
+            }
+        }
+        return text;
+    }
+    get size() {
+        let size = 0;
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                size += Buffer.byteLength(blobPart);
+            }
+            else if (isBlob(blobPart)) {
+                size += blobPart.size;
+            }
+            else if ('length' in blobPart) {
+                size += blobPart.length;
+            }
+            else if ('byteLength' in blobPart) {
+                size += blobPart.byteLength;
+            }
+        }
+        return size;
+    }
+    stream() {
+        let partQueue = [];
+        return new ReadableStream_js_1.PonyfillReadableStream({
+            start: controller => {
+                partQueue = [...this.blobParts];
+                if (partQueue.length === 0) {
+                    controller.close();
+                }
+            },
+            pull: async (controller) => {
+                const blobPart = partQueue.pop();
+                if (blobPart) {
+                    if (isBlob(blobPart)) {
+                        const arrayBuffer = await blobPart.arrayBuffer();
+                        const buf = Buffer.from(arrayBuffer, undefined, blobPart.size);
+                        controller.enqueue(buf);
+                    }
+                    else {
+                        const buf = getBlobPartAsBuffer(blobPart);
+                        controller.enqueue(buf);
+                    }
+                }
+                else {
+                    controller.close();
+                }
+            },
+        });
+    }
+    slice() {
+        throw new Error('Not implemented');
+    }
+}
+exports.PonyfillBlob = PonyfillBlob;

package/cjs/Body.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillBody = void 0;
+const tslib_1 = require("tslib");
+const stream_1 = require("stream");
+const busboy_1 = tslib_1.__importDefault(require("busboy"));
+const Blob_js_1 = require("./Blob.js");
+const File_js_1 = require("./File.js");
+const FormData_js_1 = require("./FormData.js");
+const ReadableStream_js_1 = require("./ReadableStream.js");
+const utils_js_1 = require("./utils.js");
+var BodyInitType;
+(function (BodyInitType) {
+    BodyInitType["ReadableStream"] = "ReadableStream";
+    BodyInitType["Blob"] = "Blob";
+    BodyInitType["FormData"] = "FormData";
+    BodyInitType["ArrayBuffer"] = "ArrayBuffer";
+    BodyInitType["String"] = "String";
+    BodyInitType["Readable"] = "Readable";
+    BodyInitType["Buffer"] = "Buffer";
+    BodyInitType["Uint8Array"] = "Uint8Array";
+})(BodyInitType || (BodyInitType = {}));
+class PonyfillBody {
+    constructor(bodyInit, options = {}) {
+        this.bodyInit = bodyInit;
+        this.options = options;
+        this.bodyUsed = false;
+        this.contentType = null;
+        this.contentLength = null;
+        this._bodyFactory = () => null;
+        this._generatedBody = null;
+        const { bodyFactory, contentType, contentLength, bodyType } = processBodyInit(bodyInit);
+        this._bodyFactory = bodyFactory;
+        this.contentType = contentType;
+        this.contentLength = contentLength;
+        this.bodyType = bodyType;
+    }
+    generateBody() {
+        if (this._generatedBody) {
+            return this._generatedBody;
+        }
+        const body = this._bodyFactory();
+        this._generatedBody = body;
+        return body;
+    }
+    get body() {
+        const _body = this.generateBody();
+        if (_body != null) {
+            const ponyfillReadableStream = _body;
+            const readable = _body.readable;
+            return new Proxy(_body.readable, {
+                get(_, prop) {
+                    if (prop in ponyfillReadableStream) {
+                        const ponyfillReadableStreamProp = ponyfillReadableStream[prop];
+                        if (typeof ponyfillReadableStreamProp === 'function') {
+                            return ponyfillReadableStreamProp.bind(ponyfillReadableStream);
+                        }
+                        return ponyfillReadableStreamProp;
+                    }
+                    if (prop in readable) {
+                        const readableProp = readable[prop];
+                        if (typeof readableProp === 'function') {
+                            return readableProp.bind(readable);
+                        }
+                        return readableProp;
+                    }
+                },
+            });
+        }
+        return null;
+    }
+    async arrayBuffer() {
+        if (this.bodyType === BodyInitType.ArrayBuffer) {
+            return this.bodyInit;
+        }
+        if (this.bodyType === BodyInitType.Uint8Array || this.bodyType === BodyInitType.Buffer) {
+            const typedBodyInit = this.bodyInit;
+            return (0, utils_js_1.uint8ArrayToArrayBuffer)(typedBodyInit);
+        }
+        if (this.bodyType === BodyInitType.String) {
+            const buffer = Buffer.from(this.bodyInit);
+            return (0, utils_js_1.uint8ArrayToArrayBuffer)(buffer);
+        }
+        if (this.bodyType === BodyInitType.Blob) {
+            const blob = this.bodyInit;
+            const arrayBuffer = await blob.arrayBuffer();
+            return arrayBuffer;
+        }
+        const blob = await this.blob();
+        return blob.arrayBuffer();
+    }
+    async _collectChunksFromReadable() {
+        const chunks = [];
+        const _body = this.generateBody();
+        if (_body) {
+            for await (const chunk of _body.readable) {
+                chunks.push(chunk);
+            }
+        }
+        return chunks;
+    }
+    async blob() {
+        if (this.bodyType === BodyInitType.Blob) {
+            return this.bodyInit;
+        }
+        if (this.bodyType === BodyInitType.String ||
+            this.bodyType === BodyInitType.Buffer ||
+            this.bodyType === BodyInitType.Uint8Array) {
+            const bodyInitTyped = this.bodyInit;
+            return new Blob_js_1.PonyfillBlob([bodyInitTyped], {
+                type: this.contentType || '',
+            });
+        }
+        if (this.bodyType === BodyInitType.ArrayBuffer) {
+            const bodyInitTyped = this.bodyInit;
+            const buf = Buffer.from(bodyInitTyped, undefined, bodyInitTyped.byteLength);
+            return new Blob_js_1.PonyfillBlob([buf], {
+                type: this.contentType || '',
+            });
+        }
+        const chunks = await this._collectChunksFromReadable();
+        return new Blob_js_1.PonyfillBlob(chunks, {
+            type: this.contentType || '',
+        });
+    }
+    formData(opts) {
+        if (this.bodyType === BodyInitType.FormData) {
+            return Promise.resolve(this.bodyInit);
+        }
+        const formData = new FormData_js_1.PonyfillFormData();
+        const _body = this.generateBody();
+        if (_body == null) {
+            return Promise.resolve(formData);
+        }
+        const formDataLimits = {
+            ...this.options.formDataLimits,
+            ...opts === null || opts === void 0 ? void 0 : opts.formDataLimits,
+        };
+        return new Promise((resolve, reject) => {
+            const bb = (0, busboy_1.default)({
+                headers: {
+                    'content-type': this.contentType || '',
+                },
+                limits: formDataLimits,
+                defParamCharset: 'utf-8',
+            });
+            bb.on('field', (name, value, { nameTruncated, valueTruncated }) => {
+                if (nameTruncated) {
+                    reject(new Error(`Field name size exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.fieldNameSize} bytes`));
+                }
+                if (valueTruncated) {
+                    reject(new Error(`Field value size exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.fieldSize} bytes`));
+                }
+                formData.set(name, value);
+            });
+            bb.on('fieldsLimit', () => {
+                reject(new Error(`Fields limit exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.fields}`));
+            });
+            bb.on('file', (name, fileStream, { filename, mimeType }) => {
+                const chunks = [];
+                fileStream.on('limit', () => {
+                    reject(new Error(`File size limit exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.fileSize} bytes`));
+                });
+                fileStream.on('data', chunk => {
+                    chunks.push(Buffer.from(chunk));
+                });
+                fileStream.on('close', () => {
+                    if (fileStream.truncated) {
+                        reject(new Error(`File size limit exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.fileSize} bytes`));
+                    }
+                    const file = new File_js_1.PonyfillFile(chunks, filename, { type: mimeType });
+                    formData.set(name, file);
+                });
+            });
+            bb.on('filesLimit', () => {
+                reject(new Error(`Files limit exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.files}`));
+            });
+            bb.on('partsLimit', () => {
+                reject(new Error(`Parts limit exceeded: ${formDataLimits === null || formDataLimits === void 0 ? void 0 : formDataLimits.parts}`));
+            });
+            bb.on('close', () => {
+                resolve(formData);
+            });
+            bb.on('error', err => {
+                reject(err);
+            });
+            _body === null || _body === void 0 ? void 0 : _body.readable.pipe(bb);
+        });
+    }
+    async buffer() {
+        if (this.bodyType === BodyInitType.Buffer) {
+            return this.bodyInit;
+        }
+        if (this.bodyType === BodyInitType.String) {
+            return Buffer.from(this.bodyInit);
+        }
+        if (this.bodyType === BodyInitType.Uint8Array || this.bodyType === BodyInitType.ArrayBuffer) {
+            const bodyInitTyped = this.bodyInit;
+            const buffer = Buffer.from(bodyInitTyped, 'byteOffset' in bodyInitTyped ? bodyInitTyped.byteOffset : undefined, bodyInitTyped.byteLength);
+            return buffer;
+        }
+        if (this.bodyType === BodyInitType.Blob) {
+            if (this.bodyInit instanceof Blob_js_1.PonyfillBlob) {
+                return this.bodyInit.buffer();
+            }
+            const bodyInitTyped = this.bodyInit;
+            const buffer = Buffer.from(await bodyInitTyped.arrayBuffer(), undefined, bodyInitTyped.size);
+            return buffer;
+        }
+        const chunks = await this._collectChunksFromReadable();
+        return Buffer.concat(chunks);
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    async text() {
+        if (this.bodyType === BodyInitType.String) {
+            return this.bodyInit;
+        }
+        const buffer = await this.buffer();
+        return buffer.toString('utf-8');
+    }
+}
+exports.PonyfillBody = PonyfillBody;
+function processBodyInit(bodyInit) {
+    if (bodyInit == null) {
+        return {
+            bodyFactory: () => null,
+            contentType: null,
+            contentLength: null,
+        };
+    }
+    if (typeof bodyInit === 'string') {
+        return {
+            bodyType: BodyInitType.String,
+            contentType: 'text/plain;charset=UTF-8',
+            contentLength: Buffer.byteLength(bodyInit),
+            bodyFactory() {
+                const readable = stream_1.Readable.from(bodyInit);
+                return new ReadableStream_js_1.PonyfillReadableStream(readable);
+            },
+        };
+    }
+    if (bodyInit instanceof ReadableStream_js_1.PonyfillReadableStream) {
+        return {
+            bodyType: BodyInitType.ReadableStream,
+            bodyFactory: () => bodyInit,
+            contentType: null,
+            contentLength: null,
+        };
+    }
+    if (bodyInit instanceof Blob_js_1.PonyfillBlob) {
+        return {
+            bodyType: BodyInitType.Blob,
+            contentType: bodyInit.type,
+            contentLength: bodyInit.size,
+            bodyFactory() {
+                return bodyInit.stream();
+            },
+        };
+    }
+    if (bodyInit instanceof Buffer) {
+        const contentLength = bodyInit.length;
+        return {
+            bodyType: BodyInitType.Buffer,
+            contentLength,
+            contentType: null,
+            bodyFactory() {
+                const readable = stream_1.Readable.from(bodyInit);
+                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+                return body;
+            },
+        };
+    }
+    if (bodyInit instanceof Uint8Array) {
+        const contentLength = bodyInit.byteLength;
+        return {
+            bodyType: BodyInitType.Uint8Array,
+            contentLength,
+            contentType: null,
+            bodyFactory() {
+                const readable = stream_1.Readable.from(bodyInit);
+                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+                return body;
+            },
+        };
+    }
+    if ('buffer' in bodyInit) {
+        const contentLength = bodyInit.byteLength;
+        return {
+            contentLength,
+            contentType: null,
+            bodyFactory() {
+                const buffer = Buffer.from(bodyInit);
+                const readable = stream_1.Readable.from(buffer);
+                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+                return body;
+            },
+        };
+    }
+    if (bodyInit instanceof ArrayBuffer) {
+        const contentLength = bodyInit.byteLength;
+        return {
+            bodyType: BodyInitType.ArrayBuffer,
+            contentType: null,
+            contentLength,
+            bodyFactory() {
+                const buffer = Buffer.from(bodyInit, undefined, bodyInit.byteLength);
+                const readable = stream_1.Readable.from(buffer);
+                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+                return body;
+            },
+        };
+    }
+    if (bodyInit instanceof stream_1.Readable) {
+        return {
+            bodyType: BodyInitType.Readable,
+            contentType: null,
+            contentLength: null,
+            bodyFactory() {
+                const body = new ReadableStream_js_1.PonyfillReadableStream(bodyInit);
+                return body;
+            },
+        };
+    }
+    if ('stream' in bodyInit) {
+        return {
+            contentType: bodyInit.type,
+            contentLength: bodyInit.size,
+            bodyFactory() {
+                const bodyStream = bodyInit.stream();
+                const body = new ReadableStream_js_1.PonyfillReadableStream(bodyStream);
+                return body;
+            },
+        };
+    }
+    if ('sort' in bodyInit) {
+        const contentType = 'application/x-www-form-urlencoded;charset=UTF-8';
+        return {
+            bodyType: BodyInitType.String,
+            contentType,
+            contentLength: null,
+            bodyFactory() {
+                const body = new ReadableStream_js_1.PonyfillReadableStream(stream_1.Readable.from(bodyInit.toString()));
+                return body;
+            },
+        };
+    }
+    if ('forEach' in bodyInit) {
+        const boundary = Math.random().toString(36).substr(2);
+        const contentType = `multipart/form-data; boundary=${boundary}`;
+        return {
+            contentType,
+            contentLength: null,
+            bodyFactory() {
+                return (0, FormData_js_1.getStreamFromFormData)(bodyInit, boundary);
+            },
+        };
+    }
+    if (bodyInit[Symbol.iterator] || bodyInit[Symbol.asyncIterator]) {
+        return {
+            contentType: null,
+            contentLength: null,
+            bodyFactory() {
+                const readable = stream_1.Readable.from(bodyInit);
+                return new ReadableStream_js_1.PonyfillReadableStream(readable);
+            },
+        };
+    }
+    throw new Error('Unknown body type');
+}

package/cjs/File.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillFile = void 0;
+const Blob_js_1 = require("./Blob.js");
+class PonyfillFile extends Blob_js_1.PonyfillBlob {
+    constructor(fileBits, name, options) {
+        super(fileBits, options);
+        this.name = name;
+        this.webkitRelativePath = '';
+        this.lastModified = (options === null || options === void 0 ? void 0 : options.lastModified) || Date.now();
+    }
+}
+exports.PonyfillFile = PonyfillFile;