@aws-sdk/lib-storage 3.529.0 → 3.532.0

package/dist-cjs/index.js

@@ -32,12 +32,14 @@ var import_smithy_client = require("@smithy/smithy-client");
 var import_events = require("events");
 
 // src/bytelength.ts
+var import_buffer = require("buffer");
 var import_runtimeConfig = require("././runtimeConfig");
 var byteLength = /* @__PURE__ */ __name((input) => {
   if (input === null || input === void 0)
     return 0;
-  if (typeof input === "string")
-    input = Buffer.from(input);
+  if (typeof input === "string") {
+    return import_buffer.Buffer.byteLength(input);
+  }
   if (typeof input.byteLength === "number") {
     return input.byteLength;
   } else if (typeof input.length === "number") {
@@ -58,60 +60,64 @@ var byteLength = /* @__PURE__ */ __name((input) => {
 
 var import_stream = require("stream");
 
-// src/chunks/getChunkBuffer.ts
-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
-  };
-}
-__name(getChunkBuffer, "getChunkBuffer");
-
 // src/chunks/getChunkStream.ts
-var import_buffer = require("buffer");
+
 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;
+    currentBuffer.length += datum.byteLength;
     while (currentBuffer.length >= partSize) {
       const dataChunk = currentBuffer.chunks.length > 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
       yield {
         partNumber,
-        data: dataChunk.slice(0, partSize)
+        data: dataChunk.subarray(0, partSize)
       };
-      currentBuffer.chunks = [dataChunk.slice(partSize)];
-      currentBuffer.length = currentBuffer.chunks[0].length;
+      currentBuffer.chunks = [dataChunk.subarray(partSize)];
+      currentBuffer.length = currentBuffer.chunks[0].byteLength;
       partNumber += 1;
     }
   }
   yield {
     partNumber,
-    data: import_buffer.Buffer.concat(currentBuffer.chunks),
+    data: currentBuffer.chunks.length !== 1 ? import_buffer.Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0],
     lastPart: true
   };
 }
 __name(getChunkStream, "getChunkStream");
 
+// src/chunks/getChunkUint8Array.ts
+async function* getChunkUint8Array(data, partSize) {
+  let partNumber = 1;
+  let startByte = 0;
+  let endByte = partSize;
+  while (endByte < data.byteLength) {
+    yield {
+      partNumber,
+      data: data.subarray(startByte, endByte)
+    };
+    partNumber += 1;
+    startByte = endByte;
+    endByte = startByte + partSize;
+  }
+  yield {
+    partNumber,
+    data: data.subarray(startByte),
+    lastPart: true
+  };
+}
+__name(getChunkUint8Array, "getChunkUint8Array");
+
 // src/chunks/getDataReadable.ts
 
 async function* getDataReadable(data) {
   for await (const chunk of data) {
-    yield import_buffer.Buffer.from(chunk);
+    if (import_buffer.Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+      yield chunk;
+    } else {
+      yield import_buffer.Buffer.from(chunk);
+    }
   }
 }
 __name(getDataReadable, "getDataReadable");
@@ -123,9 +129,14 @@ async function* getDataReadableStream(data) {
   try {
     while (true) {
       const { done, value } = await reader.read();
-      if (done)
+      if (done) {
         return;
-      yield import_buffer.Buffer.from(value);
+      }
+      if (import_buffer.Buffer.isBuffer(value) || value instanceof Uint8Array) {
+        yield value;
+      } else {
+        yield import_buffer.Buffer.from(value);
+      }
     }
   } catch (e) {
     throw e;
@@ -137,22 +148,24 @@ __name(getDataReadableStream, "getDataReadableStream");
 
 // src/chunker.ts
 var getChunk = /* @__PURE__ */ __name((data, partSize) => {
-  if (data instanceof import_buffer.Buffer) {
-    return getChunkBuffer(data, partSize);
-  } else if (data instanceof import_stream.Readable) {
+  if (data instanceof Uint8Array) {
+    return getChunkUint8Array(data, partSize);
+  }
+  if (data instanceof import_stream.Readable) {
     return getChunkStream(data, partSize, getDataReadable);
-  } else if (data instanceof String || typeof data === "string" || data instanceof Uint8Array) {
-    return getChunkBuffer(import_buffer.Buffer.from(data), partSize);
+  }
+  if (data instanceof String || typeof data === "string") {
+    return getChunkUint8Array(import_buffer.Buffer.from(data), partSize);
   }
   if (typeof data.stream === "function") {
     return getChunkStream(data.stream(), partSize, getDataReadableStream);
-  } else if (data instanceof ReadableStream) {
+  }
+  if (data instanceof ReadableStream) {
     return getChunkStream(data, partSize, getDataReadableStream);
-  } else {
-    throw new Error(
-      "Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;."
-    );
   }
+  throw new Error(
+    "Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;."
+  );
 }, "getChunk");
 
 // src/Upload.ts

package/dist-es/bytelength.js

@@ -1,9 +1,11 @@
+import { Buffer } from "buffer";
 import { ClientDefaultValues } from "./runtimeConfig";
 export const byteLength = (input) => {
     if (input === null || input === undefined)
         return 0;
-    if (typeof input === "string")
-        input = Buffer.from(input);
+    if (typeof input === "string") {
+        return Buffer.byteLength(input);
+    }
     if (typeof input.byteLength === "number") {
         return input.byteLength;
     }

package/dist-es/chunker.js

@@ -1,26 +1,24 @@
 import { Buffer } from "buffer";
 import { Readable } from "stream";
-import { getChunkBuffer } from "./chunks/getChunkBuffer";
 import { getChunkStream } from "./chunks/getChunkStream";
+import { getChunkUint8Array } from "./chunks/getChunkUint8Array";
 import { getDataReadable } from "./chunks/getDataReadable";
 import { getDataReadableStream } from "./chunks/getDataReadableStream";
 export const getChunk = (data, partSize) => {
-    if (data instanceof Buffer) {
-        return getChunkBuffer(data, partSize);
+    if (data instanceof Uint8Array) {
+        return getChunkUint8Array(data, partSize);
     }
-    else if (data instanceof Readable) {
+    if (data instanceof Readable) {
         return getChunkStream(data, partSize, getDataReadable);
     }
-    else if (data instanceof String || typeof data === "string" || data instanceof Uint8Array) {
-        return getChunkBuffer(Buffer.from(data), partSize);
+    if (data instanceof String || typeof data === "string") {
+        return getChunkUint8Array(Buffer.from(data), partSize);
     }
     if (typeof data.stream === "function") {
         return getChunkStream(data.stream(), partSize, getDataReadableStream);
     }
-    else if (data instanceof ReadableStream) {
+    if (data instanceof ReadableStream) {
         return getChunkStream(data, partSize, getDataReadableStream);
     }
-    else {
-        throw new Error("Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;.");
-    }
+    throw new Error("Body Data is unsupported format, expected data to be one of: string | Uint8Array | Buffer | Readable | ReadableStream | Blob;.");
 };

package/dist-es/chunks/getChunkStream.js

@@ -4,21 +4,21 @@ export async function* getChunkStream(data, partSize, getNextData) {
     const currentBuffer = { chunks: [], length: 0 };
     for await (const datum of getNextData(data)) {
         currentBuffer.chunks.push(datum);
-        currentBuffer.length += datum.length;
+        currentBuffer.length += datum.byteLength;
         while (currentBuffer.length >= partSize) {
             const dataChunk = currentBuffer.chunks.length > 1 ? Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0];
             yield {
                 partNumber,
-                data: dataChunk.slice(0, partSize),
+                data: dataChunk.subarray(0, partSize),
             };
-            currentBuffer.chunks = [dataChunk.slice(partSize)];
-            currentBuffer.length = currentBuffer.chunks[0].length;
+            currentBuffer.chunks = [dataChunk.subarray(partSize)];
+            currentBuffer.length = currentBuffer.chunks[0].byteLength;
             partNumber += 1;
         }
     }
     yield {
         partNumber,
-        data: Buffer.concat(currentBuffer.chunks),
+        data: currentBuffer.chunks.length !== 1 ? Buffer.concat(currentBuffer.chunks) : currentBuffer.chunks[0],
         lastPart: true,
     };
 }

package/dist-es/chunks/{getChunkBuffer.js → getChunkUint8Array.js}

@@ -1,11 +1,11 @@
-export async function* getChunkBuffer(data, partSize) {
+export async function* getChunkUint8Array(data, partSize) {
     let partNumber = 1;
     let startByte = 0;
     let endByte = partSize;
     while (endByte < data.byteLength) {
         yield {
             partNumber,
-            data: data.slice(startByte, endByte),
+            data: data.subarray(startByte, endByte),
         };
         partNumber += 1;
         startByte = endByte;
@@ -13,7 +13,7 @@ export async function* getChunkBuffer(data, partSize) {
     }
     yield {
         partNumber,
-        data: data.slice(startByte),
+        data: data.subarray(startByte),
         lastPart: true,
     };
 }

package/dist-es/chunks/getDataReadable.js

@@ -1,6 +1,11 @@
 import { Buffer } from "buffer";
 export async function* getDataReadable(data) {
     for await (const chunk of data) {
-        yield Buffer.from(chunk);
+        if (Buffer.isBuffer(chunk) || chunk instanceof Uint8Array) {
+            yield chunk;
+        }
+        else {
+            yield Buffer.from(chunk);
+        }
     }
 }

package/dist-es/chunks/getDataReadableStream.js

@@ -4,9 +4,15 @@ export async function* getDataReadableStream(data) {
     try {
         while (true) {
             const { done, value } = await reader.read();
-            if (done)
+            if (done) {
                 return;
-            yield Buffer.from(value);
+            }
+            if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+                yield value;
+            }
+            else {
+                yield Buffer.from(value);
+            }
         }
     }
     catch (e) {

package/dist-types/chunker.d.ts

@@ -1,2 +1,3 @@
 import { BodyDataTypes } from "./types";
-export declare const getChunk: (data: BodyDataTypes, partSize: number) => AsyncGenerator<import("./Upload").RawDataPart, void, undefined>;
+import type { RawDataPart } from "./Upload";
+export declare const getChunk: (data: BodyDataTypes, partSize: number) => AsyncGenerator<RawDataPart, void, undefined>;

package/dist-types/chunks/getChunkStream.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 import { RawDataPart } from "../Upload";
-export declare function getChunkStream<T>(data: T, partSize: number, getNextData: (data: T) => AsyncGenerator<Buffer>): AsyncGenerator<RawDataPart, void, undefined>;
+export declare function getChunkStream<T>(data: T, partSize: number, getNextData: (data: T) => AsyncGenerator<Uint8Array>): AsyncGenerator<RawDataPart, void, undefined>;

package/dist-types/chunks/getChunkUint8Array.d.ts

@@ -0,0 +1,2 @@
+import { RawDataPart } from "../Upload";
+export declare function getChunkUint8Array(data: Uint8Array, partSize: number): AsyncGenerator<RawDataPart, void, undefined>;

package/dist-types/chunks/getDataReadable.d.ts

@@ -1,4 +1,3 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { Readable } from "stream";
-export declare function getDataReadable(data: Readable): AsyncGenerator<Buffer>;
+export declare function getDataReadable(data: Readable): AsyncGenerator<Uint8Array>;

package/dist-types/chunks/getDataReadableStream.d.ts

@@ -1,2 +1 @@
-/// <reference types="node" />
-export declare function getDataReadableStream(data: ReadableStream): AsyncGenerator<Buffer>;
+export declare function getDataReadableStream(data: ReadableStream): AsyncGenerator<Uint8Array>;

package/dist-types/ts3.4/chunker.d.ts

@@ -1,5 +1,6 @@
 import { BodyDataTypes } from "./types";
+import { RawDataPart } from "./Upload";
 export declare const getChunk: (
   data: BodyDataTypes,
   partSize: number
-) => AsyncGenerator<import("./Upload").RawDataPart, void, undefined>;
+) => AsyncGenerator<RawDataPart, void, undefined>;

package/dist-types/ts3.4/chunks/getChunkStream.d.ts

@@ -2,5 +2,5 @@ import { RawDataPart } from "../Upload";
 export declare function getChunkStream<T>(
   data: T,
   partSize: number,
-  getNextData: (data: T) => AsyncGenerator<Buffer>
+  getNextData: (data: T) => AsyncGenerator<Uint8Array>
 ): AsyncGenerator<RawDataPart, void, undefined>;

package/dist-types/ts3.4/chunks/{getChunkBuffer.d.ts → getChunkUint8Array.d.ts}

@@ -1,5 +1,5 @@
 import { RawDataPart } from "../Upload";
-export declare function getChunkBuffer(
-  data: Buffer,
+export declare function getChunkUint8Array(
+  data: Uint8Array,
   partSize: number
 ): AsyncGenerator<RawDataPart, void, undefined>;

package/dist-types/ts3.4/chunks/getDataReadable.d.ts

@@ -1,2 +1,4 @@
 import { Readable } from "stream";
-export declare function getDataReadable(data: Readable): AsyncGenerator<Buffer>;
+export declare function getDataReadable(
+  data: Readable
+): AsyncGenerator<Uint8Array>;

package/dist-types/ts3.4/chunks/getDataReadableStream.d.ts

@@ -1,3 +1,3 @@
 export declare function getDataReadableStream(
   data: ReadableStream
-): AsyncGenerator<Buffer>;
+): AsyncGenerator<Uint8Array>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/lib-storage",
-  "version": "3.529.0",
+  "version": "3.532.0",
   "description": "Storage higher order operation",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
@@ -14,7 +14,8 @@
     "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
     "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
     "extract:docs": "api-extractor run --local",
-    "test": "jest"
+    "test": "jest",
+    "test:e2e": "jest -c jest.config.e2e.js"
   },
   "engines": {
     "node": ">=14.0.0"
@@ -37,7 +38,7 @@
     "@aws-sdk/client-s3": "^3.0.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-s3": "3.529.0",
+    "@aws-sdk/client-s3": "3.529.1",
     "@smithy/types": "^2.10.1",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^14.14.31",

package/dist-types/chunks/getChunkBuffer.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="node" />
-import { RawDataPart } from "../Upload";
-export declare function getChunkBuffer(data: Buffer, partSize: number): AsyncGenerator<RawDataPart, void, undefined>;