fetch-har 7.0.0 → 8.0.2

package/CHANGELOG.md

@@ -1,3 +1,35 @@
+## <small>8.0.2 (2022-05-20)</small>
+
+* fix: don't look for a length on `postData.text` if it's undefined (#272) ([cd70c2f](https://github.com/readmeio/fetch-har/commit/cd70c2f)), closes [#272](https://github.com/readmeio/fetch-har/issues/272)
+* fix: pin to node 18.0 (#273) ([9ab5991](https://github.com/readmeio/fetch-har/commit/9ab5991)), closes [#273](https://github.com/readmeio/fetch-har/issues/273)
+* ci: pin ci to node 18.0 ([6ce62ac](https://github.com/readmeio/fetch-har/commit/6ce62ac))
+* ci: pin to node 18.1 because 18.2 has broken cookie header support ([05748b4](https://github.com/readmeio/fetch-har/commit/05748b4))
+
+
+
+## <small>8.0.1 (2022-05-03)</small>
+
+* fix: making har-format types a regular dep ([93dcb7d](https://github.com/readmeio/fetch-har/commit/93dcb7d))
+* chore: don't remove a `@types/` directory that we aren't using ([c915fae](https://github.com/readmeio/fetch-har/commit/c915fae))
+* chore(deps-dev): bump @types/node from 17.0.29 to 17.0.30 (#269) ([e6f62f3](https://github.com/readmeio/fetch-har/commit/e6f62f3)), closes [#269](https://github.com/readmeio/fetch-har/issues/269)
+* chore(deps-dev): bump ts-loader from 7.0.5 to 9.3.0 (#268) ([34877c5](https://github.com/readmeio/fetch-har/commit/34877c5)), closes [#268](https://github.com/readmeio/fetch-har/issues/268)
+* chore(deps-dev): bump typescript from 4.6.3 to 4.6.4 (#267) ([826dcac](https://github.com/readmeio/fetch-har/commit/826dcac)), closes [#267](https://github.com/readmeio/fetch-har/issues/267)
+* chore(deps): bump actions/cache from 3.0.1 to 3.0.2 (#270) ([55e45a6](https://github.com/readmeio/fetch-har/commit/55e45a6)), closes [#270](https://github.com/readmeio/fetch-har/issues/270)
+* chore(deps): bump github/codeql-action from 1 to 2 (#271) ([e29ddce](https://github.com/readmeio/fetch-har/commit/e29ddce)), closes [#271](https://github.com/readmeio/fetch-har/issues/271)
+
+
+
+## 8.0.0 (2022-04-28)
+
+> **BREAKING CHANGE**
+>
+> This library is now written in TypeScript and as a result the main export dist is now contained within a `default` object. If you load it into your codebase with `import` you don't need to do anything, but if you're using `require()` you'll need to do `require('fetch-har').default`.
+
+* feat: adding test for common mocking libraries (#266) ([1cdb0bf](https://github.com/readmeio/fetch-har/commit/1cdb0bf)), closes [#266](https://github.com/readmeio/fetch-har/issues/266)
+* feat: rewriting the library in typescript, adding support for node 18 (#265) ([209cb20](https://github.com/readmeio/fetch-har/commit/209cb20)), closes [#265](https://github.com/readmeio/fetch-har/issues/265)
+
+
+
 ## 7.0.0 (2022-04-26)
 
 > **BREAKING CHANGE**

package/README.md

@@ -1,10 +1,19 @@
 # fetch-har
-[![CI](https://github.com/readmeio/fetch-har/workflows/CI/badge.svg)](https://github.com/readmeio/fetch-har)
-
 Make a [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) request from a HAR definition.
 
+[![CI](https://github.com/readmeio/fetch-har/workflows/CI/badge.svg)](https://github.com/readmeio/fetch-har/)
+[![](https://img.shields.io/npm/v/fetch-har)](https://npm.im/fetch-har)
+[![License](https://img.shields.io/npm/l/fetch-har.svg)](LICENSE)
+
 [![](https://d3vv6lp55qjaqc.cloudfront.net/items/1M3C3j0I0s0j3T362344/Untitled-2.png)](https://readme.io)
 
+## Features
+
+- Supports Node 14+ (including the native `fetch` implementation in Node 18!).
+- Natively works in all browsers that support [fetch](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) without having to use any polyfils.
+- [Tested](https://github.com/readmeio/fetch-har/actions) across Chrome, Safari, Firefox on Mac, Windows, and Linux.
+- Requests can be mocked with [nock](https://npm.im/nock) or [fetch-mock](https://npm.im/fetch-mock).
+
 ## Installation
 
 ```
@@ -15,10 +24,11 @@ npm install --save fetch-har
 ```js
 require('isomorphic-fetch');
 
-// If executing from an environment that doesn't normally provide `fetch()`
-// we'll automatically polyfill in the `Blob`, `File`, and `FormData` APIs
-// with the optional `formdata-node` package (provided you've installed it).
-const fetchHar = require('.');
+// If executing from an environment that doesn't normally provide `fetch()` we'll automatically
+// polyfill in the `Blob`, `File`, and `FormData` APIs with the optional `formdata-node` package
+// (provided you've installed it).
+const fetchHAR = require('fetch-har').default;
+// import fetchHAR from 'fetch-har'); // Or if you're in an ESM codebase.
 
 const har = {
   log: {
@@ -51,7 +61,7 @@ const har = {
   },
 };
 
-fetchHar(har)
+fetchHAR(har)
   .then(res => res.json())
   .then(console.log);
 ```
@@ -68,14 +78,14 @@ Though we recommend either [formdata-node](https://npm.im/formdata-node) or [for
 A custom `User-Agent` header to apply to your request. Please note that browsers have their own handling for these headers in `fetch()` calls so it may not work everywhere; it will always be sent in Node however.
 
 ```js
-await fetchHar(har, { userAgent: 'my-client/1.0' });
+await fetchHAR(har, { userAgent: 'my-client/1.0' });
 ```
 
 ##### files
 An optional object map you can supply to use for `multipart/form-data` file uploads in leu of relying on if the HAR you have has [data URLs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs). It supports Node file buffers and the [File](https://developer.mozilla.org/en-US/docs/Web/API/File) API.
 
 ```js
-await fetchHar(har, { files: {
+await fetchHAR(har, { files: {
   'owlbert.png': await fs.readFile('./owlbert.png'),
   'file.txt': document.querySelector('#some-file-input').files[0],
 } });
@@ -93,7 +103,22 @@ We recommend [form-data-encoder](https://npm.im/form-data-encoder).
 ```js
 const { FormDataEncoder } = require('form-data-encoder');
 
-await fetchHar(har, { multipartEncoder: FormDataEncoder });
+await fetchHAR(har, { multipartEncoder: FormDataEncoder });
 ```
 
 You do **not**, and shouldn't, need to use this option in browser environments.
+
+##### init
+This optional argument lets you supply any option that's available to supply to the [Request constructor](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).
+
+```js
+await fetchHAR(har, {
+  init: {
+    headers: new Headers({
+      'x-custom-header': 'buster',
+    }),
+  },
+})
+```
+
+> ❗ Note that if you supply `body` or `credentials` to this option they may be overridden by what your HAR requires.

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import type { Har } from 'har-format';
+declare type FetchHAROptions = {
+    userAgent?: string;
+    files?: Record<string, Blob | Buffer>;
+    multipartEncoder?: any;
+    init?: RequestInit;
+};
+export default function fetchHAR(har: Har, opts?: FetchHAROptions): Promise<Response>;
+export {};

package/dist/index.js

@@ -0,0 +1,304 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var readable_stream_1 = require("readable-stream");
+var parse_data_url_1 = __importDefault(require("parse-data-url"));
+if (!globalThis.Blob) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-extraneous-dependencies
+        globalThis.Blob = require('formdata-node').Blob;
+    }
+    catch (e) {
+        throw new Error('Since you do not have the Blob API available in this environment you must install the optional `formdata-node` dependency.');
+    }
+}
+if (!globalThis.File) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-extraneous-dependencies
+        globalThis.File = require('formdata-node').File;
+    }
+    catch (e) {
+        throw new Error('Since you do not have the File API available in this environment you must install the optional `formdata-node` dependency.');
+    }
+}
+if (!globalThis.FormData) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-extraneous-dependencies
+        globalThis.FormData = require('formdata-node').FormData;
+    }
+    catch (e) {
+        throw new Error('Since you do not have the FormData API available in this environment you must install the optional `formdata-node` dependency.');
+    }
+}
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function isBuffer(value) {
+    return typeof Buffer !== 'undefined' && Buffer.isBuffer(value);
+}
+function isFile(value) {
+    if (value instanceof File) {
+        // The `Blob` polyfill on Node comes back as being an instanceof `File`. Because passing a Blob into
+        // a File will end up with a corrupted file we want to prevent this.
+        //
+        // This object identity crisis does not happen in the browser.
+        return value.constructor.name === 'File';
+    }
+    return false;
+}
+/**
+ * @license MIT
+ * @see {@link https://github.com/octet-stream/form-data-encoder/blob/master/lib/util/isFunction.ts}
+ */
+function isFunction(value) {
+    return typeof value === 'function';
+}
+/**
+ * We're loading this library in here instead of loading it from `form-data-encoder` because that uses lookbehind
+ * regex in its main encoder that Safari doesn't support so it throws a fatal page exception.
+ *
+ * @license MIT
+ * @see {@link https://github.com/octet-stream/form-data-encoder/blob/master/lib/util/isFormData.ts}
+ */
+function isFormData(value) {
+    return (value &&
+        isFunction(value.constructor) &&
+        value[Symbol.toStringTag] === 'FormData' &&
+        isFunction(value.append) &&
+        isFunction(value.getAll) &&
+        isFunction(value.entries) &&
+        isFunction(value[Symbol.iterator]));
+}
+function fetchHAR(har, opts) {
+    var _a;
+    if (opts === void 0) { opts = {}; }
+    if (!har)
+        throw new Error('Missing HAR definition');
+    if (!har.log || !har.log.entries || !har.log.entries.length)
+        throw new Error('Missing log.entries array');
+    var request = har.log.entries[0].request;
+    var url = request.url;
+    var querystring = '';
+    var options = __assign(__assign({}, (opts.init ? opts.init : {})), { method: request.method });
+    if (!options.headers) {
+        options.headers = new Headers();
+    }
+    else if (typeof options.headers === 'object' && !(options.headers instanceof Headers) && options.headers !== null) {
+        options.headers = new Headers(options.headers);
+    }
+    var headers = options.headers;
+    if ('headers' in request && request.headers.length) {
+        // eslint-disable-next-line consistent-return
+        request.headers.forEach(function (header) {
+            try {
+                return headers.append(header.name, header.value);
+            }
+            catch (err) {
+                // `Headers.append()` will throw errors if the header name is not a legal HTTP header name, like
+                // `X-API-KEY (Header)`. If that happens instead of tossing the error back out, we should silently just ignore
+                // it.
+            }
+        });
+    }
+    if ('cookies' in request && request.cookies.length) {
+        // As the browser fetch API can't set custom cookies for requests, they instead need to be defined on the document
+        // and passed into the request via `credentials: include`. Since this is a browser-specific quirk, that should only
+        // happen in browsers!
+        if (isBrowser()) {
+            request.cookies.forEach(function (cookie) {
+                document.cookie = "".concat(encodeURIComponent(cookie.name), "=").concat(encodeURIComponent(cookie.value));
+            });
+            options.credentials = 'include';
+        }
+        else {
+            headers.append('cookie', request.cookies
+                .map(function (cookie) { return "".concat(encodeURIComponent(cookie.name), "=").concat(encodeURIComponent(cookie.value)); })
+                .join('; '));
+        }
+    }
+    if ('postData' in request) {
+        if ('params' in request.postData) {
+            if (!('mimeType' in request.postData)) {
+                // @ts-expect-error HAR spec requires that `mimeType` is always present but it might not be.
+                request.postData.mimeType = 'application/octet-stream';
+            }
+            switch (request.postData.mimeType) {
+                case 'application/x-www-form-urlencoded':
+                    // Since the content we're handling here is to be encoded as `application/x-www-form-urlencoded`, this should
+                    // override any other Content-Type headers that are present in the HAR. This is how Postman handles this case
+                    // when building code snippets!
+                    //
+                    // https://github.com/github/fetch/issues/263#issuecomment-209530977
+                    headers.set('Content-Type', request.postData.mimeType);
+                    var encodedParams_1 = new URLSearchParams();
+                    request.postData.params.forEach(function (param) { return encodedParams_1.set(param.name, param.value); });
+                    options.body = encodedParams_1.toString();
+                    break;
+                case 'multipart/alternative':
+                case 'multipart/form-data':
+                case 'multipart/mixed':
+                case 'multipart/related':
+                    // If there's a Content-Type header set remove it. We're doing this because when we pass the form data object
+                    // into `fetch` that'll set a proper `Content-Type` header for this request that also includes the boundary
+                    // used on the content.
+                    //
+                    // If we don't do this, then consumers won't be able to parse out the payload because they won't know what
+                    // the boundary to split on it.
+                    if (headers.has('Content-Type')) {
+                        headers["delete"]('Content-Type');
+                    }
+                    var form_1 = new FormData();
+                    if (!isFormData(form_1)) {
+                        // The `form-data` NPM module returns one of two things: a native `FormData` API or its own polyfill.
+                        // Unfortunately this polyfill does not support the full API of the native FormData object so when you load
+                        // `form-data` within a browser environment you'll have two major differences in API:
+                        //
+                        //  * The `.append()` API in `form-data` requires that the third argument is an object containing various,
+                        //    undocumented, options. In the browser, `.append()`'s third argument should only be present when the
+                        //    second is a `Blob` or `USVString`, and when it is present, it should be a filename string.
+                        //  * `form-data` does not expose an `.entries()` API, so the only way to retrieve data out of it for
+                        //    construction of boundary-separated payload content is to use its `.pipe()` API. Since the browser
+                        //    doesn't have this API, you'll be unable to retrieve data out of it.
+                        //
+                        // Now since the native `FormData` API is iterable, and has the `.entries()` iterator, we can easily detect
+                        // if we have a native copy of the FormData API. It's for all of these reasons that we're opting to hard
+                        // crash here because supporting this non-compliant API is more trouble than its worth.
+                        //
+                        // https://github.com/form-data/form-data/issues/124
+                        throw new Error("We've detected you're using a non-spec compliant FormData library. We recommend polyfilling FormData with https://npm.im/formdata-node");
+                    }
+                    request.postData.params.forEach(function (param) {
+                        if ('fileName' in param) {
+                            if (opts.files && param.fileName in opts.files) {
+                                var fileContents = opts.files[param.fileName];
+                                // If the file we've got available to us is a Buffer then we need to convert it so that the FormData
+                                // API can use it.
+                                if (isBuffer(fileContents)) {
+                                    form_1.set(param.name, new File([fileContents], param.fileName, {
+                                        type: param.contentType || null
+                                    }), param.fileName);
+                                    return;
+                                }
+                                else if (isFile(fileContents)) {
+                                    form_1.set(param.name, fileContents, param.fileName);
+                                    return;
+                                }
+                                throw new TypeError('An unknown object has been supplied into the `files` config for use. We only support instances of the File API and Node Buffer objects.');
+                            }
+                            else if ('value' in param) {
+                                var paramBlob = void 0;
+                                var parsed = (0, parse_data_url_1["default"])(param.value);
+                                if (parsed) {
+                                    // If we were able to parse out this data URL we don't need to transform its data into a buffer for
+                                    // `Blob` because that supports data URLs already.
+                                    paramBlob = new Blob([param.value], { type: parsed.contentType || param.contentType || null });
+                                }
+                                else {
+                                    paramBlob = new Blob([param.value], { type: param.contentType || null });
+                                }
+                                form_1.append(param.name, paramBlob, param.fileName);
+                                return;
+                            }
+                            throw new Error("The supplied HAR has a postData parameter with `fileName`, but neither `value` content within the HAR or any file buffers were supplied with the `files` option. Since this library doesn't have access to the filesystem, it can't fetch that file.");
+                        }
+                        form_1.append(param.name, param.value);
+                    });
+                    // If a the `fetch` polyfill that's being used here doesn't have spec-compliant handling for the `FormData`
+                    // API (like `node-fetch@2`), then you should pass in a handler (like the `form-data-encoder` library) to
+                    // transform its contents into something that can be used with the `Request` object.
+                    //
+                    // https://www.npmjs.com/package/formdata-node
+                    if (opts.multipartEncoder) {
+                        // eslint-disable-next-line new-cap
+                        var encoder_1 = new opts.multipartEncoder(form_1);
+                        Object.keys(encoder_1.headers).forEach(function (header) {
+                            headers.set(header, encoder_1.headers[header]);
+                        });
+                        // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
+                        options.body = readable_stream_1.Readable.from(encoder_1);
+                    }
+                    else {
+                        options.body = form_1;
+                    }
+                    break;
+                default:
+                    var formBody_1 = {};
+                    request.postData.params.map(function (param) {
+                        try {
+                            formBody_1[param.name] = JSON.parse(param.value);
+                        }
+                        catch (e) {
+                            formBody_1[param.name] = param.value;
+                        }
+                        return true;
+                    });
+                    options.body = JSON.stringify(formBody_1);
+            }
+        }
+        else if ((_a = request.postData.text) === null || _a === void 0 ? void 0 : _a.length) {
+            // If we've got `files` map content present, and this post data content contains a valid data URL then we can
+            // substitute the payload with that file instead of the using data URL.
+            if (opts.files) {
+                var parsed = (0, parse_data_url_1["default"])(request.postData.text);
+                if (parsed) {
+                    if ((parsed === null || parsed === void 0 ? void 0 : parsed.name) && parsed.name in opts.files) {
+                        var fileContents = opts.files[parsed.name];
+                        if (isBuffer(fileContents)) {
+                            options.body = fileContents;
+                        }
+                        else if (isFile(fileContents)) {
+                            // `Readable.from` isn't available in browsers but the browser `Request` object can handle `File` objects
+                            // just fine without us having to mold it into shape.
+                            if (isBrowser()) {
+                                options.body = fileContents;
+                            }
+                            else {
+                                // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
+                                options.body = readable_stream_1.Readable.from(fileContents.stream());
+                                // Supplying a polyfilled `File` stream into `Request.body` doesn't automatically add `Content-Length`.
+                                if (!headers.has('content-length')) {
+                                    headers.set('content-length', String(fileContents.size));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (typeof options.body === 'undefined') {
+                options.body = request.postData.text;
+            }
+        }
+    }
+    // We automaticaly assume that the HAR that we have already has query parameters encoded within it so we do **not**
+    // use the `URLSearchParams` API here for composing the query string.
+    if ('queryString' in request && request.queryString.length) {
+        var urlObj = new URL(url);
+        var queryParams_1 = Array.from(urlObj.searchParams).map(function (_a) {
+            var k = _a[0], v = _a[1];
+            return "".concat(k, "=").concat(v);
+        });
+        request.queryString.forEach(function (q) {
+            queryParams_1.push("".concat(q.name, "=").concat(q.value));
+        });
+        querystring = queryParams_1.join('&');
+    }
+    if (opts.userAgent) {
+        headers.append('User-Agent', opts.userAgent);
+    }
+    options.headers = headers;
+    return fetch("".concat(url.split('?')[0]).concat(querystring ? "?".concat(querystring) : ''), options);
+}
+exports["default"] = fetchHAR;

package/example.js

@@ -1,10 +1,9 @@
-/* eslint-disable import/no-extraneous-dependencies, no-console */
 require('isomorphic-fetch');
 
 // If executing from an environment that doesn't normally provide `fetch()`
 // we'll automatically polyfill in the `Blob`, `File`, and `FormData` APIs
 // with the optional `formdata-node` package (provided you've installed it).
-const fetchHar = require('.');
+const fetchHAR = require('.').default;
 
 const har = {
   log: {
@@ -37,6 +36,6 @@ const har = {
   },
 };
 
-fetchHar(har)
+fetchHAR(har)
   .then(res => res.json())
   .then(console.log);

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "fetch-har",
-  "version": "7.0.0",
+  "version": "8.0.2",
   "description": "Make a fetch request from a HAR definition",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "engines": {
     "node": ">=14"
   },
   "scripts": {
-    "lint": "eslint .",
+    "build": "tsc",
+    "lint": "eslint . --ext .js,.ts",
+    "prebuild": "rm -rf dist/",
+    "prepack": "npm run build",
     "pretest": "npm run lint",
-    "prettier": "prettier --list-different --write \"./**.js\"",
+    "prettier": "prettier --list-different --write \"./**/**.{js,ts}\"",
     "release": "npx conventional-changelog-cli -i CHANGELOG.md -s",
-    "serve": "node __tests__/server.js",
     "test:browser": "karma start --single-run",
     "test:browser:chrome": "karma start --browsers=Chrome --single-run=false",
     "test:browser:debug": "karma start --single-run=false",
-    "test": "nyc mocha"
+    "test": "nyc mocha \"test/**/*.test.ts\""
   },
   "repository": {
     "type": "git",
@@ -27,6 +30,7 @@
   },
   "homepage": "https://github.com/readmeio/fetch-har#readme",
   "dependencies": {
+    "@types/har-format": "^1.2.8",
     "parse-data-url": "^4.0.1",
     "readable-stream": "^3.6.0"
   },
@@ -36,19 +40,29 @@
   "devDependencies": {
     "@jsdevtools/host-environment": "^2.1.2",
     "@jsdevtools/karma-config": "^3.1.7",
-    "@readme/eslint-config": "^8.7.1",
+    "@readme/eslint-config": "^8.7.3",
+    "@types/chai": "^4.3.1",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^17.0.29",
+    "@types/parse-data-url": "^3.0.0",
+    "@types/readable-stream": "^2.3.13",
     "chai": "^4.3.4",
     "eslint": "^8.14.0",
-    "eslint-plugin-compat": "^4.0.1",
+    "fetch-mock": "^9.11.0",
     "form-data": "^4.0.0",
     "form-data-encoder": "^1.7.1",
     "formdata-node": "^4.3.2",
-    "har-examples": "^3.1.0",
+    "har-examples": "^3.1.1",
     "isomorphic-fetch": "^3.0.0",
     "mocha": "^9.2.2",
+    "nock": "^13.2.4",
     "node-fetch": "^2.6.0",
     "nyc": "^15.1.0",
-    "prettier": "^2.6.2"
+    "prettier": "^2.6.2",
+    "ts-loader": "^9.3.0",
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.3",
+    "undici": "^5.0.0"
   },
   "browserslist": [
     "last 2 versions"

package/{index.js → src/index.ts}

@@ -1,9 +1,10 @@
-const { Readable } = require('readable-stream');
-const parseDataUrl = require('parse-data-url');
+import type { Har } from 'har-format';
+import { Readable } from 'readable-stream';
+import parseDataUrl from 'parse-data-url';
 
 if (!globalThis.Blob) {
   try {
-    // eslint-disable-next-line import/no-extraneous-dependencies
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-extraneous-dependencies
     globalThis.Blob = require('formdata-node').Blob;
   } catch (e) {
     throw new Error(
@@ -14,7 +15,7 @@ if (!globalThis.Blob) {
 
 if (!globalThis.File) {
   try {
-    // eslint-disable-next-line import/no-extraneous-dependencies
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-extraneous-dependencies
     globalThis.File = require('formdata-node').File;
   } catch (e) {
     throw new Error(
@@ -25,7 +26,7 @@ if (!globalThis.File) {
 
 if (!globalThis.FormData) {
   try {
-    // eslint-disable-next-line import/no-extraneous-dependencies
+    // eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-extraneous-dependencies
     globalThis.FormData = require('formdata-node').FormData;
   } catch (e) {
     throw new Error(
@@ -38,11 +39,11 @@ function isBrowser() {
   return typeof window !== 'undefined' && typeof document !== 'undefined';
 }
 
-function isBuffer(value) {
+function isBuffer(value: any) {
   return typeof Buffer !== 'undefined' && Buffer.isBuffer(value);
 }
 
-function isFile(value) {
+function isFile(value: any) {
   if (value instanceof File) {
     // The `Blob` polyfill on Node comes back as being an instanceof `File`. Because passing a Blob into
     // a File will end up with a corrupted file we want to prevent this.
@@ -58,7 +59,7 @@ function isFile(value) {
  * @license MIT
  * @see {@link https://github.com/octet-stream/form-data-encoder/blob/master/lib/util/isFunction.ts}
  */
-function isFunction(value) {
+function isFunction(value: any) {
   return typeof value === 'function';
 }
 
@@ -69,19 +70,32 @@ function isFunction(value) {
  * @license MIT
  * @see {@link https://github.com/octet-stream/form-data-encoder/blob/master/lib/util/isFormData.ts}
  */
-function isFormData(value) {
+function isFormData(value: any) {
   return (
     value &&
     isFunction(value.constructor) &&
-    value[Symbol.toStringTag] === 'FormData' && // eslint-disable-line compat/compat
+    value[Symbol.toStringTag] === 'FormData' &&
     isFunction(value.append) &&
     isFunction(value.getAll) &&
     isFunction(value.entries) &&
-    isFunction(value[Symbol.iterator]) // eslint-disable-line compat/compat
+    isFunction(value[Symbol.iterator])
   );
 }
 
-function constructRequest(har, opts = { userAgent: false, files: false, multipartEncoder: false }) {
+type FetchHAROptions = {
+  userAgent?: string;
+  files?: Record<string, Blob | Buffer>;
+  multipartEncoder?: any; // form-data-encoder
+  init?: RequestInit;
+};
+
+type DataURL = parseDataUrl.DataUrl & {
+  // `parse-data-url` doesn't explicitly support `name` in data URLs but if it's there it'll be
+  // returned back to us.
+  name?: string;
+};
+
+export default function fetchHAR(har: Har, opts: FetchHAROptions = {}) {
   if (!har) throw new Error('Missing HAR definition');
   if (!har.log || !har.log.entries || !har.log.entries.length) throw new Error('Missing log.entries array');
 
@@ -89,11 +103,20 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
   const { url } = request;
   let querystring = '';
 
-  const headers = new Headers();
-  const options = {
+  const options: RequestInit = {
+    // If we have custom options for the `Request` API we need to add them in here now before we
+    // fill it in with everything we need from the HAR.
+    ...(opts.init ? opts.init : {}),
     method: request.method,
   };
 
+  if (!options.headers) {
+    options.headers = new Headers();
+  } else if (typeof options.headers === 'object' && !(options.headers instanceof Headers) && options.headers !== null) {
+    options.headers = new Headers(options.headers);
+  }
+
+  const headers = options.headers as Headers;
   if ('headers' in request && request.headers.length) {
     // eslint-disable-next-line consistent-return
     request.headers.forEach(header => {
@@ -130,6 +153,7 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
   if ('postData' in request) {
     if ('params' in request.postData) {
       if (!('mimeType' in request.postData)) {
+        // @ts-expect-error HAR spec requires that `mimeType` is always present but it might not be.
         request.postData.mimeType = 'application/octet-stream';
       }
 
@@ -203,7 +227,7 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
 
                   return;
                 } else if (isFile(fileContents)) {
-                  form.set(param.name, fileContents, param.fileName);
+                  form.set(param.name, fileContents as Blob, param.fileName);
                   return;
                 }
 
@@ -245,6 +269,7 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
               headers.set(header, encoder.headers[header]);
             });
 
+            // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
             options.body = Readable.from(encoder);
           } else {
             options.body = form;
@@ -252,7 +277,7 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
           break;
 
         default:
-          const formBody = {};
+          const formBody: Record<string, unknown> = {};
           request.postData.params.map(param => {
             try {
               formBody[param.name] = JSON.parse(param.value);
@@ -265,26 +290,29 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
 
           options.body = JSON.stringify(formBody);
       }
-    } else if (request.postData.text.length) {
+    } else if (request.postData.text?.length) {
       // If we've got `files` map content present, and this post data content contains a valid data URL then we can
       // substitute the payload with that file instead of the using data URL.
       if (opts.files) {
-        const parsed = parseDataUrl(request.postData.text);
-        if (parsed && 'name' in parsed && parsed.name in opts.files) {
-          const fileContents = opts.files[parsed.name];
-          if (isBuffer(fileContents)) {
-            options.body = fileContents;
-          } else if (isFile(fileContents)) {
-            // `Readable.from` isn't available in browsers but the browser `Request` object can handle `File` objects
-            // just fine without us having to mold it into shape.
-            if (isBrowser()) {
+        const parsed = parseDataUrl(request.postData.text) as DataURL;
+        if (parsed) {
+          if (parsed?.name && parsed.name in opts.files) {
+            const fileContents = opts.files[parsed.name];
+            if (isBuffer(fileContents)) {
               options.body = fileContents;
-            } else {
-              options.body = Readable.from(fileContents.stream());
-
-              // Supplying a polyfilled `File` stream into `Request.body` doesn't automatically add `Content-Length`.
-              if (!headers.has('content-length')) {
-                headers.set('content-length', fileContents.size);
+            } else if (isFile(fileContents)) {
+              // `Readable.from` isn't available in browsers but the browser `Request` object can handle `File` objects
+              // just fine without us having to mold it into shape.
+              if (isBrowser()) {
+                options.body = fileContents;
+              } else {
+                // @ts-expect-error "Property 'from' does not exist on type 'typeof Readable'." but it does!
+                options.body = Readable.from((fileContents as File).stream());
+
+                // Supplying a polyfilled `File` stream into `Request.body` doesn't automatically add `Content-Length`.
+                if (!headers.has('content-length')) {
+                  headers.set('content-length', String((fileContents as File).size));
+                }
               }
             }
           }
@@ -316,12 +344,5 @@ function constructRequest(har, opts = { userAgent: false, files: false, multipar
 
   options.headers = headers;
 
-  return new Request(`${url.split('?')[0]}${querystring ? `?${querystring}` : ''}`, options);
-}
-
-function fetchHar(har, opts = { userAgent: false, files: false, multipartEncoder: false }) {
-  return fetch(constructRequest(har, opts));
+  return fetch(`${url.split('?')[0]}${querystring ? `?${querystring}` : ''}`, options);
 }
-
-module.exports = fetchHar;
-module.exports.constructRequest = constructRequest;

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "baseUrl": "./src",
+    "declaration": true,
+    "esModuleInterop": true,
+    "lib": ["dom", "es2020"],
+    "noImplicitAny": true,
+    "outDir": "dist/"
+  },
+  "include": ["./src/**/*"]
+}