Add support for Uint8Array in iterables

Fixes #21

Author: sindresorhus

index.d.ts

@@ -6,8 +6,8 @@ export type Input =
 | NodeJS.TypedArray
 | ArrayBuffer
 | string
-| Iterable<Buffer | string>
-| AsyncIterable<Buffer | string>;
+| Iterable<Buffer | string | NodeJS.TypedArray>
+| AsyncIterable<Buffer | string | NodeJS.TypedArray>;
 
 /* eslint-disable @typescript-eslint/ban-types */
 export type ObjectInput =

index.js

@@ -17,28 +17,40 @@ function baseIntoStream(isObjectMode, input) {
 value = [...value];
 }
 
-if (
-!isObjectMode
-&& (
-value instanceof ArrayBuffer
-|| (ArrayBuffer.isView(value) && !Buffer.isBuffer(value))
-)
-) {
+// Convert ArrayBuffer/TypedArray to Buffer
+if (!isObjectMode && (value instanceof ArrayBuffer || (ArrayBuffer.isView(value) && !Buffer.isBuffer(value)))) {
 value = Buffer.from(value);
 }
 
-// We don't iterate on strings and buffers since yielding them is ~7x faster.
+const convertElement = element => {
+if (isObjectMode) {
+return element;
+}
+
+if (ArrayBuffer.isView(element) && !Buffer.isBuffer(element)) {
+return Buffer.from(element);
+}
+
+if (typeof element === 'number') {
+return Buffer.from([element]);
+}
+
+return element;
+};
+
+// Handle iterables
 if (typeof value !== 'string' && !Buffer.isBuffer(value) && value?.[Symbol.iterator]) {
 for (const element of value) {
-yield element;
+yield convertElement(element);
 }
 
 return;
 }
 
+// Handle async iterables
 if (value?.[Symbol.asyncIterator]) {
 for await (const element of value) {
-yield await element;
+yield convertElement(await element);
 }
 
 return;

readme.md

@@ -23,7 +23,7 @@ intoStream('unicorn').pipe(process.stdout);
 
 ### intoStream(input)
 
-Type: `Buffer | TypedArray | ArrayBuffer | string | Iterable<Buffer | string> | AsyncIterable<Buffer | string> | Promise`\
+Type: `Buffer | TypedArray | ArrayBuffer | string | Iterable<Buffer | string | TypedArray> | AsyncIterable<Buffer | string | TypedArray> | Promise`\
 Returns: [Readable stream](https://nodejs.org/api/stream.html#class-streamreadable)
 
 ### intoStream.object(input)

test.js

@@ -90,10 +90,13 @@ test('async iterable', async t => {
 t.is(await getStream(intoStream(iterable)), fixture);
 });
 
-test.failing('async iterable - Uint8Array', async t => {
-const fixture = new Uint8Array([21, 31]);
+test('async iterable - Uint8Array elements iterate as numbers', async t => {
+// When iterating over a Uint8Array directly, it yields numbers, not Uint8Array chunks
+// This test documents that behavior - individual numbers get converted to single-byte buffers
+const fixture = new Uint8Array([65, 66]); // 'A', 'B' in ASCII
 const iterable = asyncIterableFrom(fixture);
-t.is(await getStream(intoStream(iterable)), fixture);
+const result = await getStream(intoStream(iterable));
+t.is(result, 'AB');
 });
 
 test('async generator', async t => {
@@ -197,3 +200,23 @@ test('pushes chunk on next tick', async t => {
 
 t.true(flag);
 });
+
+test('Uint8Array in iterables', async t => {
+// Sync iterable
+function * syncGen() {
+yield new Uint8Array([72, 101]); // "He"
+yield new Uint8Array([108, 108, 111]); // "llo"
+}
+
+// Async iterable
+async function * asyncGen() {
+yield new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+yield new Uint8Array([32, 87, 111, 114, 108, 100]); // " World"
+}
+
+const syncResult = await getStream.buffer(intoStream(syncGen()));
+const asyncResult = await getStream.buffer(intoStream(asyncGen()));
+
+t.is(syncResult.toString(), 'Hello');
+t.is(asyncResult.toString(), 'Hello World');
+});