@aws-sdk/sha256-tree-hash 3.186.0 → 3.190.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.190.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.189.0...v3.190.0) (2022-10-17)
+
+**Note:** Version bump only for package @aws-sdk/sha256-tree-hash
+
+
+
+
+
+# [3.188.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.187.0...v3.188.0) (2022-10-13)
+
+**Note:** Version bump only for package @aws-sdk/sha256-tree-hash
+
+
+
+
+
 # [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/sha256-tree-hash

package/dist-es/index.js

@@ -1,86 +1,67 @@
-import { __awaiter, __generator, __read } from "tslib";
-var MiB = 1048576;
-var TreeHash = (function () {
-    function TreeHash(Sha256, fromUtf8) {
+const MiB = 1048576;
+export class TreeHash {
+    constructor(Sha256, fromUtf8) {
         this.Sha256 = Sha256;
         this.fromUtf8 = fromUtf8;
         this.collectedHashDigests = [];
     }
-    TreeHash.prototype.hashBuffer = function () {
+    hashBuffer() {
         if (!this.buffer) {
             return;
         }
-        var remainingSize = this.buffer.byteLength;
+        let remainingSize = this.buffer.byteLength;
         while (remainingSize >= MiB) {
-            var hash = new this.Sha256();
+            const hash = new this.Sha256();
             hash.update(this.buffer.subarray(0, MiB));
             this.collectedHashDigests.push(hash.digest());
             this.buffer = this.buffer.subarray(MiB);
             remainingSize = this.buffer.byteLength;
         }
-    };
-    TreeHash.prototype.update = function (data) {
-        var chunk = this.convertToBuffer(data);
+    }
+    update(data) {
+        const chunk = this.convertToBuffer(data);
         if (!this.buffer) {
             this.buffer = chunk;
         }
         else {
-            var totalSize = this.buffer.byteLength + chunk.byteLength;
-            var tempBuffer = new Uint8Array(totalSize);
+            const totalSize = this.buffer.byteLength + chunk.byteLength;
+            const tempBuffer = new Uint8Array(totalSize);
             tempBuffer.set(this.buffer);
             tempBuffer.set(chunk, this.buffer.byteLength);
             this.buffer = tempBuffer;
         }
         this.hashBuffer();
-    };
-    TreeHash.prototype.digest = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var collectedHashDigests, smallHash, higherLevelHashDigests, i, _a, digest1, digest2, chunk, hash;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        collectedHashDigests = this.collectedHashDigests;
-                        this.collectedHashDigests = [];
-                        if (this.buffer && this.buffer.byteLength > 0) {
-                            smallHash = new this.Sha256();
-                            smallHash.update(this.buffer);
-                            collectedHashDigests.push(smallHash.digest());
-                            this.buffer = void 0;
-                        }
-                        _b.label = 1;
-                    case 1:
-                        if (!(collectedHashDigests.length > 1)) return [3, 7];
-                        higherLevelHashDigests = [];
-                        i = 0;
-                        _b.label = 2;
-                    case 2:
-                        if (!(i < collectedHashDigests.length)) return [3, 6];
-                        if (!(i + 1 < collectedHashDigests.length)) return [3, 4];
-                        return [4, Promise.all([collectedHashDigests[i], collectedHashDigests[i + 1]])];
-                    case 3:
-                        _a = __read.apply(void 0, [_b.sent(), 2]), digest1 = _a[0], digest2 = _a[1];
-                        chunk = new Uint8Array(digest1.byteLength + digest2.byteLength);
-                        chunk.set(digest1);
-                        chunk.set(digest2, digest1.byteLength);
-                        hash = new this.Sha256();
-                        hash.update(chunk);
-                        higherLevelHashDigests.push(hash.digest());
-                        return [3, 5];
-                    case 4:
-                        higherLevelHashDigests.push(collectedHashDigests[i]);
-                        _b.label = 5;
-                    case 5:
-                        i += 2;
-                        return [3, 2];
-                    case 6:
-                        collectedHashDigests = higherLevelHashDigests;
-                        return [3, 1];
-                    case 7: return [2, collectedHashDigests[0]];
+    }
+    async digest() {
+        let collectedHashDigests = this.collectedHashDigests;
+        this.collectedHashDigests = [];
+        if (this.buffer && this.buffer.byteLength > 0) {
+            const smallHash = new this.Sha256();
+            smallHash.update(this.buffer);
+            collectedHashDigests.push(smallHash.digest());
+            this.buffer = void 0;
+        }
+        while (collectedHashDigests.length > 1) {
+            const higherLevelHashDigests = [];
+            for (let i = 0; i < collectedHashDigests.length; i += 2) {
+                if (i + 1 < collectedHashDigests.length) {
+                    const [digest1, digest2] = await Promise.all([collectedHashDigests[i], collectedHashDigests[i + 1]]);
+                    const chunk = new Uint8Array(digest1.byteLength + digest2.byteLength);
+                    chunk.set(digest1);
+                    chunk.set(digest2, digest1.byteLength);
+                    const hash = new this.Sha256();
+                    hash.update(chunk);
+                    higherLevelHashDigests.push(hash.digest());
                 }
-            });
-        });
-    };
-    TreeHash.prototype.convertToBuffer = function (data) {
+                else {
+                    higherLevelHashDigests.push(collectedHashDigests[i]);
+                }
+            }
+            collectedHashDigests = higherLevelHashDigests;
+        }
+        return collectedHashDigests[0];
+    }
+    convertToBuffer(data) {
         if (typeof data === "string") {
             return this.fromUtf8(data);
         }
@@ -88,7 +69,5 @@ var TreeHash = (function () {
             return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
         }
         return new Uint8Array(data);
-    };
-    return TreeHash;
-}());
-export { TreeHash };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/sha256-tree-hash",
-  "version": "3.186.0",
+  "version": "3.190.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,13 +20,13 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/types": "3.186.0",
+    "@aws-sdk/types": "3.190.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
     "@aws-crypto/sha256-js": "2.0.0",
-    "@aws-sdk/util-hex-encoding": "3.186.0",
-    "@aws-sdk/util-utf8-node": "3.186.0",
+    "@aws-sdk/util-hex-encoding": "3.188.0",
+    "@aws-sdk/util-utf8-node": "3.188.0",
     "@tsconfig/recommended": "1.0.1",
     "concurrently": "7.0.0",
     "downlevel-dts": "0.10.1",