@aws-sdk/lib-storage 3.183.0 → 3.186.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
+
+**Note:** Version bump only for package @aws-sdk/lib-storage
+
+
+
+
+
+# [3.185.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.184.0...v3.185.0) (2022-10-05)
+
+**Note:** Version bump only for package @aws-sdk/lib-storage
+
+
+
+
+
 # [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
 
 **Note:** Version bump only for package @aws-sdk/lib-storage

package/dist-es/Upload.js

@@ -1,3 +1,4 @@
+import { __assign, __asyncValues, __awaiter, __extends, __generator } from "tslib";
 import { AbortController } from "@aws-sdk/abort-controller";
 import { CompleteMultipartUploadCommand, CreateMultipartUploadCommand, PutObjectCommand, PutObjectTaggingCommand, UploadPartCommand, } from "@aws-sdk/client-s3";
 import { getEndpointFromInstructions, toEndpointV1, } from "@aws-sdk/middleware-endpoint";
@@ -5,252 +6,350 @@ import { extendedEncodeURIComponent } from "@aws-sdk/smithy-client";
 import { EventEmitter } from "events";
 import { byteLength } from "./bytelength";
 import { getChunk } from "./chunker";
-const MIN_PART_SIZE = 1024 * 1024 * 5;
-export class Upload extends EventEmitter {
-    constructor(options) {
-        super();
-        this.MAX_PARTS = 10000;
-        this.queueSize = 4;
-        this.partSize = MIN_PART_SIZE;
-        this.leavePartsOnError = false;
-        this.tags = [];
-        this.concurrentUploaders = [];
-        this.uploadedParts = [];
-        this.isMultiPart = true;
-        this.queueSize = options.queueSize || this.queueSize;
-        this.partSize = options.partSize || this.partSize;
-        this.leavePartsOnError = options.leavePartsOnError || this.leavePartsOnError;
-        this.tags = options.tags || this.tags;
-        this.client = options.client;
-        this.params = options.params;
-        this.__validateInput();
-        this.totalBytes = byteLength(this.params.Body);
-        this.bytesUploadedSoFar = 0;
-        this.abortController = options.abortController ?? new AbortController();
+var MIN_PART_SIZE = 1024 * 1024 * 5;
+var Upload = (function (_super) {
+    __extends(Upload, _super);
+    function Upload(options) {
+        var _this = this;
+        var _a;
+        _this = _super.call(this) || this;
+        _this.MAX_PARTS = 10000;
+        _this.queueSize = 4;
+        _this.partSize = MIN_PART_SIZE;
+        _this.leavePartsOnError = false;
+        _this.tags = [];
+        _this.concurrentUploaders = [];
+        _this.uploadedParts = [];
+        _this.isMultiPart = true;
+        _this.queueSize = options.queueSize || _this.queueSize;
+        _this.partSize = options.partSize || _this.partSize;
+        _this.leavePartsOnError = options.leavePartsOnError || _this.leavePartsOnError;
+        _this.tags = options.tags || _this.tags;
+        _this.client = options.client;
+        _this.params = options.params;
+        _this.__validateInput();
+        _this.totalBytes = byteLength(_this.params.Body);
+        _this.bytesUploadedSoFar = 0;
+        _this.abortController = (_a = options.abortController) !== null && _a !== void 0 ? _a : new AbortController();
+        return _this;
     }
-    async abort() {
-        this.abortController.abort();
-    }
-    async done() {
-        return await Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)]);
-    }
-    on(event, listener) {
-        this.uploadEvent = event;
-        return super.on(event, listener);
-    }
-    async __uploadUsingPut(dataPart) {
-        this.isMultiPart = false;
-        const params = { ...this.params, Body: dataPart.data };
-        const clientConfig = this.client.config;
-        const requestHandler = clientConfig.requestHandler;
-        const eventEmitter = requestHandler instanceof EventEmitter ? requestHandler : null;
-        const uploadEventListener = (event) => {
-            this.bytesUploadedSoFar = event.loaded;
-            this.totalBytes = event.total;
-            this.__notifyProgress({
-                loaded: this.bytesUploadedSoFar,
-                total: this.totalBytes,
-                part: dataPart.partNumber,
-                Key: this.params.Key,
-                Bucket: this.params.Bucket,
+    Upload.prototype.abort = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.abortController.abort();
+                return [2];
             });
-        };
-        if (eventEmitter !== null) {
-            eventEmitter.on("xhr.upload.progress", uploadEventListener);
-        }
-        const resolved = await Promise.all([this.client.send(new PutObjectCommand(params)), clientConfig?.endpoint?.()]);
-        const putResult = resolved[0];
-        let endpoint = resolved[1];
-        if (!endpoint) {
-            endpoint = toEndpointV1(await getEndpointFromInstructions(params, PutObjectCommand, {
-                ...clientConfig,
-            }));
-        }
-        if (!endpoint) {
-            throw new Error('Could not resolve endpoint from S3 "client.config.endpoint()" nor EndpointsV2.');
-        }
-        if (eventEmitter !== null) {
-            eventEmitter.off("xhr.upload.progress", uploadEventListener);
-        }
-        const locationKey = this.params
-            .Key.split("/")
-            .map((segment) => extendedEncodeURIComponent(segment))
-            .join("/");
-        const locationBucket = extendedEncodeURIComponent(this.params.Bucket);
-        const Location = this.client.config.forcePathStyle
-            ? `${endpoint.protocol}//${endpoint.hostname}/${locationBucket}/${locationKey}`
-            : `${endpoint.protocol}//${locationBucket}.${endpoint.hostname}/${locationKey}`;
-        this.singleUploadResult = {
-            ...putResult,
-            Bucket: this.params.Bucket,
-            Key: this.params.Key,
-            Location,
-        };
-        const totalSize = byteLength(dataPart.data);
-        this.__notifyProgress({
-            loaded: totalSize,
-            total: totalSize,
-            part: 1,
-            Key: this.params.Key,
-            Bucket: this.params.Bucket,
         });
-    }
-    async __createMultipartUpload() {
-        if (!this.createMultiPartPromise) {
-            const createCommandParams = { ...this.params, Body: undefined };
-            this.createMultiPartPromise = this.client.send(new CreateMultipartUploadCommand(createCommandParams));
-        }
-        const createMultipartUploadResult = await this.createMultiPartPromise;
-        this.uploadId = createMultipartUploadResult.UploadId;
-    }
-    async __doConcurrentUpload(dataFeeder) {
-        for await (const dataPart of dataFeeder) {
-            if (this.uploadedParts.length > this.MAX_PARTS) {
-                throw new Error(`Exceeded ${this.MAX_PARTS} as part of the upload to ${this.params.Key} and ${this.params.Bucket}.`);
-            }
-            try {
-                if (this.abortController.signal.aborted) {
-                    return;
-                }
-                if (dataPart.partNumber === 1 && dataPart.lastPart) {
-                    return await this.__uploadUsingPut(dataPart);
-                }
-                if (!this.uploadId) {
-                    await this.__createMultipartUpload();
-                    if (this.abortController.signal.aborted) {
-                        return;
-                    }
-                }
-                const partSize = byteLength(dataPart.data) || 0;
-                const requestHandler = this.client.config.requestHandler;
-                const eventEmitter = requestHandler instanceof EventEmitter ? requestHandler : null;
-                let lastSeenBytes = 0;
-                const uploadEventListener = (event, request) => {
-                    const requestPartSize = Number(request.query["partNumber"]) || -1;
-                    if (requestPartSize !== dataPart.partNumber) {
-                        return;
-                    }
-                    if (event.total && partSize) {
-                        this.bytesUploadedSoFar += event.loaded - lastSeenBytes;
-                        lastSeenBytes = event.loaded;
-                    }
-                    this.__notifyProgress({
-                        loaded: this.bytesUploadedSoFar,
-                        total: this.totalBytes,
-                        part: dataPart.partNumber,
-                        Key: this.params.Key,
-                        Bucket: this.params.Bucket,
-                    });
-                };
-                if (eventEmitter !== null) {
-                    eventEmitter.on("xhr.upload.progress", uploadEventListener);
-                }
-                const partResult = await this.client.send(new UploadPartCommand({
-                    ...this.params,
-                    UploadId: this.uploadId,
-                    Body: dataPart.data,
-                    PartNumber: dataPart.partNumber,
-                }));
-                if (eventEmitter !== null) {
-                    eventEmitter.off("xhr.upload.progress", uploadEventListener);
+    };
+    Upload.prototype.done = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, Promise.race([this.__doMultipartUpload(), this.__abortTimeout(this.abortController.signal)])];
+                    case 1: return [2, _a.sent()];
                 }
-                if (this.abortController.signal.aborted) {
-                    return;
-                }
-                if (!partResult.ETag) {
-                    throw new Error(`Part ${dataPart.partNumber} is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?`);
+            });
+        });
+    };
+    Upload.prototype.on = function (event, listener) {
+        this.uploadEvent = event;
+        return _super.prototype.on.call(this, event, listener);
+    };
+    Upload.prototype.__uploadUsingPut = function (dataPart) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var params, clientConfig, requestHandler, eventEmitter, uploadEventListener, resolved, putResult, endpoint, _b, locationKey, locationBucket, Location, totalSize;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.isMultiPart = false;
+                        params = __assign(__assign({}, this.params), { Body: dataPart.data });
+                        clientConfig = this.client.config;
+                        requestHandler = clientConfig.requestHandler;
+                        eventEmitter = requestHandler instanceof EventEmitter ? requestHandler : null;
+                        uploadEventListener = function (event) {
+                            _this.bytesUploadedSoFar = event.loaded;
+                            _this.totalBytes = event.total;
+                            _this.__notifyProgress({
+                                loaded: _this.bytesUploadedSoFar,
+                                total: _this.totalBytes,
+                                part: dataPart.partNumber,
+                                Key: _this.params.Key,
+                                Bucket: _this.params.Bucket,
+                            });
+                        };
+                        if (eventEmitter !== null) {
+                            eventEmitter.on("xhr.upload.progress", uploadEventListener);
+                        }
+                        return [4, Promise.all([this.client.send(new PutObjectCommand(params)), (_a = clientConfig === null || clientConfig === void 0 ? void 0 : clientConfig.endpoint) === null || _a === void 0 ? void 0 : _a.call(clientConfig)])];
+                    case 1:
+                        resolved = _c.sent();
+                        putResult = resolved[0];
+                        endpoint = resolved[1];
+                        if (!!endpoint) return [3, 3];
+                        _b = toEndpointV1;
+                        return [4, getEndpointFromInstructions(params, PutObjectCommand, __assign({}, clientConfig))];
+                    case 2:
+                        endpoint = _b.apply(void 0, [_c.sent()]);
+                        _c.label = 3;
+                    case 3:
+                        if (!endpoint) {
+                            throw new Error('Could not resolve endpoint from S3 "client.config.endpoint()" nor EndpointsV2.');
+                        }
+                        if (eventEmitter !== null) {
+                            eventEmitter.off("xhr.upload.progress", uploadEventListener);
+                        }
+                        locationKey = this.params
+                            .Key.split("/")
+                            .map(function (segment) { return extendedEncodeURIComponent(segment); })
+                            .join("/");
+                        locationBucket = extendedEncodeURIComponent(this.params.Bucket);
+                        Location = this.client.config.forcePathStyle
+                            ? "".concat(endpoint.protocol, "//").concat(endpoint.hostname, "/").concat(locationBucket, "/").concat(locationKey)
+                            : "".concat(endpoint.protocol, "//").concat(locationBucket, ".").concat(endpoint.hostname, "/").concat(locationKey);
+                        this.singleUploadResult = __assign(__assign({}, putResult), { Bucket: this.params.Bucket, Key: this.params.Key, Location: Location });
+                        totalSize = byteLength(dataPart.data);
+                        this.__notifyProgress({
+                            loaded: totalSize,
+                            total: totalSize,
+                            part: 1,
+                            Key: this.params.Key,
+                            Bucket: this.params.Bucket,
+                        });
+                        return [2];
                 }
-                this.uploadedParts.push({
-                    PartNumber: dataPart.partNumber,
-                    ETag: partResult.ETag,
-                    ...(partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 }),
-                    ...(partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C }),
-                    ...(partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 }),
-                    ...(partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 }),
-                });
-                if (eventEmitter === null) {
-                    this.bytesUploadedSoFar += partSize;
+            });
+        });
+    };
+    Upload.prototype.__createMultipartUpload = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var createCommandParams, createMultipartUploadResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.createMultiPartPromise) {
+                            createCommandParams = __assign(__assign({}, this.params), { Body: undefined });
+                            this.createMultiPartPromise = this.client.send(new CreateMultipartUploadCommand(createCommandParams));
+                        }
+                        return [4, this.createMultiPartPromise];
+                    case 1:
+                        createMultipartUploadResult = _a.sent();
+                        this.uploadId = createMultipartUploadResult.UploadId;
+                        return [2];
                 }
-                this.__notifyProgress({
-                    loaded: this.bytesUploadedSoFar,
-                    total: this.totalBytes,
-                    part: dataPart.partNumber,
-                    Key: this.params.Key,
-                    Bucket: this.params.Bucket,
-                });
-            }
-            catch (e) {
-                if (!this.uploadId) {
-                    throw e;
+            });
+        });
+    };
+    Upload.prototype.__doConcurrentUpload = function (dataFeeder) {
+        var dataFeeder_1, dataFeeder_1_1;
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _loop_1, this_1, state_1, e_1_1;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 6, 7, 12]);
+                        _loop_1 = function () {
+                            var dataPart, _c, partSize_1, requestHandler, eventEmitter, lastSeenBytes_1, uploadEventListener, partResult, e_2;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        dataPart = dataFeeder_1_1.value;
+                                        if (this_1.uploadedParts.length > this_1.MAX_PARTS) {
+                                            throw new Error("Exceeded ".concat(this_1.MAX_PARTS, " as part of the upload to ").concat(this_1.params.Key, " and ").concat(this_1.params.Bucket, "."));
+                                        }
+                                        _d.label = 1;
+                                    case 1:
+                                        _d.trys.push([1, 7, , 8]);
+                                        if (this_1.abortController.signal.aborted) {
+                                            return [2, { value: void 0 }];
+                                        }
+                                        if (!(dataPart.partNumber === 1 && dataPart.lastPart)) return [3, 3];
+                                        _c = {};
+                                        return [4, this_1.__uploadUsingPut(dataPart)];
+                                    case 2: return [2, (_c.value = _d.sent(), _c)];
+                                    case 3:
+                                        if (!!this_1.uploadId) return [3, 5];
+                                        return [4, this_1.__createMultipartUpload()];
+                                    case 4:
+                                        _d.sent();
+                                        if (this_1.abortController.signal.aborted) {
+                                            return [2, { value: void 0 }];
+                                        }
+                                        _d.label = 5;
+                                    case 5:
+                                        partSize_1 = byteLength(dataPart.data) || 0;
+                                        requestHandler = this_1.client.config.requestHandler;
+                                        eventEmitter = requestHandler instanceof EventEmitter ? requestHandler : null;
+                                        lastSeenBytes_1 = 0;
+                                        uploadEventListener = function (event, request) {
+                                            var requestPartSize = Number(request.query["partNumber"]) || -1;
+                                            if (requestPartSize !== dataPart.partNumber) {
+                                                return;
+                                            }
+                                            if (event.total && partSize_1) {
+                                                _this.bytesUploadedSoFar += event.loaded - lastSeenBytes_1;
+                                                lastSeenBytes_1 = event.loaded;
+                                            }
+                                            _this.__notifyProgress({
+                                                loaded: _this.bytesUploadedSoFar,
+                                                total: _this.totalBytes,
+                                                part: dataPart.partNumber,
+                                                Key: _this.params.Key,
+                                                Bucket: _this.params.Bucket,
+                                            });
+                                        };
+                                        if (eventEmitter !== null) {
+                                            eventEmitter.on("xhr.upload.progress", uploadEventListener);
+                                        }
+                                        return [4, this_1.client.send(new UploadPartCommand(__assign(__assign({}, this_1.params), { UploadId: this_1.uploadId, Body: dataPart.data, PartNumber: dataPart.partNumber })))];
+                                    case 6:
+                                        partResult = _d.sent();
+                                        if (eventEmitter !== null) {
+                                            eventEmitter.off("xhr.upload.progress", uploadEventListener);
+                                        }
+                                        if (this_1.abortController.signal.aborted) {
+                                            return [2, { value: void 0 }];
+                                        }
+                                        if (!partResult.ETag) {
+                                            throw new Error("Part ".concat(dataPart.partNumber, " is missing ETag in UploadPart response. Missing Bucket CORS configuration for ETag header?"));
+                                        }
+                                        this_1.uploadedParts.push(__assign(__assign(__assign(__assign({ PartNumber: dataPart.partNumber, ETag: partResult.ETag }, (partResult.ChecksumCRC32 && { ChecksumCRC32: partResult.ChecksumCRC32 })), (partResult.ChecksumCRC32C && { ChecksumCRC32C: partResult.ChecksumCRC32C })), (partResult.ChecksumSHA1 && { ChecksumSHA1: partResult.ChecksumSHA1 })), (partResult.ChecksumSHA256 && { ChecksumSHA256: partResult.ChecksumSHA256 })));
+                                        if (eventEmitter === null) {
+                                            this_1.bytesUploadedSoFar += partSize_1;
+                                        }
+                                        this_1.__notifyProgress({
+                                            loaded: this_1.bytesUploadedSoFar,
+                                            total: this_1.totalBytes,
+                                            part: dataPart.partNumber,
+                                            Key: this_1.params.Key,
+                                            Bucket: this_1.params.Bucket,
+                                        });
+                                        return [3, 8];
+                                    case 7:
+                                        e_2 = _d.sent();
+                                        if (!this_1.uploadId) {
+                                            throw e_2;
+                                        }
+                                        if (this_1.leavePartsOnError) {
+                                            throw e_2;
+                                        }
+                                        return [3, 8];
+                                    case 8: return [2];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        dataFeeder_1 = __asyncValues(dataFeeder);
+                        _b.label = 1;
+                    case 1: return [4, dataFeeder_1.next()];
+                    case 2:
+                        if (!(dataFeeder_1_1 = _b.sent(), !dataFeeder_1_1.done)) return [3, 5];
+                        return [5, _loop_1()];
+                    case 3:
+                        state_1 = _b.sent();
+                        if (typeof state_1 === "object")
+                            return [2, state_1.value];
+                        _b.label = 4;
+                    case 4: return [3, 1];
+                    case 5: return [3, 12];
+                    case 6:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3, 12];
+                    case 7:
+                        _b.trys.push([7, , 10, 11]);
+                        if (!(dataFeeder_1_1 && !dataFeeder_1_1.done && (_a = dataFeeder_1.return))) return [3, 9];
+                        return [4, _a.call(dataFeeder_1)];
+                    case 8:
+                        _b.sent();
+                        _b.label = 9;
+                    case 9: return [3, 11];
+                    case 10:
+                        if (e_1) throw e_1.error;
+                        return [7];
+                    case 11: return [7];
+                    case 12: return [2];
                 }
-                if (this.leavePartsOnError) {
-                    throw e;
+            });
+        });
+    };
+    Upload.prototype.__doMultipartUpload = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var dataFeeder, index, currentUpload, result, uploadCompleteParams;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dataFeeder = getChunk(this.params.Body, this.partSize);
+                        for (index = 0; index < this.queueSize; index++) {
+                            currentUpload = this.__doConcurrentUpload(dataFeeder);
+                            this.concurrentUploaders.push(currentUpload);
+                        }
+                        return [4, Promise.all(this.concurrentUploaders)];
+                    case 1:
+                        _a.sent();
+                        if (this.abortController.signal.aborted) {
+                            throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
+                        }
+                        if (!this.isMultiPart) return [3, 3];
+                        this.uploadedParts.sort(function (a, b) { return a.PartNumber - b.PartNumber; });
+                        uploadCompleteParams = __assign(__assign({}, this.params), { Body: undefined, UploadId: this.uploadId, MultipartUpload: {
+                                Parts: this.uploadedParts,
+                            } });
+                        return [4, this.client.send(new CompleteMultipartUploadCommand(uploadCompleteParams))];
+                    case 2:
+                        result = _a.sent();
+                        return [3, 4];
+                    case 3:
+                        result = this.singleUploadResult;
+                        _a.label = 4;
+                    case 4:
+                        if (!this.tags.length) return [3, 6];
+                        return [4, this.client.send(new PutObjectTaggingCommand(__assign(__assign({}, this.params), { Tagging: {
+                                    TagSet: this.tags,
+                                } })))];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [2, result];
                 }
-            }
-        }
-    }
-    async __doMultipartUpload() {
-        const dataFeeder = getChunk(this.params.Body, this.partSize);
-        for (let index = 0; index < this.queueSize; index++) {
-            const currentUpload = this.__doConcurrentUpload(dataFeeder);
-            this.concurrentUploaders.push(currentUpload);
-        }
-        await Promise.all(this.concurrentUploaders);
-        if (this.abortController.signal.aborted) {
-            throw Object.assign(new Error("Upload aborted."), { name: "AbortError" });
-        }
-        let result;
-        if (this.isMultiPart) {
-            this.uploadedParts.sort((a, b) => a.PartNumber - b.PartNumber);
-            const uploadCompleteParams = {
-                ...this.params,
-                Body: undefined,
-                UploadId: this.uploadId,
-                MultipartUpload: {
-                    Parts: this.uploadedParts,
-                },
-            };
-            result = await this.client.send(new CompleteMultipartUploadCommand(uploadCompleteParams));
-        }
-        else {
-            result = this.singleUploadResult;
-        }
-        if (this.tags.length) {
-            await this.client.send(new PutObjectTaggingCommand({
-                ...this.params,
-                Tagging: {
-                    TagSet: this.tags,
-                },
-            }));
-        }
-        return result;
-    }
-    __notifyProgress(progress) {
+            });
+        });
+    };
+    Upload.prototype.__notifyProgress = function (progress) {
         if (this.uploadEvent) {
             this.emit(this.uploadEvent, progress);
         }
-    }
-    async __abortTimeout(abortSignal) {
-        return new Promise((resolve, reject) => {
-            abortSignal.onabort = () => {
-                const abortError = new Error("Upload aborted.");
-                abortError.name = "AbortError";
-                reject(abortError);
-            };
+    };
+    Upload.prototype.__abortTimeout = function (abortSignal) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2, new Promise(function (resolve, reject) {
+                        abortSignal.onabort = function () {
+                            var abortError = new Error("Upload aborted.");
+                            abortError.name = "AbortError";
+                            reject(abortError);
+                        };
+                    })];
+            });
         });
-    }
-    __validateInput() {
+    };
+    Upload.prototype.__validateInput = function () {
         if (!this.params) {
-            throw new Error(`InputError: Upload requires params to be passed to upload.`);
+            throw new Error("InputError: Upload requires params to be passed to upload.");
         }
         if (!this.client) {
-            throw new Error(`InputError: Upload requires a AWS client to do uploads with.`);
+            throw new Error("InputError: Upload requires a AWS client to do uploads with.");
         }
         if (this.partSize < MIN_PART_SIZE) {
-            throw new Error(`EntityTooSmall: Your proposed upload partsize [${this.partSize}] is smaller than the minimum allowed size [${MIN_PART_SIZE}] (5MB)`);
+            throw new Error("EntityTooSmall: Your proposed upload partsize [".concat(this.partSize, "] is smaller than the minimum allowed size [").concat(MIN_PART_SIZE, "] (5MB)"));
         }
         if (this.queueSize < 1) {
-            throw new Error(`Queue size: Must have at least one uploading queue.`);
+            throw new Error("Queue size: Must have at least one uploading queue.");
         }
-    }
-}
+    };
+    return Upload;
+}(EventEmitter));
+export { Upload };

package/dist-es/bytelength.js

@@ -1,5 +1,5 @@
 import { ClientDefaultValues } from "./runtimeConfig";
-export const byteLength = (input) => {
+export var byteLength = function (input) {
     if (input === null || input === undefined)
         return 0;
     if (typeof input === "string")

package/dist-es/chunker.js

@@ -4,7 +4,7 @@ import { getChunkBuffer } from "./chunks/getChunkBuffer";
 import { getChunkStream } from "./chunks/getChunkStream";
 import { getDataReadable } from "./chunks/getDataReadable";
 import { getDataReadableStream } from "./chunks/getDataReadableStream";
-export const getChunk = (data, partSize) => {
+export var getChunk = function (data, partSize) {
     if (data instanceof Buffer) {
         return getChunkBuffer(data, partSize);
     }

package/dist-es/chunks/getChunkBuffer.js

@@ -1,19 +1,37 @@
-export async function* getChunkBuffer(data, partSize) {
-    let partNumber = 1;
-    let startByte = 0;
-    let endByte = partSize;
-    while (endByte < data.byteLength) {
-        yield {
-            partNumber,
-            data: data.slice(startByte, endByte),
-        };
-        partNumber += 1;
-        startByte = endByte;
-        endByte = startByte + partSize;
-    }
-    yield {
-        partNumber,
-        data: data.slice(startByte),
-        lastPart: true,
-    };
+import { __asyncGenerator, __await, __generator } from "tslib";
+export function getChunkBuffer(data, partSize) {
+    return __asyncGenerator(this, arguments, function getChunkBuffer_1() {
+        var partNumber, startByte, endByte;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    partNumber = 1;
+                    startByte = 0;
+                    endByte = partSize;
+                    _a.label = 1;
+                case 1:
+                    if (!(endByte < data.byteLength)) return [3, 4];
+                    return [4, __await({
+                            partNumber: partNumber,
+                            data: data.slice(startByte, endByte),
+                        })];
+                case 2: return [4, _a.sent()];
+                case 3:
+                    _a.sent();
+                    partNumber += 1;
+                    startByte = endByte;
+                    endByte = startByte + partSize;
+                    return [3, 1];
+                case 4: return [4, __await({
+                        partNumber: partNumber,
+                        data: data.slice(startByte),
+                        lastPart: true,
+                    })];
+                case 5: return [4, _a.sent()];
+                case 6:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    });
 }

package/dist-es/chunks/getChunkStream.js

@@ -1,24 +1,68 @@
+import { __asyncGenerator, __asyncValues, __await, __generator } from "tslib";
 import { Buffer } from "buffer";
-export async function* getChunkStream(data, partSize, getNextData) {
-    let partNumber = 1;
-    const currentBuffer = { chunks: [], length: 0 };
-    for await (const datum of getNextData(data)) {
-        currentBuffer.chunks.push(datum);
-        currentBuffer.length += datum.length;
-        while (currentBuffer.length >= partSize) {
-            const dataChunk = currentBuffer.chunks.length > 1 ? Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
-            yield {
-                partNumber,
-                data: dataChunk.slice(0, partSize),
-            };
-            currentBuffer.chunks = [dataChunk.slice(partSize)];
-            currentBuffer.length = currentBuffer.chunks[0].length;
-            partNumber += 1;
-        }
-    }
-    yield {
-        partNumber,
-        data: Buffer.concat(currentBuffer.chunks),
-        lastPart: true,
-    };
+export function getChunkStream(data, partSize, getNextData) {
+    return __asyncGenerator(this, arguments, function getChunkStream_1() {
+        var partNumber, currentBuffer, _a, _b, datum, dataChunk, e_1_1;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    partNumber = 1;
+                    currentBuffer = { chunks: [], length: 0 };
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 9, 10, 15]);
+                    _a = __asyncValues(getNextData(data));
+                    _d.label = 2;
+                case 2: return [4, __await(_a.next())];
+                case 3:
+                    if (!(_b = _d.sent(), !_b.done)) return [3, 8];
+                    datum = _b.value;
+                    currentBuffer.chunks.push(datum);
+                    currentBuffer.length += datum.length;
+                    _d.label = 4;
+                case 4:
+                    if (!(currentBuffer.length >= partSize)) return [3, 7];
+                    dataChunk = currentBuffer.chunks.length > 1 ? Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
+                    return [4, __await({
+                            partNumber: partNumber,
+                            data: dataChunk.slice(0, partSize),
+                        })];
+                case 5: return [4, _d.sent()];
+                case 6:
+                    _d.sent();
+                    currentBuffer.chunks = [dataChunk.slice(partSize)];
+                    currentBuffer.length = currentBuffer.chunks[0].length;
+                    partNumber += 1;
+                    return [3, 4];
+                case 7: return [3, 2];
+                case 8: return [3, 15];
+                case 9:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 15];
+                case 10:
+                    _d.trys.push([10, , 13, 14]);
+                    if (!(_b && !_b.done && (_c = _a.return))) return [3, 12];
+                    return [4, __await(_c.call(_a))];
+                case 11:
+                    _d.sent();
+                    _d.label = 12;
+                case 12: return [3, 14];
+                case 13:
+                    if (e_1) throw e_1.error;
+                    return [7];
+                case 14: return [7];
+                case 15: return [4, __await({
+                        partNumber: partNumber,
+                        data: Buffer.concat(currentBuffer.chunks),
+                        lastPart: true,
+                    })];
+                case 16: return [4, _d.sent()];
+                case 17:
+                    _d.sent();
+                    return [2];
+            }
+        });
+    });
 }

package/dist-es/chunks/getDataReadable.js

@@ -1,6 +1,44 @@
+import { __asyncGenerator, __asyncValues, __await, __generator } from "tslib";
 import { Buffer } from "buffer";
-export async function* getDataReadable(data) {
-    for await (const chunk of data) {
-        yield Buffer.from(chunk);
-    }
+export function getDataReadable(data) {
+    return __asyncGenerator(this, arguments, function getDataReadable_1() {
+        var data_1, data_1_1, chunk, e_1_1;
+        var e_1, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 7, 8, 13]);
+                    data_1 = __asyncValues(data);
+                    _b.label = 1;
+                case 1: return [4, __await(data_1.next())];
+                case 2:
+                    if (!(data_1_1 = _b.sent(), !data_1_1.done)) return [3, 6];
+                    chunk = data_1_1.value;
+                    return [4, __await(Buffer.from(chunk))];
+                case 3: return [4, _b.sent()];
+                case 4:
+                    _b.sent();
+                    _b.label = 5;
+                case 5: return [3, 1];
+                case 6: return [3, 13];
+                case 7:
+                    e_1_1 = _b.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3, 13];
+                case 8:
+                    _b.trys.push([8, , 11, 12]);
+                    if (!(data_1_1 && !data_1_1.done && (_a = data_1.return))) return [3, 10];
+                    return [4, __await(_a.call(data_1))];
+                case 9:
+                    _b.sent();
+                    _b.label = 10;
+                case 10: return [3, 12];
+                case 11:
+                    if (e_1) throw e_1.error;
+                    return [7];
+                case 12: return [7];
+                case 13: return [2];
+            }
+        });
+    });
 }

package/dist-es/chunks/getDataReadableStream.js

@@ -1,18 +1,38 @@
+import { __asyncGenerator, __await, __generator } from "tslib";
 import { Buffer } from "buffer";
-export async function* getDataReadableStream(data) {
-    const reader = data.getReader();
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                return;
-            yield Buffer.from(value);
-        }
-    }
-    catch (e) {
-        throw e;
-    }
-    finally {
-        reader.releaseLock();
-    }
+export function getDataReadableStream(data) {
+    return __asyncGenerator(this, arguments, function getDataReadableStream_1() {
+        var reader, _a, done, value, e_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = data.getReader();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 9, 10, 11]);
+                    _b.label = 2;
+                case 2:
+                    if (!true) return [3, 8];
+                    return [4, __await(reader.read())];
+                case 3:
+                    _a = _b.sent(), done = _a.done, value = _a.value;
+                    if (!done) return [3, 5];
+                    return [4, __await(void 0)];
+                case 4: return [2, _b.sent()];
+                case 5: return [4, __await(Buffer.from(value))];
+                case 6: return [4, _b.sent()];
+                case 7:
+                    _b.sent();
+                    return [3, 2];
+                case 8: return [3, 11];
+                case 9:
+                    e_1 = _b.sent();
+                    throw e_1;
+                case 10:
+                    reader.releaseLock();
+                    return [7];
+                case 11: return [2];
+            }
+        });
+    });
 }

package/dist-es/runtimeConfig.browser.js

@@ -1,5 +1,3 @@
+import { __assign } from "tslib";
 import { ClientSharedValues } from "./runtimeConfig.shared";
-export const ClientDefaultValues = {
-    ...ClientSharedValues,
-    runtime: "browser",
-};
+export var ClientDefaultValues = __assign(__assign({}, ClientSharedValues), { runtime: "browser" });

package/dist-es/runtimeConfig.js

@@ -1,7 +1,4 @@
+import { __assign } from "tslib";
 import { lstatSync } from "fs";
 import { ClientSharedValues } from "./runtimeConfig.shared";
-export const ClientDefaultValues = {
-    ...ClientSharedValues,
-    runtime: "node",
-    lstatSync,
-};
+export var ClientDefaultValues = __assign(__assign({}, ClientSharedValues), { runtime: "node", lstatSync: lstatSync });

package/dist-es/runtimeConfig.native.js

@@ -1,5 +1,3 @@
+import { __assign } from "tslib";
 import { ClientDefaultValues as BrowserDefaults } from "./runtimeConfig.browser";
-export const ClientDefaultValues = {
-    ...BrowserDefaults,
-    runtime: "react-native",
-};
+export var ClientDefaultValues = __assign(__assign({}, BrowserDefaults), { runtime: "react-native" });

package/dist-es/runtimeConfig.shared.js

@@ -1,3 +1,3 @@
-export const ClientSharedValues = {
-    lstatSync: () => { },
+export var ClientSharedValues = {
+    lstatSync: function () { },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/lib-storage",
-  "version": "3.183.0",
+  "version": "3.186.0",
   "description": "Storage higher order operation",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -24,8 +24,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/middleware-endpoint": "3.183.0",
-    "@aws-sdk/smithy-client": "3.183.0",
+    "@aws-sdk/middleware-endpoint": "3.186.0",
+    "@aws-sdk/smithy-client": "3.186.0",
     "buffer": "5.6.0",
     "events": "3.3.0",
     "stream-browserify": "3.0.0",
@@ -36,9 +36,9 @@
     "@aws-sdk/client-s3": "^3.0.0"
   },
   "devDependencies": {
-    "@aws-sdk/abort-controller": "3.183.0",
-    "@aws-sdk/client-s3": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
+    "@aws-sdk/abort-controller": "3.186.0",
+    "@aws-sdk/client-s3": "3.186.0",
+    "@aws-sdk/types": "3.186.0",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^14.11.2",
     "concurrently": "7.0.0",