Socket
Socket
Sign inDemoInstall

into-stream

Package Overview
Dependencies
Maintainers
1
Versions
13
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

into-stream - npm Package Compare versions

Comparing version 7.0.0 to 8.0.0

21

index.d.ts

@@ -1,2 +0,3 @@

import {Readable as ReadableStream} from 'stream';
import {type Readable as ReadableStream} from 'node:stream';
import {type Buffer} from 'node:buffer';

@@ -20,14 +21,6 @@ export type Input =

/**
Convert object `input` into a stream.
@param input - The object input to convert to a stream.
@returns A [readable object stream](https://nodejs.org/api/stream.html#stream_object_mode).
*/
object: (input: ObjectInput | Promise<ObjectInput>) => ReadableStream;
/**
Convert `input` into a stream. Adheres to the requested chunk size, except for `array` where each element will be a chunk.
@param input - The input to convert to a stream.
@returns A [readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
@returns A [readable stream](https://nodejs.org/api/stream.html#class-streamreadable).

@@ -43,4 +36,12 @@ @example

(input: Input | Promise<Input>): ReadableStream;
/**
Convert object `input` into a stream.
@param input - The object input to convert to a stream.
@returns A [readable object stream](https://nodejs.org/api/stream.html#object-mode).
*/
object: (input: ObjectInput | Promise<ObjectInput>) => ReadableStream;
};
export default intoStream;

@@ -1,135 +0,53 @@

import from2 from 'from2';
import isPromise from 'p-is-promise';
import {Readable as ReadableStream} from 'node:stream';
import {Buffer} from 'node:buffer';
export default function intoStream(input) {
if (Array.isArray(input)) {
input = input.slice();
}
function baseIntoStream(isObjectMode, input) {
async function * reader() {
let value = await input;
let promise;
let iterator;
let asyncIterator;
if (!value) {
return;
}
prepare(input);
if (Array.isArray(value)) {
value = [...value];
}
function prepare(value) {
input = value;
if (
input instanceof ArrayBuffer ||
(ArrayBuffer.isView(input) && !Buffer.isBuffer(input))
!isObjectMode
&& (
value instanceof ArrayBuffer
|| (ArrayBuffer.isView(value) && !Buffer.isBuffer(value))
)
) {
input = Buffer.from(input);
value = Buffer.from(value);
}
promise = isPromise(input) ? input : null;
// We don't iterate on strings and buffers since yielding them is ~7x faster.
if (typeof value !== 'string' && !Buffer.isBuffer(value) && value?.[Symbol.iterator]) {
for (const element of value) {
yield element;
}
// We don't iterate on strings and buffers since slicing them is ~7x faster
const shouldIterate = !promise && input[Symbol.iterator] && typeof input !== 'string' && !Buffer.isBuffer(input);
iterator = shouldIterate ? input[Symbol.iterator]() : null;
const shouldAsyncIterate = !promise && input[Symbol.asyncIterator];
asyncIterator = shouldAsyncIterate ? input[Symbol.asyncIterator]() : null;
}
return from2(function reader(size, callback) {
if (promise) {
(async () => {
try {
await prepare(await promise);
reader.call(this, size, callback);
} catch (error) {
callback(error);
}
})();
return;
}
if (iterator) {
const object = iterator.next();
setImmediate(callback, null, object.done ? null : object.value);
return;
}
if (value?.[Symbol.asyncIterator]) {
for await (const element of value) {
yield await element;
}
if (asyncIterator) {
(async () => {
try {
const object = await asyncIterator.next();
setImmediate(callback, null, object.done ? null : object.value);
} catch (error) {
setImmediate(callback, error);
}
})();
return;
}
if (input.length === 0) {
setImmediate(callback, null, null);
return;
}
yield value;
}
const chunk = input.slice(0, size);
input = input.slice(size);
setImmediate(callback, null, chunk);
});
return ReadableStream.from(reader(), {objectMode: isObjectMode});
}
intoStream.object = input => {
if (Array.isArray(input)) {
input = input.slice();
}
const intoStream = baseIntoStream.bind(undefined, false);
let promise;
let iterator;
let asyncIterator;
export default intoStream;
prepare(input);
function prepare(value) {
input = value;
promise = isPromise(input) ? input : null;
iterator = !promise && input[Symbol.iterator] ? input[Symbol.iterator]() : null;
asyncIterator = !promise && input[Symbol.asyncIterator] ? input[Symbol.asyncIterator]() : null;
}
return from2.obj(function reader(size, callback) {
if (promise) {
(async () => {
try {
await prepare(await promise);
reader.call(this, size, callback);
} catch (error) {
callback(error);
}
})();
return;
}
if (iterator) {
const object = iterator.next();
setImmediate(callback, null, object.done ? null : object.value);
return;
}
if (asyncIterator) {
(async () => {
try {
const object = await asyncIterator.next();
setImmediate(callback, null, object.done ? null : object.value);
} catch (error) {
setImmediate(callback, error);
}
})();
return;
}
this.push(input);
setImmediate(callback, null, null);
});
};
intoStream.object = baseIntoStream.bind(undefined, true);
{
"name": "into-stream",
"version": "7.0.0",
"version": "8.0.0",
"description": "Convert a string/promise/array/iterable/asynciterable/buffer/typedarray/arraybuffer/object into a stream",

@@ -16,3 +16,3 @@ "license": "MIT",

"engines": {
"node": ">=12"
"node": ">=16"
},

@@ -47,14 +47,9 @@ "scripts": {

],
"dependencies": {
"from2": "^2.3.0",
"p-is-promise": "^3.0.0"
},
"devDependencies": {
"ava": "^3.15.0",
"ava": "^5.3.0",
"get-stream": "^6.0.1",
"p-event": "^4.2.0",
"p-immediate": "^4.0.0",
"tsd": "^0.14.0",
"xo": "^0.38.2"
"p-event": "^5.0.1",
"tsd": "^0.28.1",
"xo": "^0.54.2"
}
}

@@ -5,9 +5,9 @@ # into-stream

Correctly chunks up the input and handles backpressure.
Correctly handles backpressure.
## Install
```sh
npm install into-stream
```
$ npm install into-stream
```

@@ -28,13 +28,12 @@ ## Usage

Type: `Buffer | TypedArray | ArrayBuffer | string | Iterable<Buffer | string> | AsyncIterable<Buffer | string> | Promise`\
Returns: [Readable stream](https://nodejs.org/api/stream.html#stream_class_stream_readable)
Returns: [Readable stream](https://nodejs.org/api/stream.html#class-streamreadable)
Adheres to the requested chunk size, except for `array` where each element will be a chunk.
### intoStream.object(input)
Type: `object | Iterable<object> | AsyncIterable<object> | Promise`\
Returns: [Readable object stream](https://nodejs.org/api/stream.html#stream_object_mode)
Returns: [Readable object stream](https://nodejs.org/api/stream.html#object-mode)
## Related
- [to-readable-stream](https://github.com/sindresorhus/to-readable-stream) - Simpler version of this module
- [to-readable-stream](https://github.com/sindresorhus/to-readable-stream) - Simpler version of this package
- [get-stream](https://github.com/sindresorhus/get-stream) - The opposite of this package
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc