stream-protocol-toolkit 0.1.0

package/dist/StreamContext/StreamContext.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamContext = void 0;
+const events_1 = require("events");
+class StreamContext {
+    constructor(options) {
+        this.input = options.input;
+        this.output = options.output;
+        this.eventBus = new events_1.EventEmitter();
+        this.application = options.application;
+        this.abortController = new AbortController();
+        this.inputTransform = options.inputTransform;
+        this.outputTransform = options.outputTransform;
+        this.streamContextState = options.streamContextState;
+        this.streamProtocolProcessor = options.streamProtocolProcessor;
+    }
+}
+exports.StreamContext = StreamContext;

package/dist/StreamContext/StreamContextOptions.d.ts

@@ -0,0 +1,12 @@
+import type { Application } from '../Application';
+import type { Readable, Writable, Transform } from 'stream';
+import type { StreamProtocolProcessor } from '../StreamProtocolProcessor';
+export type StreamContextOptions<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    input: ISTREAM;
+    output?: OSTREAM;
+    streamContextState: SCS;
+    inputTransform?: Transform[];
+    outputTransform?: Transform[];
+    application: Application<ISTREAM, OSTREAM, AS, SCS>;
+    streamProtocolProcessor: StreamProtocolProcessor<ISTREAM, OSTREAM, AS, SCS>;
+};

package/dist/StreamContext/StreamContextOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/StreamContext/index.d.ts

@@ -0,0 +1,2 @@
+export { StreamContext } from './StreamContext';
+export type { StreamContextOptions } from './StreamContextOptions';

package/dist/StreamContext/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamContext = void 0;
+var StreamContext_1 = require("./StreamContext");
+Object.defineProperty(exports, "StreamContext", { enumerable: true, get: function () { return StreamContext_1.StreamContext; } });

package/dist/StreamProtocolProcessor/StreamProtocolProcessor.d.ts

@@ -0,0 +1,28 @@
+import { Buffer } from 'buffer';
+import { StreamBuffer } from '../StreamBuffer';
+import type { Application } from '../Application';
+import type { Readable, Writable } from 'stream';
+import type { RawPacket, RawPacketHeader } from '../RawPacket';
+import type { StreamProtocolProcessorOptions } from './StreamProtocolProcessorOptions';
+export declare class StreamProtocolProcessor<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> {
+    readonly packetMaxLength: number;
+    readonly packetOpcodeSize: number;
+    readonly packetLengthSize: number;
+    readonly streamBuffer: StreamBuffer;
+    readonly application: Application<ISTREAM, OSTREAM, AS, SCS>;
+    constructor(options: StreamProtocolProcessorOptions<ISTREAM, OSTREAM, AS, SCS>);
+    pushChunk(chunk: Buffer): this;
+    assertState(): void;
+    readPacketOpcode(buffer: StreamBuffer): number;
+    writePacketOpcode(buffer: StreamBuffer, value: number, unshift?: boolean): this;
+    packetOpcodeIsReadable(buffer: StreamBuffer): boolean;
+    readPacketLength(buffer: StreamBuffer): number;
+    writePacketLength(buffer: StreamBuffer, value: number, unshift?: boolean): this;
+    packetLengthIsReadable(buffer: StreamBuffer): boolean;
+    readPacketHeader(buffer: StreamBuffer): RawPacketHeader;
+    writePacketHeader(buffer: StreamBuffer, packetHeader: RawPacketHeader, unshift?: boolean): this;
+    packetHeaderIsReadable(buffer: StreamBuffer): boolean;
+    readPacket(buffer: StreamBuffer): RawPacket;
+    writePacket(buffer: StreamBuffer, packet: RawPacket, unshift?: boolean): this;
+    packetIsReadable(buffer: StreamBuffer): boolean;
+}

package/dist/StreamProtocolProcessor/StreamProtocolProcessor.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolProcessor = void 0;
+const StreamBuffer_1 = require("../StreamBuffer");
+const extended_buffer_1 = require("extended-buffer");
+const errors_1 = require("../errors");
+const DEFAULT_PACKET_OPCODE_SIZE = 1;
+const DEFAULT_PACKET_LENGTH_SIZE = 1;
+const DEFAULT_PACKET_MAX_LENGTH = 16 * 1024;
+class StreamProtocolProcessor {
+    constructor(options) {
+        var _a, _b, _c;
+        this.application = options.application;
+        this.streamBuffer = options.streamBuffer;
+        this.packetMaxLength = (_a = options.packetMaxLength) !== null && _a !== void 0 ? _a : DEFAULT_PACKET_MAX_LENGTH;
+        this.packetOpcodeSize = (_b = options.packetOpcodeSize) !== null && _b !== void 0 ? _b : DEFAULT_PACKET_OPCODE_SIZE;
+        this.packetLengthSize = (_c = options.packetLengthSize) !== null && _c !== void 0 ? _c : DEFAULT_PACKET_LENGTH_SIZE;
+    }
+    pushChunk(chunk) {
+        this.streamBuffer.writeNativeBuffer(chunk);
+        return this;
+    }
+    assertState() {
+        if (!this.packetHeaderIsReadable(this.streamBuffer)) {
+            return;
+        }
+        const savedPointer = this.streamBuffer.getPointer();
+        const packetHeader = this.readPacketHeader(this.streamBuffer);
+        this.streamBuffer.setPointer(savedPointer);
+        if (packetHeader.length > this.packetMaxLength) {
+            throw new errors_1.StreamProtocolToolkitError('MAX_PACKET_SIZE_EXCEEDED');
+        }
+    }
+    readPacketOpcode(buffer) {
+        return buffer.readUIntBE(this.packetOpcodeSize);
+    }
+    writePacketOpcode(buffer, value, unshift) {
+        buffer.writeUIntBE(value, this.packetOpcodeSize, unshift);
+        return this;
+    }
+    packetOpcodeIsReadable(buffer) {
+        return buffer.isReadable(this.packetOpcodeSize);
+    }
+    readPacketLength(buffer) {
+        return buffer.readUIntBE(this.packetLengthSize);
+    }
+    writePacketLength(buffer, value, unshift) {
+        buffer.writeUIntBE(value, this.packetLengthSize, unshift);
+        return this;
+    }
+    packetLengthIsReadable(buffer) {
+        return buffer.isReadable(this.packetLengthSize);
+    }
+    readPacketHeader(buffer) {
+        const savedPointer = buffer.getPointer();
+        try {
+            const opcode = this.readPacketOpcode(buffer);
+            const length = this.readPacketLength(buffer);
+            return {
+                opcode,
+                length
+            };
+        }
+        catch (e) {
+            buffer.setPointer(savedPointer);
+            throw e;
+        }
+    }
+    writePacketHeader(buffer, packetHeader, unshift) {
+        if (unshift) {
+            const headerSize = this.packetOpcodeSize + this.packetLengthSize;
+            buffer.allocStart(headerSize);
+            this.writePacketLength(buffer, packetHeader.length, true).writePacketOpcode(buffer, packetHeader.opcode, true);
+        }
+        else {
+            this.writePacketOpcode(buffer, packetHeader.opcode).writePacketLength(buffer, packetHeader.length);
+        }
+        return this;
+    }
+    packetHeaderIsReadable(buffer) {
+        const headerSize = this.packetOpcodeSize + this.packetLengthSize;
+        return buffer.isReadable(headerSize);
+    }
+    readPacket(buffer) {
+        const savedPointer = buffer.getPointer();
+        try {
+            const packetHeader = this.readPacketHeader(buffer);
+            const currentPointer = buffer.getPointer();
+            const payload = new StreamBuffer_1.StreamBuffer({
+                initNativeBuffer: (0, extended_buffer_1.nativeBufferSubarray)(buffer.nativeBufferView, currentPointer, currentPointer + packetHeader.length)
+            });
+            buffer.offset(packetHeader.length);
+            return {
+                opcode: packetHeader.opcode,
+                length: packetHeader.length,
+                payload
+            };
+        }
+        catch (e) {
+            buffer.setPointer(savedPointer);
+            throw e;
+        }
+    }
+    writePacket(buffer, packet, unshift) {
+        if (unshift) {
+            const headerSize = this.packetOpcodeSize + this.packetLengthSize;
+            buffer.allocStart(headerSize + packet.payload.length);
+            buffer.writeNativeBuffer(packet.payload.nativeBufferView, true);
+            this.writePacketHeader(buffer, {
+                opcode: packet.opcode,
+                length: packet.payload.length
+            }, true);
+        }
+        else {
+            this.writePacketHeader(buffer, {
+                opcode: packet.opcode,
+                length: packet.payload.length
+            });
+            buffer.writeNativeBuffer(packet.payload.nativeBufferView);
+        }
+        return this;
+    }
+    packetIsReadable(buffer) {
+        const savedPointer = buffer.getPointer();
+        try {
+            if (!this.packetHeaderIsReadable(buffer)) {
+                return false;
+            }
+            const packetHeader = this.readPacketHeader(buffer);
+            return buffer.isReadable(packetHeader.length);
+        }
+        finally {
+            buffer.setPointer(savedPointer);
+        }
+    }
+}
+exports.StreamProtocolProcessor = StreamProtocolProcessor;

package/dist/StreamProtocolProcessor/StreamProtocolProcessorOptions.d.ts

@@ -0,0 +1,10 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../Application';
+import type { StreamBuffer } from '../StreamBuffer';
+export type StreamProtocolProcessorOptions<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    packetMaxLength?: number;
+    packetOpcodeSize?: number;
+    packetLengthSize?: number;
+    streamBuffer: StreamBuffer;
+    application: Application<ISTREAM, OSTREAM, AS, SCS>;
+};

package/dist/StreamProtocolProcessor/StreamProtocolProcessorOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/StreamProtocolProcessor/index.d.ts

@@ -0,0 +1,2 @@
+export { StreamProtocolProcessor } from './StreamProtocolProcessor';
+export type { StreamProtocolProcessorOptions } from './StreamProtocolProcessorOptions';

package/dist/StreamProtocolProcessor/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolProcessor = void 0;
+var StreamProtocolProcessor_1 = require("./StreamProtocolProcessor");
+Object.defineProperty(exports, "StreamProtocolProcessor", { enumerable: true, get: function () { return StreamProtocolProcessor_1.StreamProtocolProcessor; } });

package/dist/errors/StreamProtocolToolkitAlreadyExistsError.d.ts

@@ -0,0 +1,3 @@
+import { StreamProtocolToolkitError } from './StreamProtocolToolkitError';
+export declare class StreamProtocolToolkitAlreadyExistsError extends StreamProtocolToolkitError {
+}

package/dist/errors/StreamProtocolToolkitAlreadyExistsError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolToolkitAlreadyExistsError = void 0;
+const StreamProtocolToolkitError_1 = require("./StreamProtocolToolkitError");
+class StreamProtocolToolkitAlreadyExistsError extends StreamProtocolToolkitError_1.StreamProtocolToolkitError {
+}
+exports.StreamProtocolToolkitAlreadyExistsError = StreamProtocolToolkitAlreadyExistsError;

package/dist/errors/StreamProtocolToolkitError.d.ts

@@ -0,0 +1,3 @@
+export declare class StreamProtocolToolkitError extends Error {
+    constructor(message?: string);
+}

package/dist/errors/StreamProtocolToolkitError.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolToolkitError = void 0;
+class StreamProtocolToolkitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, new.target);
+        }
+    }
+}
+exports.StreamProtocolToolkitError = StreamProtocolToolkitError;

package/dist/errors/StreamProtocolToolkitNotImplementedError.d.ts

@@ -0,0 +1,3 @@
+import { StreamProtocolToolkitError } from './StreamProtocolToolkitError';
+export declare class StreamProtocolToolkitNotImplementedError extends StreamProtocolToolkitError {
+}

package/dist/errors/StreamProtocolToolkitNotImplementedError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolToolkitNotImplementedError = void 0;
+const StreamProtocolToolkitError_1 = require("./StreamProtocolToolkitError");
+class StreamProtocolToolkitNotImplementedError extends StreamProtocolToolkitError_1.StreamProtocolToolkitError {
+}
+exports.StreamProtocolToolkitNotImplementedError = StreamProtocolToolkitNotImplementedError;

package/dist/errors/StreamProtocolToolkitTypeError.d.ts

@@ -0,0 +1,3 @@
+import { StreamProtocolToolkitError } from './StreamProtocolToolkitError';
+export declare class StreamProtocolToolkitTypeError extends StreamProtocolToolkitError {
+}

package/dist/errors/StreamProtocolToolkitTypeError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolToolkitTypeError = void 0;
+const StreamProtocolToolkitError_1 = require("./StreamProtocolToolkitError");
+class StreamProtocolToolkitTypeError extends StreamProtocolToolkitError_1.StreamProtocolToolkitError {
+}
+exports.StreamProtocolToolkitTypeError = StreamProtocolToolkitTypeError;

package/dist/errors/index.d.ts

@@ -0,0 +1,4 @@
+export { StreamProtocolToolkitError } from './StreamProtocolToolkitError';
+export { StreamProtocolToolkitTypeError } from './StreamProtocolToolkitTypeError';
+export { StreamProtocolToolkitAlreadyExistsError } from './StreamProtocolToolkitAlreadyExistsError';
+export { StreamProtocolToolkitNotImplementedError } from './StreamProtocolToolkitNotImplementedError';

package/dist/errors/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamProtocolToolkitNotImplementedError = exports.StreamProtocolToolkitAlreadyExistsError = exports.StreamProtocolToolkitTypeError = exports.StreamProtocolToolkitError = void 0;
+var StreamProtocolToolkitError_1 = require("./StreamProtocolToolkitError");
+Object.defineProperty(exports, "StreamProtocolToolkitError", { enumerable: true, get: function () { return StreamProtocolToolkitError_1.StreamProtocolToolkitError; } });
+var StreamProtocolToolkitTypeError_1 = require("./StreamProtocolToolkitTypeError");
+Object.defineProperty(exports, "StreamProtocolToolkitTypeError", { enumerable: true, get: function () { return StreamProtocolToolkitTypeError_1.StreamProtocolToolkitTypeError; } });
+var StreamProtocolToolkitAlreadyExistsError_1 = require("./StreamProtocolToolkitAlreadyExistsError");
+Object.defineProperty(exports, "StreamProtocolToolkitAlreadyExistsError", { enumerable: true, get: function () { return StreamProtocolToolkitAlreadyExistsError_1.StreamProtocolToolkitAlreadyExistsError; } });
+var StreamProtocolToolkitNotImplementedError_1 = require("./StreamProtocolToolkitNotImplementedError");
+Object.defineProperty(exports, "StreamProtocolToolkitNotImplementedError", { enumerable: true, get: function () { return StreamProtocolToolkitNotImplementedError_1.StreamProtocolToolkitNotImplementedError; } });

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './utils';
+export * from './errors';
+export * from './Protocol';
+export * from './RawPacket';
+export * from './Application';
+export * from './StreamBuffer';
+export * from './StreamContext';
+export * from './ProtocolHandler';
+export * from './StreamProtocolProcessor';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./Protocol"), exports);
+__exportStar(require("./RawPacket"), exports);
+__exportStar(require("./Application"), exports);
+__exportStar(require("./StreamBuffer"), exports);
+__exportStar(require("./StreamContext"), exports);
+__exportStar(require("./ProtocolHandler"), exports);
+__exportStar(require("./StreamProtocolProcessor"), exports);

package/dist/utils/any-signal.d.ts

@@ -0,0 +1 @@
+export declare function anySignal(signals: AbortSignal[]): AbortSignal;

package/dist/utils/any-signal.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anySignal = anySignal;
+function anySignal(signals) {
+    const handlers = new Map();
+    const controller = new AbortController();
+    const cleanup = function () {
+        for (const [signal, handler] of handlers) {
+            signal.removeEventListener('abort', handler);
+        }
+        handlers.clear();
+    };
+    for (const signal of signals) {
+        if (!signal) {
+            continue;
+        }
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+            cleanup();
+            return controller.signal;
+        }
+        const handler = function () {
+            controller.abort(signal.reason);
+        };
+        handlers.set(signal, handler);
+        signal.addEventListener('abort', handler, {
+            once: true
+        });
+    }
+    controller.signal.addEventListener('abort', cleanup, {
+        once: true
+    });
+    return controller.signal;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { anySignal } from './any-signal';
+export { isPlainObject } from './is-plain-object';
+export { isReadableStreamAlive } from './is-readable-stream-alive';
+export { isWritableStreamAlive } from './is-writable-stream-alive';
+export { readPausedStreamChunk } from './read-paused-stream-chunk';

package/dist/utils/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPausedStreamChunk = exports.isWritableStreamAlive = exports.isReadableStreamAlive = exports.isPlainObject = exports.anySignal = void 0;
+var any_signal_1 = require("./any-signal");
+Object.defineProperty(exports, "anySignal", { enumerable: true, get: function () { return any_signal_1.anySignal; } });
+var is_plain_object_1 = require("./is-plain-object");
+Object.defineProperty(exports, "isPlainObject", { enumerable: true, get: function () { return is_plain_object_1.isPlainObject; } });
+var is_readable_stream_alive_1 = require("./is-readable-stream-alive");
+Object.defineProperty(exports, "isReadableStreamAlive", { enumerable: true, get: function () { return is_readable_stream_alive_1.isReadableStreamAlive; } });
+var is_writable_stream_alive_1 = require("./is-writable-stream-alive");
+Object.defineProperty(exports, "isWritableStreamAlive", { enumerable: true, get: function () { return is_writable_stream_alive_1.isWritableStreamAlive; } });
+var read_paused_stream_chunk_1 = require("./read-paused-stream-chunk");
+Object.defineProperty(exports, "readPausedStreamChunk", { enumerable: true, get: function () { return read_paused_stream_chunk_1.readPausedStreamChunk; } });

package/dist/utils/is-plain-object.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject<T extends object>(value: T): boolean;

package/dist/utils/is-plain-object.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null) {
+        return true;
+    }
+    return Object.getPrototypeOf(proto) === null;
+}

package/dist/utils/is-readable-stream-alive.d.ts

@@ -0,0 +1,2 @@
+import type { Readable } from 'stream';
+export declare function isReadableStreamAlive(stream: Readable): boolean;

package/dist/utils/is-readable-stream-alive.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReadableStreamAlive = isReadableStreamAlive;
+function isReadableStreamAlive(stream) {
+    if (!stream ||
+        stream.readable === false ||
+        stream.errored ||
+        stream.closed === true ||
+        stream.destroyed === true ||
+        stream.readableEnded === true) {
+        return false;
+    }
+    const readableState = stream._readableState;
+    if (readableState) {
+        if (readableState.destroyed ||
+            readableState.ended && readableState.endEmitted) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/utils/is-writable-stream-alive.d.ts

@@ -0,0 +1,2 @@
+import type { Writable } from 'stream';
+export declare function isWritableStreamAlive(stream: Writable): boolean;

package/dist/utils/is-writable-stream-alive.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWritableStreamAlive = isWritableStreamAlive;
+function isWritableStreamAlive(stream) {
+    if (!stream ||
+        stream.writable === false ||
+        stream.errored ||
+        stream.closed === true ||
+        stream.destroyed === true ||
+        stream.writableEnded === true ||
+        stream.writableFinished === true) {
+        return false;
+    }
+    const writableState = stream._writableState;
+    if (writableState) {
+        if (writableState.destroyed ||
+            writableState.errored ||
+            writableState.errorEmitted === true ||
+            (writableState.ending === true || writableState.ended === true || writableState.finished === true)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/utils/read-paused-stream-chunk.d.ts

@@ -0,0 +1,3 @@
+import { Buffer } from 'buffer';
+import type { Readable } from 'stream';
+export declare function readPausedStreamChunk(stream: Readable): Promise<Buffer>;

package/dist/utils/read-paused-stream-chunk.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPausedStreamChunk = readPausedStreamChunk;
+const buffer_1 = require("buffer");
+const errors_1 = require("../errors");
+const is_readable_stream_alive_1 = require("./is-readable-stream-alive");
+function waitReadable(stream) {
+    return new Promise(function (resolve, reject) {
+        const onReadable = function () {
+            cleanup();
+            resolve();
+        };
+        const onEnd = function () {
+            cleanup();
+            reject(new errors_1.StreamProtocolToolkitError('STREAM_ENDED'));
+        };
+        const onClose = function () {
+            cleanup();
+            reject(new errors_1.StreamProtocolToolkitError('STREAM_CLOSED'));
+        };
+        const onError = function (err) {
+            cleanup();
+            reject(err);
+        };
+        const cleanup = function () {
+            stream.removeListener('readable', onReadable);
+            stream.removeListener('end', onEnd);
+            stream.removeListener('close', onClose);
+            stream.removeListener('error', onError);
+        };
+        stream.once('readable', onReadable);
+        stream.once('end', onEnd);
+        stream.once('close', onClose);
+        stream.once('error', onError);
+    });
+}
+async function readPausedStreamChunk(stream) {
+    if (!stream.isPaused()) {
+        throw new errors_1.StreamProtocolToolkitError('STREAM_NOT_PAUSED');
+    }
+    while (true) {
+        if (!(0, is_readable_stream_alive_1.isReadableStreamAlive)(stream)) {
+            throw new errors_1.StreamProtocolToolkitError('INVALID_READABLE_STREAM');
+        }
+        const chunk = stream.read();
+        if (chunk !== null) {
+            return typeof chunk === 'string' ? buffer_1.Buffer.from(chunk) : chunk;
+        }
+        await waitReadable(stream);
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "stream-protocol-toolkit",
+  "version": "0.1.0",
+  "description": "Node.js stream protocol toolkit",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run clean && node ./node_modules/.bin/tsc",
+    "clean": "node -e \"['./dist'].forEach(item => require('fs').rmSync(item, {recursive:true,force:true}));\"",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mvcbox/node-stream-protocol-toolkit.git"
+  },
+  "keywords": [
+    "Buffer",
+    "Binary data"
+  ],
+  "author": "mvcbox.org@gmail.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mvcbox/node-stream-protocol-toolkit/issues"
+  },
+  "homepage": "https://github.com/mvcbox/node-stream-protocol-toolkit#readme",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "extended-buffer": "^7.4.0",
+    "utility-types": "^3.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^16.18.126",
+    "typescript": "^5.9.3"
+  }
+}