@aws-sdk/xhr-http-handler 3.901.0 → 3.910.0

package/dist-cjs/index.js

@@ -1,282 +1,234 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  XhrHttpHandler: () => XhrHttpHandler
-});
-module.exports = __toCommonJS(index_exports);
+'use strict';
 
-// src/xhr-http-handler.ts
-var import_protocol_http = require("@smithy/protocol-http");
-var import_querystring_builder = require("@smithy/querystring-builder");
-var import_events = require("events");
+var protocolHttp = require('@smithy/protocol-http');
+var querystringBuilder = require('@smithy/querystring-builder');
+var events = require('events');
 
-// src/request-timeout.ts
-var requestTimeout = /* @__PURE__ */ __name((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);
-  }
-}), "requestTimeout");
+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);
+    }
+});
 
-// src/xhr-http-handler.ts
-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";
-  }
+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";
+    },
 };
-var XhrHttpHandler = class _XhrHttpHandler extends import_events.EventEmitter {
-  static {
-    __name(this, "XhrHttpHandler");
-  }
-  static EVENTS = EVENTS;
-  static ERROR_IDENTIFIER = "XHR_HTTP_HANDLER_ERROR";
-  config;
-  configProvider;
-  /**
-   * @returns the input if it is an HttpHandler of any class,
-   * or instantiates a new instance of this handler.
-   */
-  static create(instanceOrOptions) {
-    if (typeof instanceOrOptions?.handle === "function") {
-      return instanceOrOptions;
+class XhrHttpHandler extends events.EventEmitter {
+    static EVENTS = EVENTS;
+    static ERROR_IDENTIFIER = "XHR_HTTP_HANDLER_ERROR";
+    config;
+    configProvider;
+    static create(instanceOrOptions) {
+        if (typeof instanceOrOptions?.handle === "function") {
+            return instanceOrOptions;
+        }
+        return new XhrHttpHandler(instanceOrOptions);
     }
-    return new _XhrHttpHandler(instanceOrOptions);
-  }
-  constructor(options) {
-    super();
-    if (typeof options === "function") {
-      this.configProvider = options();
-    } else {
-      this.config = options ?? {};
-      this.configProvider = Promise.resolve(this.config);
+    constructor(options) {
+        super();
+        if (typeof options === "function") {
+            this.configProvider = options();
+        }
+        else {
+            this.config = options ?? {};
+            this.configProvider = Promise.resolve(this.config);
+        }
     }
-  }
-  updateHttpClientConfig(key, value) {
-    this.config = void 0;
-    this.configProvider = this.configProvider.then((config) => {
-      config[key] = value;
-      return config;
-    });
-  }
-  httpHandlerConfigs() {
-    return this.config ?? {};
-  }
-  destroy() {
-  }
-  async handle(request, { abortSignal, requestTimeout: requestTimeout2 } = {}) {
-    if (!this.config) {
-      this.config = await this.configProvider;
+    updateHttpClientConfig(key, value) {
+        this.config = undefined;
+        this.configProvider = this.configProvider.then((config) => {
+            config[key] = value;
+            return config;
+        });
     }
-    const requestTimeoutInMs = Number(requestTimeout2 ?? this.config.requestTimeout) | 0;
-    if (abortSignal?.aborted) {
-      const abortError = new Error("Request aborted");
-      abortError.name = "AbortError";
-      throw abortError;
+    httpHandlerConfigs() {
+        return this.config ?? {};
     }
-    let path = request.path;
-    if (request.query) {
-      const queryString = (0, import_querystring_builder.buildQueryString)(request.query);
-      if (queryString) {
-        path += `?${queryString}`;
-      }
+    destroy() {
     }
-    const { port, method } = request;
-    const url = `${request.protocol}//${request.hostname}${port ? `:${port}` : ""}${path}`;
-    const body = method === "GET" || method === "HEAD" ? void 0 : 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", (err) => {
-          const error = new Error(_XhrHttpHandler.ERROR_IDENTIFIER + ": " + err);
-          reject(error);
-        });
-        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 body2 = (() => {
-                if (isArrayBuffer) {
-                  return new Blob([xhr.response]);
-                }
-                if (isText) {
-                  streamCursor !== xhr.responseText.length && writer.write?.(streamCursor > 0 ? xhr.responseText.slice(streamCursor) : xhr.responseText);
-                  writer.releaseLock();
-                  stream.writable.close();
-                  return stream.readable;
-                }
-                reject(new Error(`Unexpected XHR response type ${xhr.responseType}. Expected string or arraybuffer.`));
-              })();
-              resolve({
-                response: new import_protocol_http.HttpResponse({
-                  headers: this.responseHeaders(xhr.getAllResponseHeaders()),
-                  statusCode: xhr.status,
-                  body: body2
-                })
-              });
-              break;
-          }
-        });
-        xhr.open(method, url);
-        for (const [header, value] of Object.entries(request.headers)) {
-          if (!isForbiddenRequestHeader(header)) {
-            xhr.setRequestHeader(header, value);
-          }
+    async handle(request, { abortSignal, requestTimeout: requestTimeout$1 } = {}) {
+        if (!this.config) {
+            this.config = await this.configProvider;
         }
-        this.emit(EVENTS.BEFORE_XHR_SEND, xhr);
-        xhr.send(body);
-      }),
-      requestTimeout(requestTimeoutInMs)
-    ];
-    let removeSignalEventListener = /* @__PURE__ */ __name(() => {
-    }, "removeSignalEventListener");
-    if (abortSignal) {
-      raceOfPromises.push(
-        new Promise((resolve, reject) => {
-          const onAbort = /* @__PURE__ */ __name(() => {
-            xhr.abort();
+        const requestTimeoutInMs = Number(requestTimeout$1 ?? this.config.requestTimeout) | 0;
+        if (abortSignal?.aborted) {
             const abortError = new Error("Request aborted");
             abortError.name = "AbortError";
-            reject(abortError);
-          }, "onAbort");
-          if (typeof abortSignal.addEventListener === "function") {
-            const signal = abortSignal;
-            signal.addEventListener("abort", onAbort, { once: true });
-            removeSignalEventListener = /* @__PURE__ */ __name(() => signal.removeEventListener("abort", onAbort), "removeSignalEventListener");
-          } else {
-            abortSignal.onabort = onAbort;
-          }
-        })
-      );
+            throw abortError;
+        }
+        let path = request.path;
+        if (request.query) {
+            const queryString = querystringBuilder.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", (err) => {
+                    const error = new Error(XhrHttpHandler.ERROR_IDENTIFIER + ": " + err);
+                    reject(error);
+                });
+                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) {
+                                    streamCursor !== xhr.responseText.length &&
+                                        writer.write?.(streamCursor > 0 ? xhr.responseText.slice(streamCursor) : xhr.responseText);
+                                    writer.releaseLock();
+                                    stream.writable.close();
+                                    return stream.readable;
+                                }
+                                reject(new Error(`Unexpected XHR response type ${xhr.responseType}. Expected string or arraybuffer.`));
+                            })();
+                            resolve({
+                                response: new protocolHttp.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);
+            }),
+            requestTimeout(requestTimeoutInMs),
+        ];
+        let removeSignalEventListener = () => { };
+        if (abortSignal) {
+            raceOfPromises.push(new Promise((resolve, reject) => {
+                const onAbort = () => {
+                    xhr.abort();
+                    const abortError = new Error("Request aborted");
+                    abortError.name = "AbortError";
+                    reject(abortError);
+                };
+                if (typeof abortSignal.addEventListener === "function") {
+                    const signal = abortSignal;
+                    signal.addEventListener("abort", onAbort, { once: true });
+                    removeSignalEventListener = () => signal.removeEventListener("abort", onAbort);
+                }
+                else {
+                    abortSignal.onabort = onAbort;
+                }
+            }));
+        }
+        return Promise.race(raceOfPromises).finally(removeSignalEventListener);
     }
-    return Promise.race(raceOfPromises).finally(removeSignalEventListener);
-  }
-  /**
-   * Converts XHR response headers to a map.
-   * @param xhrHeaders - string to be parsed.
-   */
-  responseHeaders(xhrHeaders) {
-    if (!xhrHeaders) {
-      return {};
+    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,
+        };
+    }
+}
+const isForbiddenRequestHeader = (header) => {
+    header = header.toLowerCase();
+    if (header.startsWith("proxy-")) {
+        return true;
     }
-    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;
-    }, {});
-  }
-  /**
-   * @returns a stream and its default writer to be used to map the xhr response text to a readable stream.
-   */
-  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
-    };
-  }
+    if (header.startsWith("sec-")) {
+        return true;
+    }
+    return forbiddenHeaders.includes(header);
 };
-var isForbiddenRequestHeader = /* @__PURE__ */ __name((header) => {
-  header = header.toLowerCase();
-  if (header.startsWith("proxy-")) {
-    return true;
-  }
-  if (header.startsWith("sec-")) {
-    return true;
-  }
-  return forbiddenHeaders.includes(header);
-}, "isForbiddenRequestHeader");
-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"
+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());
-// Annotate the CommonJS export names for ESM import in node:
-
-0 && (module.exports = {
-  XhrHttpHandler
-});
 
+exports.XhrHttpHandler = XhrHttpHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/xhr-http-handler",
-  "version": "3.901.0",
+  "version": "3.910.0",
   "description": "Provides a way to make requests using XMLHttpRequest",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
@@ -21,15 +21,15 @@
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
   "dependencies": {
-    "@aws-sdk/types": "3.901.0",
-    "@smithy/protocol-http": "^5.3.0",
-    "@smithy/querystring-builder": "^4.2.0",
-    "@smithy/types": "^4.6.0",
+    "@aws-sdk/types": "3.910.0",
+    "@smithy/protocol-http": "^5.3.2",
+    "@smithy/querystring-builder": "^4.2.2",
+    "@smithy/types": "^4.7.1",
     "events": "3.3.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
-    "@smithy/abort-controller": "^4.2.0",
+    "@smithy/abort-controller": "^4.2.2",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",