@aws-sdk/xhr-http-handler 3.131.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+# [3.131.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.130.0...v3.131.0) (2022-07-15)
+
+
+### Features
+
+* **xhr-http-handler:** add XMLHttpRequest http handler to use with lib-storage Upload ([#3798](https://github.com/aws/aws-sdk-js-v3/issues/3798)) ([7462b07](https://github.com/aws/aws-sdk-js-v3/commit/7462b0731e54a29290b9b4c359a7f5581a3c78f9))

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,131 @@
+# @aws-sdk/xhr-http-handler
+
+[![NPM version](https://img.shields.io/npm/v/@aws-sdk/xhr-http-handler/latest.svg)](https://www.npmjs.com/package/@aws-sdk/xhr-http-handler)
+[![NPM downloads](https://img.shields.io/npm/dm/@aws-sdk/xhr-http-handler.svg)](https://www.npmjs.com/package/@aws-sdk/xhr-http-handler)
+
+This `HttpHandler` is based on `XMLHttpRequest` and can be substituted if
+requiring a specific use case not covered by `fetch`.
+
+## Warning :warning:
+
+The recommended `HttpHandler` for browser-like environments is `@aws-sdk/fetch-http-handler`,
+which is the default.
+This alternative has only been tested against `S3` in browsers.
+
+## Polyfills
+
+The following global-scope implementations are accessed by this package:
+
+- `XMLHttpRequest`
+- `TextEncoder`
+- `TransformStream`
+- `Blob`
+
+You will have to supply polyfills, for example for `TextEncoder` and `TransformStream`, for environments
+that do not implement them natively.
+
+### Use case: XMLHttpRequest upload progress events
+
+Use the `Upload` class from the `@aws-sdk/lib-storage` package as normal, except supplying a different
+`HttpHandler` when creating the `S3Client` or `S3` object(s).
+
+See also: [lib-storage/README.md](https://github.com/aws/aws-sdk-js-v3/blob/main/lib/lib-storage/README.md).
+
+```javascript
+import { XhrHttpHandler } from "@aws-sdk/xhr-http-handler";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+
+const client = new S3Client({
+  requestHandler: new XhrHttpHandler({}), // overrides default FetchHttpHandler in browsers.
+});
+
+const upload = new Upload({
+  client,
+  params: {
+    /* ... */
+  },
+});
+
+upload.on("httpUploadProgress", (progress) => {
+  // Note, this event will be emitted much more frequently when using the XhrHttpHandler.
+  // Your application should be ready to throttle the event listener if it is
+  // computationally expensive.
+
+  // The default FetchHttpHandler only emits this event upon the completion of each
+  // part, a minimum of 5 MB. Using XHR will emit this event continuously, including
+  // for files smaller than the chunk size, which use single-part upload.
+  console.log(progress);
+
+  console.log(
+    progress.loaded, // Bytes uploaded so far.
+    progress.total // Total bytes. Divide these two for progress percentage.
+  );
+});
+
+const completeMultiPartUpload = await upload.done();
+```
+
+### Use case: XMLHttpRequest download progress and other events
+
+`XhrHttpHandler` extends `EventEmitter`.
+
+##### Download progress
+
+```javascript
+import { XhrHttpHandler } from "@aws-sdk/xhr-http-handler";
+import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
+
+const handler = new XhrHttpHandler({});
+
+handler.on(XhrHttpHandler.EVENTS.PROGRESS, (progress, request) => {
+  if (progress.lengthComputable) {
+    console.log(
+      progress.loaded, // bytes
+      progress.total, // bytes
+    );
+    console.log(
+      request // contains the request information to differentiate
+              // requests from the same handler.
+    )
+  }
+});
+
+const client = new S3Client({
+  requestHandler: handler,
+});
+
+await client.send(new GetObjectCommand(/*...*/));
+```
+
+##### Accessing the `XMLHttpRequest` object.
+
+You can access the `XMLHttpRequest` object to inspect it or to
+attach addiional event listeners.
+
+```javascript
+import { XhrHttpHandler } from "@aws-sdk/xhr-http-handler";
+import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
+
+const handler = new XhrHttpHandler({});
+
+handler.on(XhrHttpHandler.EVENTS.XHR_INSTANTIATED, (xhr) => {
+  // a new XMLHttpRequest is created for each command sent.
+  // this is immediately after instantiation.
+});
+
+handler.on(XhrHttpHandler.EVENTS.BEFORE_XHR_SEND, (xhr) => {
+  // a new XMLHttpRequest is created for each command sent.
+  // this is immediately before calling `xhr.send(body)`.
+});
+
+const client = new S3Client({
+  requestHandler: handler,
+});
+
+await client.send(new GetObjectCommand(/*...*/));
+```
+
+You can check the source `.ts` file or published `.d.ts` file
+for the full list of events, or inspect the `XhrHttpHandler.EVENTS` 
+object at runtime.

package/dist-cjs/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./xhr-http-handler"), exports);

package/dist-cjs/request-timeout.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestTimeout = void 0;
+const requestTimeout = (timeoutInMs = 0) => new Promise((resolve, reject) => {
+    if (timeoutInMs) {
+        setTimeout(() => {
+            const timeoutError = new Error(`Request did not complete within ${timeoutInMs} ms`);
+            timeoutError.name = "TimeoutError";
+            reject(timeoutError);
+        }, timeoutInMs);
+    }
+});
+exports.requestTimeout = requestTimeout;

package/dist-cjs/xhr-http-handler.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XhrHttpHandler = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const querystring_builder_1 = require("@aws-sdk/querystring-builder");
+const events_1 = require("events");
+const request_timeout_1 = require("./request-timeout");
+const EVENTS = {
+    get PROGRESS() {
+        return "xhr.progress";
+    },
+    get UPLOAD_PROGRESS() {
+        return "xhr.upload.progress";
+    },
+    get XHR_INSTANTIATED() {
+        return "after.xhr.new";
+    },
+    get BEFORE_XHR_SEND() {
+        return "before.xhr.send";
+    },
+};
+class XhrHttpHandler extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        if (typeof options === "function") {
+            this.configProvider = options();
+        }
+        else {
+            this.config = options !== null && options !== void 0 ? options : {};
+            this.configProvider = Promise.resolve(this.config);
+        }
+    }
+    destroy() {
+    }
+    async handle(request, { abortSignal } = {}) {
+        if (!this.config) {
+            this.config = await this.configProvider;
+        }
+        const requestTimeoutInMs = Number(this.config.requestTimeout) | 0;
+        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+            const abortError = new Error("Request aborted");
+            abortError.name = "AbortError";
+            throw abortError;
+        }
+        let path = request.path;
+        if (request.query) {
+            const queryString = (0, querystring_builder_1.buildQueryString)(request.query);
+            if (queryString) {
+                path += `?${queryString}`;
+            }
+        }
+        const { port, method } = request;
+        const url = `${request.protocol}//${request.hostname}${port ? `:${port}` : ""}${path}`;
+        const body = method === "GET" || method === "HEAD" ? undefined : request.body;
+        const xhr = new XMLHttpRequest();
+        this.emit(EVENTS.XHR_INSTANTIATED, xhr);
+        const raceOfPromises = [
+            new Promise((resolve, reject) => {
+                let streamCursor = 0;
+                let stream;
+                let writer;
+                xhr.upload.addEventListener("progress", (event) => {
+                    this.emit(XhrHttpHandler.EVENTS.UPLOAD_PROGRESS, event, request);
+                });
+                xhr.addEventListener("progress", (event) => {
+                    this.emit(XhrHttpHandler.EVENTS.PROGRESS, event, request);
+                });
+                xhr.addEventListener("error", reject);
+                xhr.addEventListener("timeout", () => {
+                    reject(new Error("XMLHttpRequest timed out."));
+                });
+                xhr.addEventListener("readystatechange", () => {
+                    const isArrayBuffer = xhr.responseType === "arraybuffer" && xhr.response;
+                    const isText = !isArrayBuffer && typeof xhr.responseText === "string";
+                    if (isText && !stream) {
+                        ({ stream, writer } = this.initializeTransformStream());
+                    }
+                    switch (xhr.readyState) {
+                        case XMLHttpRequest.LOADING:
+                            if (isText) {
+                                writer.write(streamCursor > 0 ? xhr.responseText.slice(streamCursor) : xhr.responseText);
+                                streamCursor = xhr.responseText.length;
+                            }
+                            break;
+                        case XMLHttpRequest.DONE:
+                            const body = (() => {
+                                if (isArrayBuffer) {
+                                    return new Blob([xhr.response]);
+                                }
+                                if (isText) {
+                                    writer.releaseLock();
+                                    stream.writable.close();
+                                    return stream.readable;
+                                }
+                                reject(new Error(`Unexpected XHR response type ${xhr.responseType}. Expected string or arraybuffer.`));
+                            })();
+                            resolve({
+                                response: new protocol_http_1.HttpResponse({
+                                    headers: this.responseHeaders(xhr.getAllResponseHeaders()),
+                                    statusCode: xhr.status,
+                                    body,
+                                }),
+                            });
+                            break;
+                    }
+                });
+                xhr.open(method, url);
+                for (const [header, value] of Object.entries(request.headers)) {
+                    if (!isForbiddenRequestHeader(header)) {
+                        xhr.setRequestHeader(header, value);
+                    }
+                }
+                this.emit(EVENTS.BEFORE_XHR_SEND, xhr);
+                xhr.send(body);
+            }),
+            (0, request_timeout_1.requestTimeout)(requestTimeoutInMs),
+        ];
+        if (abortSignal) {
+            raceOfPromises.push(new Promise((resolve, reject) => {
+                abortSignal.onabort = () => {
+                    xhr.abort();
+                    const abortError = new Error("Request aborted");
+                    abortError.name = "AbortError";
+                    reject(abortError);
+                };
+            }));
+        }
+        return Promise.race(raceOfPromises);
+    }
+    responseHeaders(xhrHeaders) {
+        if (!xhrHeaders) {
+            return {};
+        }
+        return xhrHeaders.split("\r\n").reduce((headerMap, line) => {
+            const parts = line.split(": ");
+            const header = parts.shift();
+            const value = parts.join(": ");
+            headerMap[header] = value;
+            return headerMap;
+        }, {});
+    }
+    initializeTransformStream() {
+        const textEncoder = new TextEncoder();
+        const stream = new TransformStream({
+            start() { },
+            async transform(chunk, controller) {
+                controller.enqueue(textEncoder.encode(String(chunk)));
+            },
+            flush() { },
+        });
+        const writer = stream.writable.getWriter();
+        return {
+            stream,
+            writer,
+        };
+    }
+}
+exports.XhrHttpHandler = XhrHttpHandler;
+XhrHttpHandler.EVENTS = EVENTS;
+const isForbiddenRequestHeader = (header) => {
+    header = header.toLowerCase();
+    if (header.startsWith("proxy-")) {
+        return true;
+    }
+    if (header.startsWith("sec-")) {
+        return true;
+    }
+    return forbiddenHeaders.includes(header);
+};
+const forbiddenHeaders = [
+    "Accept-Charset",
+    "Accept-Encoding",
+    "Access-Control-Request-Headers",
+    "Access-Control-Request-Method",
+    "Connection",
+    "Content-Length",
+    "Cookie",
+    "Date",
+    "DNT",
+    "Expect",
+    "Feature-Policy",
+    "Host",
+    "Keep-Alive",
+    "Origin",
+    "Referer",
+    "TE",
+    "Trailer",
+    "Transfer-Encoding",
+    "Upgrade",
+    "Via",
+].map((_) => _.toLowerCase());

package/dist-es/index.js

@@ -0,0 +1 @@
+export * from "./xhr-http-handler";

package/dist-es/request-timeout.js

@@ -0,0 +1,12 @@
+export var requestTimeout = function (timeoutInMs) {
+    if (timeoutInMs === void 0) { timeoutInMs = 0; }
+    return new Promise(function (resolve, reject) {
+        if (timeoutInMs) {
+            setTimeout(function () {
+                var timeoutError = new Error("Request did not complete within ".concat(timeoutInMs, " ms"));
+                timeoutError.name = "TimeoutError";
+                reject(timeoutError);
+            }, timeoutInMs);
+        }
+    });
+};

package/dist-es/xhr-http-handler.js

@@ -0,0 +1,223 @@
+import { __awaiter, __extends, __generator, __read, __values } from "tslib";
+import { HttpResponse } from "@aws-sdk/protocol-http";
+import { buildQueryString } from "@aws-sdk/querystring-builder";
+import { EventEmitter } from "events";
+import { requestTimeout } from "./request-timeout";
+var EVENTS = {
+    get PROGRESS() {
+        return "xhr.progress";
+    },
+    get UPLOAD_PROGRESS() {
+        return "xhr.upload.progress";
+    },
+    get XHR_INSTANTIATED() {
+        return "after.xhr.new";
+    },
+    get BEFORE_XHR_SEND() {
+        return "before.xhr.send";
+    },
+};
+var XhrHttpHandler = (function (_super) {
+    __extends(XhrHttpHandler, _super);
+    function XhrHttpHandler(options) {
+        var _this = _super.call(this) || this;
+        if (typeof options === "function") {
+            _this.configProvider = options();
+        }
+        else {
+            _this.config = options !== null && options !== void 0 ? options : {};
+            _this.configProvider = Promise.resolve(_this.config);
+        }
+        return _this;
+    }
+    XhrHttpHandler.prototype.destroy = function () {
+    };
+    XhrHttpHandler.prototype.handle = function (request, _a) {
+        var _b = _a === void 0 ? {} : _a, abortSignal = _b.abortSignal;
+        return __awaiter(this, void 0, void 0, function () {
+            var _c, requestTimeoutInMs, abortError, path, queryString, port, method, url, body, xhr, raceOfPromises;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!!this.config) return [3, 2];
+                        _c = this;
+                        return [4, this.configProvider];
+                    case 1:
+                        _c.config = _d.sent();
+                        _d.label = 2;
+                    case 2:
+                        requestTimeoutInMs = Number(this.config.requestTimeout) | 0;
+                        if (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) {
+                            abortError = new Error("Request aborted");
+                            abortError.name = "AbortError";
+                            throw abortError;
+                        }
+                        path = request.path;
+                        if (request.query) {
+                            queryString = buildQueryString(request.query);
+                            if (queryString) {
+                                path += "?".concat(queryString);
+                            }
+                        }
+                        port = request.port, method = request.method;
+                        url = "".concat(request.protocol, "//").concat(request.hostname).concat(port ? ":".concat(port) : "").concat(path);
+                        body = method === "GET" || method === "HEAD" ? undefined : request.body;
+                        xhr = new XMLHttpRequest();
+                        this.emit(EVENTS.XHR_INSTANTIATED, xhr);
+                        raceOfPromises = [
+                            new Promise(function (resolve, reject) {
+                                var e_1, _a;
+                                var streamCursor = 0;
+                                var stream;
+                                var writer;
+                                xhr.upload.addEventListener("progress", function (event) {
+                                    _this.emit(XhrHttpHandler.EVENTS.UPLOAD_PROGRESS, event, request);
+                                });
+                                xhr.addEventListener("progress", function (event) {
+                                    _this.emit(XhrHttpHandler.EVENTS.PROGRESS, event, request);
+                                });
+                                xhr.addEventListener("error", reject);
+                                xhr.addEventListener("timeout", function () {
+                                    reject(new Error("XMLHttpRequest timed out."));
+                                });
+                                xhr.addEventListener("readystatechange", function () {
+                                    var _a;
+                                    var isArrayBuffer = xhr.responseType === "arraybuffer" && xhr.response;
+                                    var isText = !isArrayBuffer && typeof xhr.responseText === "string";
+                                    if (isText && !stream) {
+                                        (_a = _this.initializeTransformStream(), stream = _a.stream, writer = _a.writer);
+                                    }
+                                    switch (xhr.readyState) {
+                                        case XMLHttpRequest.LOADING:
+                                            if (isText) {
+                                                writer.write(streamCursor > 0 ? xhr.responseText.slice(streamCursor) : xhr.responseText);
+                                                streamCursor = xhr.responseText.length;
+                                            }
+                                            break;
+                                        case XMLHttpRequest.DONE:
+                                            var body_1 = (function () {
+                                                if (isArrayBuffer) {
+                                                    return new Blob([xhr.response]);
+                                                }
+                                                if (isText) {
+                                                    writer.releaseLock();
+                                                    stream.writable.close();
+                                                    return stream.readable;
+                                                }
+                                                reject(new Error("Unexpected XHR response type ".concat(xhr.responseType, ". Expected string or arraybuffer.")));
+                                            })();
+                                            resolve({
+                                                response: new HttpResponse({
+                                                    headers: _this.responseHeaders(xhr.getAllResponseHeaders()),
+                                                    statusCode: xhr.status,
+                                                    body: body_1,
+                                                }),
+                                            });
+                                            break;
+                                    }
+                                });
+                                xhr.open(method, url);
+                                try {
+                                    for (var _b = __values(Object.entries(request.headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                        var _d = __read(_c.value, 2), header = _d[0], value = _d[1];
+                                        if (!isForbiddenRequestHeader(header)) {
+                                            xhr.setRequestHeader(header, value);
+                                        }
+                                    }
+                                }
+                                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                                finally {
+                                    try {
+                                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                                    }
+                                    finally { if (e_1) throw e_1.error; }
+                                }
+                                _this.emit(EVENTS.BEFORE_XHR_SEND, xhr);
+                                xhr.send(body);
+                            }),
+                            requestTimeout(requestTimeoutInMs),
+                        ];
+                        if (abortSignal) {
+                            raceOfPromises.push(new Promise(function (resolve, reject) {
+                                abortSignal.onabort = function () {
+                                    xhr.abort();
+                                    var abortError = new Error("Request aborted");
+                                    abortError.name = "AbortError";
+                                    reject(abortError);
+                                };
+                            }));
+                        }
+                        return [2, Promise.race(raceOfPromises)];
+                }
+            });
+        });
+    };
+    XhrHttpHandler.prototype.responseHeaders = function (xhrHeaders) {
+        if (!xhrHeaders) {
+            return {};
+        }
+        return xhrHeaders.split("\r\n").reduce(function (headerMap, line) {
+            var parts = line.split(": ");
+            var header = parts.shift();
+            var value = parts.join(": ");
+            headerMap[header] = value;
+            return headerMap;
+        }, {});
+    };
+    XhrHttpHandler.prototype.initializeTransformStream = function () {
+        var textEncoder = new TextEncoder();
+        var stream = new TransformStream({
+            start: function () { },
+            transform: function (chunk, controller) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        controller.enqueue(textEncoder.encode(String(chunk)));
+                        return [2];
+                    });
+                });
+            },
+            flush: function () { },
+        });
+        var writer = stream.writable.getWriter();
+        return {
+            stream: stream,
+            writer: writer,
+        };
+    };
+    XhrHttpHandler.EVENTS = EVENTS;
+    return XhrHttpHandler;
+}(EventEmitter));
+export { XhrHttpHandler };
+var isForbiddenRequestHeader = function (header) {
+    header = header.toLowerCase();
+    if (header.startsWith("proxy-")) {
+        return true;
+    }
+    if (header.startsWith("sec-")) {
+        return true;
+    }
+    return forbiddenHeaders.includes(header);
+};
+var forbiddenHeaders = [
+    "Accept-Charset",
+    "Accept-Encoding",
+    "Access-Control-Request-Headers",
+    "Access-Control-Request-Method",
+    "Connection",
+    "Content-Length",
+    "Cookie",
+    "Date",
+    "DNT",
+    "Expect",
+    "Feature-Policy",
+    "Host",
+    "Keep-Alive",
+    "Origin",
+    "Referer",
+    "TE",
+    "Trailer",
+    "Transfer-Encoding",
+    "Upgrade",
+    "Via",
+].map(function (_) { return _.toLowerCase(); });

package/dist-types/index.d.ts

@@ -0,0 +1 @@
+export * from "./xhr-http-handler";

package/dist-types/request-timeout.d.ts

@@ -0,0 +1 @@
+export declare const requestTimeout: (timeoutInMs?: number) => Promise<never>;

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1 @@
+export * from "./xhr-http-handler";

package/dist-types/ts3.4/request-timeout.d.ts

@@ -0,0 +1 @@
+export declare const requestTimeout: (timeoutInMs?: number) => Promise<never>;

package/dist-types/ts3.4/xhr-http-handler.d.ts

@@ -0,0 +1,35 @@
+
+import { HttpHandler, HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
+import { HttpHandlerOptions, Provider } from "@aws-sdk/types";
+import { EventEmitter } from "events";
+
+export interface XhrHttpHandlerOptions {
+    
+    requestTimeout?: number;
+}
+
+export declare type XhrHttpHandlerEvents = {
+    
+    readonly PROGRESS: "xhr.progress";
+    
+    readonly UPLOAD_PROGRESS: "xhr.upload.progress";
+    
+    readonly XHR_INSTANTIATED: "after.xhr.new";
+    
+    readonly BEFORE_XHR_SEND: "before.xhr.send";
+};
+
+export declare class XhrHttpHandler extends EventEmitter implements HttpHandler {
+    static readonly EVENTS: XhrHttpHandlerEvents;
+    private config?;
+    private readonly configProvider;
+    constructor(options?: XhrHttpHandlerOptions | Provider<XhrHttpHandlerOptions>);
+    destroy(): void;
+    handle(request: HttpRequest, { abortSignal }?: HttpHandlerOptions): Promise<{
+        response: HttpResponse;
+    }>;
+    
+    private responseHeaders;
+    
+    private initializeTransformStream;
+}

package/dist-types/xhr-http-handler.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { HttpHandler, HttpRequest, HttpResponse } from "@aws-sdk/protocol-http";
+import { HttpHandlerOptions, Provider } from "@aws-sdk/types";
+import { EventEmitter } from "events";
+/**
+ * Represents the http options that can be passed to the xhr http client.
+ */
+export interface XhrHttpHandlerOptions {
+    /**
+     * The number of milliseconds a request can take before being automatically
+     * terminated.
+     */
+    requestTimeout?: number;
+}
+/**
+ * Events emitted by the XhrHttpHandler class as an EventEmitter.
+ */
+export declare type XhrHttpHandlerEvents = {
+    /**
+     * Emitted for xhr on progress.
+     * Payload is the native ProgressEvent and the HttpRequest to allow
+     * differentiation of multiple concurrent request events.
+     */
+    readonly PROGRESS: "xhr.progress";
+    /**
+     * Emitted for xhr.upload on progress.
+     * Payload is the native ProgressEvent and the HttpRequest to allow
+     * differentiation of multiple concurrent request events.
+     */
+    readonly UPLOAD_PROGRESS: "xhr.upload.progress";
+    /**
+     * Emits with the xhr object after it is instantiated with new.
+     * You can attach additional custom event listeners at this point.
+     */
+    readonly XHR_INSTANTIATED: "after.xhr.new";
+    /**
+     * Emits with the xhr object before the send method is called on it.
+     * You can attach additional custom event listeners at this point.
+     */
+    readonly BEFORE_XHR_SEND: "before.xhr.send";
+};
+/**
+ * An implementation of HttpHandler that uses XMLHttpRequest, which is
+ * traditionally associated with browsers.
+ */
+export declare class XhrHttpHandler extends EventEmitter implements HttpHandler {
+    static readonly EVENTS: XhrHttpHandlerEvents;
+    private config?;
+    private readonly configProvider;
+    constructor(options?: XhrHttpHandlerOptions | Provider<XhrHttpHandlerOptions>);
+    destroy(): void;
+    handle(request: HttpRequest, { abortSignal }?: HttpHandlerOptions): Promise<{
+        response: HttpResponse;
+    }>;
+    /**
+     * Converts XHR response headers to a map.
+     * @param xhrHeaders - string to be parsed.
+     */
+    private responseHeaders;
+    /**
+     * @returns a stream and its default writer to be used to map the xhr response text to a readable stream.
+     */
+    private initializeTransformStream;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@aws-sdk/xhr-http-handler",
+  "version": "3.131.0",
+  "description": "Provides a way to make requests using XMLHttpRequest",
+  "scripts": {
+    "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:es": "tsc -p tsconfig.es.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "test": "jest --coverage"
+  },
+  "author": "AWS SDK for JavaScript Team (https://aws.amazon.com/javascript/)",
+  "license": "Apache-2.0",
+  "main": "./dist-cjs/index.js",
+  "module": "./dist-es/index.js",
+  "types": "./dist-types/index.d.ts",
+  "dependencies": {
+    "@aws-sdk/protocol-http": "3.127.0",
+    "@aws-sdk/querystring-builder": "3.127.0",
+    "@aws-sdk/types": "3.127.0",
+    "@aws-sdk/util-base64-browser": "3.109.0",
+    "events": "3.3.0",
+    "tslib": "^2.3.1"
+  },
+  "devDependencies": {
+    "@aws-sdk/abort-controller": "3.127.0",
+    "@tsconfig/recommended": "1.0.1",
+    "concurrently": "7.0.0",
+    "downlevel-dts": "0.7.0",
+    "rimraf": "3.0.2",
+    "typedoc": "0.19.2",
+    "typescript": "~4.6.2"
+  },
+  "typesVersions": {
+    "<4.0": {
+      "dist-types/*": [
+        "dist-types/ts3.4/*"
+      ]
+    }
+  },
+  "files": [
+    "dist-*"
+  ],
+  "homepage": "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/xhr-http-handler",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aws/aws-sdk-js-v3.git",
+    "directory": "packages/xhr-http-handler"
+  },
+  "bugs": {
+    "url": "https://github.com/aws/aws-sdk-js-v3/issues"
+  }
+}