initial commit

bff/node_modules/@smithy/hash-stream-node/dist-es/HashCalculator.js

@@ -0,0 +1,18 @@
+import { toUint8Array } from "@smithy/util-utf8";
+import { Writable } from "stream";
+export class HashCalculator extends Writable {
+    hash;
+    constructor(hash, options) {
+        super(options);
+        this.hash = hash;
+    }
+    _write(chunk, encoding, callback) {
+        try {
+            this.hash.update(toUint8Array(chunk));
+        }
+        catch (err) {
+            return callback(err);
+        }
+        callback();
+    }
+}

bff/node_modules/@smithy/hash-stream-node/dist-es/fileStreamHasher.js

@@ -0,0 +1,24 @@
+import { createReadStream } from "fs";
+import { HashCalculator } from "./HashCalculator";
+export const fileStreamHasher = (hashCtor, fileStream) => new Promise((resolve, reject) => {
+    if (!isReadStream(fileStream)) {
+        reject(new Error("Unable to calculate hash for non-file streams."));
+        return;
+    }
+    const fileStreamTee = createReadStream(fileStream.path, {
+        start: fileStream.start,
+        end: fileStream.end,
+    });
+    const hash = new hashCtor();
+    const hashCalculator = new HashCalculator(hash);
+    fileStreamTee.pipe(hashCalculator);
+    fileStreamTee.on("error", (err) => {
+        hashCalculator.end();
+        reject(err);
+    });
+    hashCalculator.on("error", reject);
+    hashCalculator.on("finish", function () {
+        hash.digest().then(resolve).catch(reject);
+    });
+});
+const isReadStream = (stream) => typeof stream.path === "string";

bff/node_modules/@smithy/hash-stream-node/dist-es/index.js

@@ -0,0 +1,2 @@
+export * from "./fileStreamHasher";
+export * from "./readableStreamHasher";

bff/node_modules/@smithy/hash-stream-node/dist-es/readableStreamHasher.js

@@ -0,0 +1,19 @@
+import { HashCalculator } from "./HashCalculator";
+export const readableStreamHasher = (hashCtor, readableStream) => {
+    if (readableStream.readableFlowing !== null) {
+        throw new Error("Unable to calculate hash for flowing readable stream");
+    }
+    const hash = new hashCtor();
+    const hashCalculator = new HashCalculator(hash);
+    readableStream.pipe(hashCalculator);
+    return new Promise((resolve, reject) => {
+        readableStream.on("error", (err) => {
+            hashCalculator.end();
+            reject(err);
+        });
+        hashCalculator.on("error", reject);
+        hashCalculator.on("finish", () => {
+            hash.digest().then(resolve).catch(reject);
+        });
+    });
+};