Make the package compatible Node.js and others runtimes

.gitignore

@@ -0,0 +1 @@
+npm

build_npm.ts

@@ -0,0 +1,68 @@
+import { build, emptyDir } from "https://deno.land/x/dnt/mod.ts";
+
+const version = Deno.args[0];
+
+if (!version) {
+  throw new Error("Please specify a version.");
+}
+
+await emptyDir("./npm");
+
+await build({
+  entryPoints: ["./mod.ts"], // Replace with your actual entry point
+  outDir: "./npm",
+  shims: {
+    deno: {
+      test: "dev",
+    },
+    custom: [
+      {
+        package: {
+          name: "web-streams-polyfill",
+          version: "^3.1.1",
+        },
+        globalNames: ["ReadableStream", "WritableStream", "TransformStream"],
+      },
+    ],
+  },
+  package: {
+    // Update with your package details
+    name: "s3-lite-client",
+    version: version,
+    description: "This is a lightweight S3 client for Node.js and Deno.",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/bradenmacdonald/deno-s3-lite-client.git",
+    },
+    bugs: {
+      url: "https://github.com/bradenmacdonald/deno-s3-lite-client/issues",
+    },
+    engines: {
+      "node": ">=16"
+    },
+    author: {
+      "name": "Braden MacDonald",
+      "url": "https://github.com/bradenmacdonald"
+    },
+    contributors: [
+      "Martin Donadieu <martindonadieu@gmail.com> (https://martin.solos.ventures/)",
+    ],
+    keywords: [
+      "api",
+      "lite",
+      "amazon",
+      "minio",
+      "cloud",
+      "s3",
+      "storage"
+    ]
+  },
+  postBuild() {
+    // Copy additional files to the npm directory if needed
+    Deno.copyFileSync("LICENSE", "npm/LICENSE");
+    Deno.copyFileSync("README.md", "npm/README.md");
+  },
+});
+
+console.log("Build complete. Run `cd npm && npm publish`.");

signing.ts

@@ -153,13 +153,12 @@ function getHeadersToSign(headers: Headers): string[] {
     "content-type",
     "user-agent",
   ];
-  const headersToSign = [];
-  for (const key of headers.keys()) {
-    if (ignoredHeaders.includes(key.toLowerCase())) {
-      continue; // Ignore this header
+  const headersToSign: string[] = [];
+  headers.forEach((value, key) => {
+    if (!ignoredHeaders.includes(key.toLowerCase())) {
+      headersToSign.push(key);
     }
-    headersToSign.push(key);
-  }
+  });
   headersToSign.sort();
   return headersToSign;
 }

transform-chunk-sizes.test.ts

@@ -9,7 +9,7 @@ import { TransformChunkSizes } from "./transform-chunk-sizes.ts";
  */
 class NumberSource extends ReadableStream<Uint8Array> {
   constructor(delayMs: number, chunksCount: number, bytesPerChunk = 1) {
-    let intervalTimer: number;
+    let intervalTimer: any;
     let i = 0;
     super({
       start(controller) {

transform-chunk-sizes.ts

@@ -1,36 +1,39 @@
-import { Buffer } from "./deps.ts";
 
 /**
  * This stream transform will buffer the data it receives until it has enough to form
  * a chunk of the specified size, then pass on the data in chunks of the specified size.
  */
 export class TransformChunkSizes extends TransformStream<Uint8Array, Uint8Array> {
   constructor(outChunkSize: number) {
-    // This large buffer holds all the incoming data we receive until we reach at least outChunkSize, which we then pass on.
-    const buffer = new Buffer();
-    buffer.grow(outChunkSize);
+    const buffer = new Uint8Array(outChunkSize * 2); // Buffer size is twice the chunk size to ensure there's enough space
+    let offset = 0; // Offset to keep track of the current position in the buffer
 
     super({
-      start() {}, // required
-      async transform(chunk, controller) {
-        buffer.write(chunk);
+      start(_controller) {
+        // No initialization needed here since we've already initialized buffer and offset in the constructor.
+      },
+      transform(chunk, controller) {
+        let chunkOffset = 0;
 
-        while (buffer.length >= outChunkSize) {
-          const outChunk = new Uint8Array(outChunkSize);
-          const readFromBuffer = await buffer.read(outChunk);
-          if (readFromBuffer !== outChunkSize) {
-            throw new Error(
-              `Unexpectedly read ${readFromBuffer} bytes from transform buffer when trying to read ${outChunkSize} bytes.`,
-            );
-          }
-          // Now "outChunk" holds the next chunk of data - pass it on to the output:
-          controller.enqueue(outChunk);
+        // If the incoming chunk won't fit in the remaining buffer space, we need to process what's in the buffer first
+        while (offset + chunk.length - chunkOffset > outChunkSize) {
+          // Calculate how much of the incoming chunk we can fit into the buffer
+          const spaceLeft = outChunkSize - offset;
+          buffer.set(chunk.subarray(chunkOffset, chunkOffset + spaceLeft), offset);
+          controller.enqueue(buffer.subarray(0, outChunkSize));
+          offset = 0;
+          chunkOffset += spaceLeft;
         }
+
+        // Put the remaining chunk into the buffer
+        buffer.set(chunk.subarray(chunkOffset), offset);
+        offset += chunk.length - chunkOffset;
       },
       flush(controller) {
-        if (buffer.length) {
-          // The buffer still contains some data, send it now even though it's smaller than the desired chunk size.
-          controller.enqueue(buffer.bytes());
+        if (offset > 0) {
+          // Send any remaining data in the buffer
+          controller.enqueue(buffer.subarray(0, offset));
+          offset = 0;
         }
       },
     });