stringio: convert strings to Node.js streams and vice versa

``
npm install @rauschma/stringio
`


Strings ↔︎ streams

See line A and line B:

`js
import * as assert from 'assert';
import { StringStream, readableToString } from '@rauschma/stringio';

test('From string to stream to string', async () => {
const str = 'Hello!\nHow are you?\n';
const stringStream = new StringStream(str); // (A)
const result = await readableToString(stringStream); // (B)
assert.strictEqual(result, str);
});
`

$3

`typescript
declare class StringStream extends Readable {
constructor(str: string);
}
`

Used in line A.

$3

`typescript
declare function readableToString(readable: Readable, encoding?: string): Promise;
`

Default encoding is 'utf-8'.

Used in line B.

#### Reading stdin into a string

`typescript
async function readStdin() {
const str = await readableToString(process.stdin);
console.log('STR: '+str);
}
`

$3

* string-to-stream: Convert a string into a stream.
* get-stream: Get a stream as a string, buffer, or array.

Asynchronous iterables

$3

`typescript
declare function chunksToLinesAsync(chunks: AsyncIterable): AsyncIterable;
`

Each line includes the line break at the end (if any – the last line may not have one).

Example (starting with Node.js v.10, readable streams are asynchronous iterables):

`js
const fs = require('fs');
const {chunksToLinesAsync} = require('@rauschma/stringio');

async function main() {
const stream = fs.createReadStream(process.argv[2]);
// Works, too: const stream = process.stdin;
for await (const line of chunksToLinesAsync(stream)) {
console.log(chomp(line));
}
}
main();
`

Promisified writing to streams

`typescript
declare function streamWrite(
stream: Writable,
chunk: string | Buffer | Uint8Array,
encoding = 'utf8')
: Promise;

declare function streamEnd(
stream: Writable)
: Promise;
`

Usage:

`js
await streamWrite(someStream, 'abc');
await streamWrite(someStream, 'def');
await streamEnd(someStream);
`

onExit(childProcess): wait until a child process is finished

`ts
export declare function onExit(childProcess: ChildProcess): Promise;
`

Usage:

`js
const childProcess = child_process.spawn(···);
await onExit(childProcess);
`

Errors emitted by childProcess or a non-zero exit code reject the Promise returned by onExit().

String helper function

$3

`typescript
declare function chomp(line: string): string;
`

Further reading

The following 2ality blog posts use stringio:

* Reading streams via async iteration in Node.js
* Working with stdout and stdin of a child process in Node.js

Acknowledgements

* StringStream` is inspired by: https://github.com/feross/string-to-stream/blob/master/index.js