stream-protocol-toolkit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Custos Dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# node-stream-protocol-toolkit
+node-stream-protocol-toolkit
+
+---
+
+# Debug version

package/dist/Application/Application.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from 'events';
+import { Protocol } from '../Protocol';
+import type { Class } from 'utility-types';
+import type { StreamContext } from '../StreamContext';
+import type { ProtocolHandler } from '../ProtocolHandler';
+import type { StreamBufferOptions } from '../StreamBuffer';
+import type { ApplicationOptions } from './ApplicationOptions';
+import type { ApplicationEventMap } from './ApplicationEventMap';
+import type { StartStreamInputDTO, StartStreamOutputDTO } from './start-stream';
+import { Readable, Writable } from 'stream';
+import type { ApplicationUnknownProtocolHandler } from './ApplicationUnknownProtocolHandler';
+import type { CreateStreamContextInputDTO, CreateStreamContextOutputDTO } from './create-stream-context';
+import { StreamBufferFactory, StreamContextFactory, ApplicationStateFactory, StreamContextStateFactory, TransformStreamHandlerFactory, StreamProtocolProcessorFactory } from './factories';
+type ProtocolRecord<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    protocolClass: typeof Protocol;
+    protocolHandler: ProtocolHandler<Protocol, ISTREAM, OSTREAM, AS, SCS>;
+};
+export declare class Application<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> {
+    readonly applicationState: AS;
+    readonly abortController: AbortController;
+    readonly streamBufferOptions?: StreamBufferOptions;
+    readonly protocols: Map<number, ProtocolRecord<ISTREAM, OSTREAM, AS, SCS>>;
+    readonly attachedStreamContexts: Set<StreamContext<ISTREAM, OSTREAM, AS, SCS>>;
+    readonly eventBus: EventEmitter<ApplicationEventMap<ISTREAM, OSTREAM, AS, SCS>>;
+    readonly streamBufferFactory: StreamBufferFactory<ISTREAM, OSTREAM, AS, SCS>;
+    readonly streamContextFactory: StreamContextFactory<ISTREAM, OSTREAM, AS, SCS>;
+    readonly applicationStateFactory: ApplicationStateFactory<ISTREAM, OSTREAM, AS, SCS>;
+    readonly streamContextStateFactory: StreamContextStateFactory<ISTREAM, OSTREAM, AS, SCS>;
+    readonly transformStreamHandlerFactory: TransformStreamHandlerFactory<ISTREAM, OSTREAM, AS, SCS>;
+    readonly streamProtocolProcessorFactory: StreamProtocolProcessorFactory<ISTREAM, OSTREAM, AS, SCS>;
+    unknownProtocolHandler?: ApplicationUnknownProtocolHandler<ISTREAM, OSTREAM, AS, SCS>;
+    constructor(options?: ApplicationOptions<ISTREAM, OSTREAM, AS, SCS>);
+    addProtocol<PROT extends Protocol>(protocol: Class<PROT>, protocolHandler: ProtocolHandler<PROT, ISTREAM, OSTREAM, AS, SCS>): this;
+    removeProtocol(opcode: number): this;
+    setUnknownProtocolHandler(handler: ApplicationUnknownProtocolHandler<ISTREAM, OSTREAM, AS, SCS> | undefined): this;
+    createStreamContext(input: CreateStreamContextInputDTO<ISTREAM, OSTREAM, AS, SCS>): CreateStreamContextOutputDTO<ISTREAM, OSTREAM, AS, SCS>;
+    startStream(input: StartStreamInputDTO<ISTREAM, OSTREAM, AS, SCS>): Promise<StartStreamOutputDTO<ISTREAM, OSTREAM, AS, SCS>>;
+}
+export {};

package/dist/Application/Application.js

@@ -0,0 +1,156 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = void 0;
+const utils = __importStar(require("../utils"));
+const events_1 = require("events");
+const stream_1 = require("stream");
+const errors_1 = require("../errors");
+const factories_1 = require("./factories");
+class Application {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        this.abortController = new AbortController();
+        this.streamBufferOptions = options === null || options === void 0 ? void 0 : options.streamBufferOptions;
+        this.protocols = new Map();
+        this.eventBus = new events_1.EventEmitter();
+        this.attachedStreamContexts = new Set();
+        this.streamBufferFactory = (_a = options === null || options === void 0 ? void 0 : options.streamBufferFactory) !== null && _a !== void 0 ? _a : (factories_1.streamBufferFactory);
+        this.streamContextFactory = (_b = options === null || options === void 0 ? void 0 : options.streamContextFactory) !== null && _b !== void 0 ? _b : (factories_1.streamContextFactory);
+        this.applicationStateFactory = (_c = options === null || options === void 0 ? void 0 : options.applicationStateFactory) !== null && _c !== void 0 ? _c : (factories_1.applicationStateFactory);
+        this.streamContextStateFactory = (_d = options === null || options === void 0 ? void 0 : options.streamContextStateFactory) !== null && _d !== void 0 ? _d : (factories_1.streamContextStateFactory);
+        this.transformStreamHandlerFactory = (_e = options === null || options === void 0 ? void 0 : options.transformStreamHandlerFactory) !== null && _e !== void 0 ? _e : (factories_1.transformStreamHandlerFactory);
+        this.streamProtocolProcessorFactory = (_f = options === null || options === void 0 ? void 0 : options.streamProtocolProcessorFactory) !== null && _f !== void 0 ? _f : (factories_1.streamProtocolProcessorFactory);
+        this.applicationState = this.applicationStateFactory({
+            application: this
+        }).applicationState;
+    }
+    addProtocol(protocol, protocolHandler) {
+        const _protocol = protocol;
+        if (this.protocols.has(_protocol._opcode)) {
+            throw new errors_1.StreamProtocolToolkitAlreadyExistsError('PROTOCOL_ALREADY_REGISTERED');
+        }
+        this.protocols.set(_protocol._opcode, {
+            protocolClass: _protocol,
+            protocolHandler
+        });
+        return this;
+    }
+    removeProtocol(opcode) {
+        const protocol = this.protocols.get(opcode);
+        if (!protocol) {
+            throw new errors_1.StreamProtocolToolkitAlreadyExistsError('PROTOCOL_NOT_REGISTERED');
+        }
+        this.protocols.delete(opcode);
+        return this;
+    }
+    setUnknownProtocolHandler(handler) {
+        this.unknownProtocolHandler = handler;
+        return this;
+    }
+    createStreamContext(input) {
+        const { streamContext } = this.streamContextFactory(input);
+        setImmediate(() => {
+            this.eventBus.emit(1, streamContext);
+        });
+        return {
+            streamContext
+        };
+    }
+    async startStream(input) {
+        var _a, _b;
+        const { streamContext } = input;
+        if (streamContext.application !== this) {
+            throw new errors_1.StreamProtocolToolkitError('STREAM_CONTEXT_BELONGS_ANOTHER_APPLICATION_INSTANCE');
+        }
+        if (this.attachedStreamContexts.has(streamContext)) {
+            throw new errors_1.StreamProtocolToolkitError('STREAM_CONTEXT_ALREADY_STARTED');
+        }
+        this.attachedStreamContexts.add(streamContext);
+        try {
+            setImmediate(() => {
+                this.eventBus.emit(2, streamContext);
+            });
+            const { transformStreamHandler } = this.transformStreamHandlerFactory({
+                streamContext
+            });
+            const inputPipe = [
+                streamContext.input,
+                ...((_a = streamContext.inputTransform) !== null && _a !== void 0 ? _a : []),
+                transformStreamHandler
+            ];
+            const outputPipe = [
+                transformStreamHandler
+            ];
+            if (streamContext.output) {
+                outputPipe.push(...((_b = streamContext.outputTransform) !== null && _b !== void 0 ? _b : []));
+                outputPipe.push(streamContext.output);
+            }
+            else {
+                outputPipe.push(new stream_1.Writable({
+                    write(chunk, encoding, callback) {
+                        callback();
+                    }
+                }));
+            }
+            const abortSignal = utils.anySignal([
+                streamContext.abortController.signal,
+                streamContext.application.abortController.signal
+            ]);
+            await Promise.all([
+                stream_1.promises.pipeline(inputPipe, {
+                    signal: abortSignal
+                }),
+                stream_1.promises.pipeline(outputPipe, {
+                    signal: abortSignal
+                })
+            ]);
+        }
+        catch (e) {
+            streamContext.abortController.abort(e);
+            setImmediate(() => {
+                this.eventBus.emit(0, e);
+            });
+            throw e;
+        }
+        finally {
+            this.attachedStreamContexts.delete(streamContext);
+            setImmediate(() => {
+                this.eventBus.emit(3, streamContext);
+            });
+        }
+    }
+}
+exports.Application = Application;

package/dist/Application/ApplicationEventEnum.d.ts

@@ -0,0 +1,6 @@
+export declare const enum ApplicationEventEnum {
+    STREAM_CONTEXT_ERROR = 0,
+    STREAM_CONTEXT_CREATED = 1,
+    STREAM_CONTEXT_ATTACHED = 2,
+    STREAM_CONTEXT_DETACHED = 3
+}

package/dist/Application/ApplicationEventEnum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationEventEnum = void 0;
+var ApplicationEventEnum;
+(function (ApplicationEventEnum) {
+    ApplicationEventEnum[ApplicationEventEnum["STREAM_CONTEXT_ERROR"] = 0] = "STREAM_CONTEXT_ERROR";
+    ApplicationEventEnum[ApplicationEventEnum["STREAM_CONTEXT_CREATED"] = 1] = "STREAM_CONTEXT_CREATED";
+    ApplicationEventEnum[ApplicationEventEnum["STREAM_CONTEXT_ATTACHED"] = 2] = "STREAM_CONTEXT_ATTACHED";
+    ApplicationEventEnum[ApplicationEventEnum["STREAM_CONTEXT_DETACHED"] = 3] = "STREAM_CONTEXT_DETACHED";
+})(ApplicationEventEnum || (exports.ApplicationEventEnum = ApplicationEventEnum = {}));

package/dist/Application/ApplicationEventMap.d.ts

@@ -0,0 +1,15 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamContext } from '../StreamContext';
+import type { ApplicationEventEnum } from './ApplicationEventEnum';
+export type ApplicationEventMap<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    [ApplicationEventEnum.STREAM_CONTEXT_ERROR]: [err: any];
+    [ApplicationEventEnum.STREAM_CONTEXT_CREATED]: [
+        streamContext: StreamContext<ISTREAM, OSTREAM, AS, SCS>
+    ];
+    [ApplicationEventEnum.STREAM_CONTEXT_ATTACHED]: [
+        streamContext: StreamContext<ISTREAM, OSTREAM, AS, SCS>
+    ];
+    [ApplicationEventEnum.STREAM_CONTEXT_DETACHED]: [
+        streamContext: StreamContext<ISTREAM, OSTREAM, AS, SCS>
+    ];
+};

package/dist/Application/ApplicationEventMap.js

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

package/dist/Application/ApplicationOptions.d.ts

@@ -0,0 +1,12 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamBufferOptions } from '../StreamBuffer';
+import { StreamBufferFactory, StreamContextFactory, ApplicationStateFactory, StreamContextStateFactory, TransformStreamHandlerFactory, StreamProtocolProcessorFactory } from './factories';
+export type ApplicationOptions<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    streamBufferOptions?: StreamBufferOptions;
+    streamBufferFactory?: StreamBufferFactory<ISTREAM, OSTREAM, AS, SCS>;
+    streamContextFactory?: StreamContextFactory<ISTREAM, OSTREAM, AS, SCS>;
+    applicationStateFactory?: ApplicationStateFactory<ISTREAM, OSTREAM, AS, SCS>;
+    streamContextStateFactory?: StreamContextStateFactory<ISTREAM, OSTREAM, AS, SCS>;
+    transformStreamHandlerFactory: TransformStreamHandlerFactory<ISTREAM, OSTREAM, AS, SCS>;
+    streamProtocolProcessorFactory?: StreamProtocolProcessorFactory<ISTREAM, OSTREAM, AS, SCS>;
+};

package/dist/Application/ApplicationOptions.js

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

package/dist/Application/ApplicationState.d.ts

@@ -0,0 +1 @@
+export type ApplicationState<AS extends object> = AS;

package/dist/Application/ApplicationState.js

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

package/dist/Application/ApplicationUnknownProtocolHandler.d.ts

@@ -0,0 +1,5 @@
+import type { Buffer } from 'buffer';
+import type { RawPacket } from '../RawPacket';
+import type { Readable, Writable } from 'stream';
+import type { StreamContext } from '../StreamContext';
+export type ApplicationUnknownProtocolHandler<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = (rawPacket: RawPacket, streamContext: StreamContext<ISTREAM, OSTREAM, AS, SCS>) => Promise<Buffer | void>;

package/dist/Application/ApplicationUnknownProtocolHandler.js

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

package/dist/Application/create-stream-context/CreateStreamContextInputDTO.d.ts

@@ -0,0 +1,3 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamContextOptions } from '../../StreamContext';
+export type CreateStreamContextInputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = Pick<StreamContextOptions<ISTREAM, OSTREAM, AS, SCS>, 'input' | 'inputTransform' | 'output' | 'outputTransform'>;

package/dist/Application/create-stream-context/CreateStreamContextInputDTO.js

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

package/dist/Application/create-stream-context/CreateStreamContextOutputDTO.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamContext } from '../../StreamContext';
+export type CreateStreamContextOutputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    streamContext: StreamContext<ISTREAM, OSTREAM, AS, SCS>;
+};

package/dist/Application/create-stream-context/CreateStreamContextOutputDTO.js

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

package/dist/Application/create-stream-context/index.d.ts

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

package/dist/Application/create-stream-context/index.js

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

package/dist/Application/factories/application-state-factory/ApplicationStateFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { ApplicationStateFactoryInputDTO } from './ApplicationStateFactoryInputDTO';
+import type { ApplicationStateFactoryOutputDTO } from './ApplicationStateFactoryOutputDTO';
+export type ApplicationStateFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = (this: Application<ISTREAM, OSTREAM, AS, SCS>, input: ApplicationStateFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>) => ApplicationStateFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/application-state-factory/ApplicationStateFactory.js

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

package/dist/Application/factories/application-state-factory/ApplicationStateFactoryInputDTO.d.ts

@@ -0,0 +1,2 @@
+import type { Readable, Writable } from 'stream';
+export type ApplicationStateFactoryInputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {};

package/dist/Application/factories/application-state-factory/ApplicationStateFactoryInputDTO.js

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

package/dist/Application/factories/application-state-factory/ApplicationStateFactoryOutputDTO.d.ts

@@ -0,0 +1,4 @@
+import type { Readable, Writable } from 'stream';
+export type ApplicationStateFactoryOutputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    applicationState: AS;
+};

package/dist/Application/factories/application-state-factory/ApplicationStateFactoryOutputDTO.js

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

package/dist/Application/factories/application-state-factory/application-state-factory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { ApplicationStateFactoryInputDTO } from './ApplicationStateFactoryInputDTO';
+import type { ApplicationStateFactoryOutputDTO } from './ApplicationStateFactoryOutputDTO';
+export declare function applicationStateFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object>(this: Application<ISTREAM, OSTREAM, AS, SCS>, input: ApplicationStateFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>): ApplicationStateFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/application-state-factory/application-state-factory.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationStateFactory = applicationStateFactory;
+function applicationStateFactory(input) {
+    return {
+        applicationState: {}
+    };
+}

package/dist/Application/factories/application-state-factory/index.d.ts

@@ -0,0 +1,4 @@
+export { applicationStateFactory } from './application-state-factory';
+export type { ApplicationStateFactory } from './ApplicationStateFactory';
+export type { ApplicationStateFactoryInputDTO } from './ApplicationStateFactoryInputDTO';
+export type { ApplicationStateFactoryOutputDTO } from './ApplicationStateFactoryOutputDTO';

package/dist/Application/factories/application-state-factory/index.js

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

package/dist/Application/factories/index.d.ts

@@ -0,0 +1,6 @@
+export * from './stream-buffer-factory';
+export * from './stream-context-factory';
+export * from './application-state-factory';
+export * from './stream-context-state-factory';
+export * from './transform-stream-handler-factory';
+export * from './stream-protocol-processor-factory';

package/dist/Application/factories/index.js

@@ -0,0 +1,22 @@
+"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("./stream-buffer-factory"), exports);
+__exportStar(require("./stream-context-factory"), exports);
+__exportStar(require("./application-state-factory"), exports);
+__exportStar(require("./stream-context-state-factory"), exports);
+__exportStar(require("./transform-stream-handler-factory"), exports);
+__exportStar(require("./stream-protocol-processor-factory"), exports);

package/dist/Application/factories/stream-buffer-factory/StreamBufferFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { StreamBufferFactoryInputDTO } from './StreamBufferFactoryInputDTO';
+import type { StreamBufferFactoryOutputDTO } from './StreamBufferFactoryOutputDTO';
+export type StreamBufferFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = (this: Application<ISTREAM, OSTREAM, AS, SCS>, input: StreamBufferFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>) => StreamBufferFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/stream-buffer-factory/StreamBufferFactory.js

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

package/dist/Application/factories/stream-buffer-factory/StreamBufferFactoryInputDTO.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamBufferOptions } from '../../../StreamBuffer';
+export type StreamBufferFactoryInputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    streamBufferOptions?: StreamBufferOptions;
+};

package/dist/Application/factories/stream-buffer-factory/StreamBufferFactoryInputDTO.js

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

package/dist/Application/factories/stream-buffer-factory/StreamBufferFactoryOutputDTO.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamBuffer } from '../../../StreamBuffer';
+export type StreamBufferFactoryOutputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    streamBuffer: StreamBuffer;
+};

package/dist/Application/factories/stream-buffer-factory/StreamBufferFactoryOutputDTO.js

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

package/dist/Application/factories/stream-buffer-factory/index.d.ts

@@ -0,0 +1,4 @@
+export { streamBufferFactory } from './stream-buffer-factory';
+export type { StreamBufferFactory } from './StreamBufferFactory';
+export type { StreamBufferFactoryInputDTO } from './StreamBufferFactoryInputDTO';
+export type { StreamBufferFactoryOutputDTO } from './StreamBufferFactoryOutputDTO';

package/dist/Application/factories/stream-buffer-factory/index.js

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

package/dist/Application/factories/stream-buffer-factory/stream-buffer-factory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { StreamBufferFactoryInputDTO } from './StreamBufferFactoryInputDTO';
+import type { StreamBufferFactoryOutputDTO } from './StreamBufferFactoryOutputDTO';
+export declare function streamBufferFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object>(this: Application<ISTREAM, OSTREAM, AS, SCS>, input: StreamBufferFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>): StreamBufferFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/stream-buffer-factory/stream-buffer-factory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamBufferFactory = streamBufferFactory;
+const StreamBuffer_1 = require("../../../StreamBuffer");
+function streamBufferFactory(input) {
+    var _a;
+    return {
+        streamBuffer: new StreamBuffer_1.StreamBuffer((_a = input.streamBufferOptions) !== null && _a !== void 0 ? _a : this.streamBufferOptions)
+    };
+}

package/dist/Application/factories/stream-context-factory/StreamContextFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { StreamContextFactoryInputDTO } from './StreamContextFactoryInputDTO';
+import type { StreamContextFactoryOutputDTO } from './StreamContextFactoryOutputDTO';
+export type StreamContextFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = (this: Application<ISTREAM, OSTREAM, AS, SCS>, input: StreamContextFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>) => StreamContextFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/stream-context-factory/StreamContextFactory.js

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

package/dist/Application/factories/stream-context-factory/StreamContextFactoryInputDTO.d.ts

@@ -0,0 +1,3 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamContextOptions } from '../../../StreamContext';
+export type StreamContextFactoryInputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = Omit<StreamContextOptions<ISTREAM, OSTREAM, AS, SCS>, 'streamContextState' | 'streamProtocolProcessor' | 'application'>;

package/dist/Application/factories/stream-context-factory/StreamContextFactoryInputDTO.js

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

package/dist/Application/factories/stream-context-factory/StreamContextFactoryOutputDTO.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { StreamContext } from '../../../StreamContext';
+export type StreamContextFactoryOutputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    streamContext: StreamContext<ISTREAM, OSTREAM, AS, SCS>;
+};

package/dist/Application/factories/stream-context-factory/StreamContextFactoryOutputDTO.js

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

package/dist/Application/factories/stream-context-factory/index.d.ts

@@ -0,0 +1,4 @@
+export { streamContextFactory } from './stream-context-factory';
+export type { StreamContextFactory } from './StreamContextFactory';
+export type { StreamContextFactoryInputDTO } from './StreamContextFactoryInputDTO';
+export type { StreamContextFactoryOutputDTO } from './StreamContextFactoryOutputDTO';

package/dist/Application/factories/stream-context-factory/index.js

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

package/dist/Application/factories/stream-context-factory/stream-context-factory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { StreamContextFactoryInputDTO } from './StreamContextFactoryInputDTO';
+import type { StreamContextFactoryOutputDTO } from './StreamContextFactoryOutputDTO';
+export declare function streamContextFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object>(this: Application<ISTREAM, OSTREAM, AS, SCS>, input: StreamContextFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>): StreamContextFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/stream-context-factory/stream-context-factory.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamContextFactory = streamContextFactory;
+const StreamContext_1 = require("../../../StreamContext");
+function streamContextFactory(input) {
+    const { streamContextState } = this.streamContextStateFactory({});
+    const { streamProtocolProcessor } = this.streamProtocolProcessorFactory({});
+    return {
+        streamContext: new StreamContext_1.StreamContext(Object.assign(Object.assign({}, input), { streamProtocolProcessor,
+            streamContextState, application: this }))
+    };
+}

package/dist/Application/factories/stream-context-state-factory/StreamContextStateFactory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { StreamContextStateFactoryInputDTO } from './StreamContextStateFactoryInputDTO';
+import type { StreamContextStateFactoryOutputDTO } from './StreamContextStateFactoryOutputDTO';
+export type StreamContextStateFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = (this: Application<ISTREAM, OSTREAM, AS, SCS>, input: StreamContextStateFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>) => StreamContextStateFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;

package/dist/Application/factories/stream-context-state-factory/StreamContextStateFactory.js

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

package/dist/Application/factories/stream-context-state-factory/StreamContextStateFactoryInputDTO.d.ts

@@ -0,0 +1,2 @@
+import type { Readable, Writable } from 'stream';
+export type StreamContextStateFactoryInputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {};

package/dist/Application/factories/stream-context-state-factory/StreamContextStateFactoryInputDTO.js

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

package/dist/Application/factories/stream-context-state-factory/StreamContextStateFactoryOutputDTO.d.ts

@@ -0,0 +1,4 @@
+import type { Readable, Writable } from 'stream';
+export type StreamContextStateFactoryOutputDTO<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> = {
+    streamContextState: SCS;
+};

package/dist/Application/factories/stream-context-state-factory/StreamContextStateFactoryOutputDTO.js

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

package/dist/Application/factories/stream-context-state-factory/index.d.ts

@@ -0,0 +1,4 @@
+export { streamContextStateFactory } from './stream-context-state-factory';
+export type { StreamContextStateFactory } from './StreamContextStateFactory';
+export type { StreamContextStateFactoryInputDTO } from './StreamContextStateFactoryInputDTO';
+export type { StreamContextStateFactoryOutputDTO } from './StreamContextStateFactoryOutputDTO';

package/dist/Application/factories/stream-context-state-factory/index.js

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

package/dist/Application/factories/stream-context-state-factory/stream-context-state-factory.d.ts

@@ -0,0 +1,5 @@
+import type { Readable, Writable } from 'stream';
+import type { Application } from '../../Application';
+import type { StreamContextStateFactoryInputDTO } from './StreamContextStateFactoryInputDTO';
+import type { StreamContextStateFactoryOutputDTO } from './StreamContextStateFactoryOutputDTO';
+export declare function streamContextStateFactory<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object>(this: Application<ISTREAM, OSTREAM, AS, SCS>, input: StreamContextStateFactoryInputDTO<ISTREAM, OSTREAM, AS, SCS>): StreamContextStateFactoryOutputDTO<ISTREAM, OSTREAM, AS, SCS>;