stream-protocol-toolkit 0.1.0

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

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

package/dist/Application/factories/stream-protocol-processor-factory/StreamProtocolProcessorFactory.d.ts

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

package/dist/Application/factories/stream-protocol-processor-factory/StreamProtocolProcessorFactory.js

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

package/dist/Application/factories/stream-protocol-processor-factory/StreamProtocolProcessorFactoryInputDTO.d.ts

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

package/dist/Application/factories/stream-protocol-processor-factory/StreamProtocolProcessorFactoryInputDTO.js

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

package/dist/Application/factories/stream-protocol-processor-factory/StreamProtocolProcessorFactoryOutputDTO.d.ts

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

package/dist/Application/factories/stream-protocol-processor-factory/StreamProtocolProcessorFactoryOutputDTO.js

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

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

@@ -0,0 +1,4 @@
+export { streamProtocolProcessorFactory } from './stream-protocol-processor-factory';
+export type { StreamProtocolProcessorFactory } from './StreamProtocolProcessorFactory';
+export type { StreamProtocolProcessorFactoryInputDTO } from './StreamProtocolProcessorFactoryInputDTO';
+export type { StreamProtocolProcessorFactoryOutputDTO } from './StreamProtocolProcessorFactoryOutputDTO';

package/dist/Application/factories/stream-protocol-processor-factory/index.js

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

package/dist/Application/factories/stream-protocol-processor-factory/stream-protocol-processor-factory.d.ts

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

package/dist/Application/factories/stream-protocol-processor-factory/stream-protocol-processor-factory.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamProtocolProcessorFactory = streamProtocolProcessorFactory;
+const StreamProtocolProcessor_1 = require("../../../StreamProtocolProcessor");
+function streamProtocolProcessorFactory(input) {
+    const { streamBuffer } = this.streamBufferFactory({});
+    return {
+        streamProtocolProcessor: new StreamProtocolProcessor_1.StreamProtocolProcessor({
+            streamBuffer,
+            application: this
+        })
+    };
+}

package/dist/Application/factories/transform-stream-handler-factory/TransformStreamHandlerFactory.d.ts

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

package/dist/Application/factories/transform-stream-handler-factory/TransformStreamHandlerFactory.js

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

package/dist/Application/factories/transform-stream-handler-factory/TransformStreamHandlerFactoryInputDTO.d.ts

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

package/dist/Application/factories/transform-stream-handler-factory/TransformStreamHandlerFactoryInputDTO.js

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

package/dist/Application/factories/transform-stream-handler-factory/TransformStreamHandlerFactoryOutputDTO.d.ts

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

package/dist/Application/factories/transform-stream-handler-factory/TransformStreamHandlerFactoryOutputDTO.js

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

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

@@ -0,0 +1,4 @@
+export { transformStreamHandlerFactory } from './transform-stream-handler-factory';
+export type { TransformStreamHandlerFactory } from './TransformStreamHandlerFactory';
+export type { TransformStreamHandlerFactoryInputDTO } from './TransformStreamHandlerFactoryInputDTO';
+export type { TransformStreamHandlerFactoryOutputDTO } from './TransformStreamHandlerFactoryOutputDTO';

package/dist/Application/factories/transform-stream-handler-factory/index.js

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

package/dist/Application/factories/transform-stream-handler-factory/transform-stream-handler-factory.d.ts

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

package/dist/Application/factories/transform-stream-handler-factory/transform-stream-handler-factory.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStreamHandlerFactory = transformStreamHandlerFactory;
+const Protocol_1 = require("../../../Protocol");
+const StreamBuffer_1 = require("../../../StreamBuffer");
+const errors_1 = require("../../../errors");
+const stream_1 = require("stream");
+function transformStreamHandlerFactory(input) {
+    const { streamContext } = input;
+    const application = streamContext.application;
+    const streamProtocolProcessor = streamContext.streamProtocolProcessor;
+    const transformStreamHandler = new stream_1.Transform({
+        transform: async function (chunk, encoding, callback) {
+            try {
+                streamProtocolProcessor.pushChunk(chunk).assertState();
+                if (streamProtocolProcessor.packetIsReadable(streamProtocolProcessor.streamBuffer)) {
+                    do {
+                        const rawPacket = streamProtocolProcessor.readPacket(streamProtocolProcessor.streamBuffer);
+                        const protocol = application.protocols.get(rawPacket.opcode);
+                        if (protocol) {
+                            const protocolPacket = new protocol.protocolClass(rawPacket.payload);
+                            let result = await protocol.protocolHandler.handle({
+                                packet: protocolPacket,
+                                streamContext
+                            });
+                            if (result !== undefined) {
+                                if (result instanceof Protocol_1.Protocol) {
+                                    const protocolBuffer = result._marshal();
+                                    streamProtocolProcessor.writePacketHeader(protocolBuffer, {
+                                        opcode: result._opcode,
+                                        length: protocolBuffer.length
+                                    }, true);
+                                    this.push(protocolBuffer.nativeBufferView);
+                                }
+                                else if (result instanceof StreamBuffer_1.StreamBuffer) {
+                                    this.push(result.nativeBufferView);
+                                }
+                                else {
+                                    throw new errors_1.StreamProtocolToolkitError('PROTOCOL_HANDLER_INVALID_RESULT');
+                                }
+                            }
+                        }
+                        else if (application.unknownProtocolHandler) {
+                            const result = await application.unknownProtocolHandler(rawPacket, streamContext);
+                            if (result) {
+                                this.push(result);
+                            }
+                        }
+                        else {
+                            throw new errors_1.StreamProtocolToolkitError('UNHANDLED_RAW_PACKET');
+                        }
+                    } while (streamProtocolProcessor.packetIsReadable(streamProtocolProcessor.streamBuffer));
+                    streamProtocolProcessor.streamBuffer.discardReadData();
+                }
+                callback();
+            }
+            catch (e) {
+                callback(e !== null && e !== void 0 ? e : new errors_1.StreamProtocolToolkitError('UNKNOWN_TRANSFORM_STREAM_ERROR'));
+            }
+        }
+    });
+    return {
+        transformStreamHandler
+    };
+}

package/dist/Application/index.d.ts

@@ -0,0 +1,9 @@
+export * from './factories';
+export * from './start-stream';
+export * from './create-stream-context';
+export { Application } from './Application';
+export type { ApplicationState } from './ApplicationState';
+export { ApplicationEventEnum } from './ApplicationEventEnum';
+export type { ApplicationOptions } from './ApplicationOptions';
+export type { ApplicationEventMap } from './ApplicationEventMap';
+export type { ApplicationUnknownProtocolHandler } from './ApplicationUnknownProtocolHandler';

package/dist/Application/index.js

@@ -0,0 +1,24 @@
+"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 });
+exports.ApplicationEventEnum = exports.Application = void 0;
+__exportStar(require("./factories"), exports);
+__exportStar(require("./start-stream"), exports);
+__exportStar(require("./create-stream-context"), exports);
+var Application_1 = require("./Application");
+Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return Application_1.Application; } });
+var ApplicationEventEnum_1 = require("./ApplicationEventEnum");
+Object.defineProperty(exports, "ApplicationEventEnum", { enumerable: true, get: function () { return ApplicationEventEnum_1.ApplicationEventEnum; } });

package/dist/Application/start-stream/StartStreamInputDTO.d.ts

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

package/dist/Application/start-stream/StartStreamInputDTO.js

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

package/dist/Application/start-stream/StartStreamOutputDTO.d.ts

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

package/dist/Application/start-stream/StartStreamOutputDTO.js

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

package/dist/Application/start-stream/index.d.ts

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

package/dist/Application/start-stream/index.js

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

package/dist/Protocol/Protocol.d.ts

@@ -0,0 +1,12 @@
+import type { ProtocolInitValue } from './ProtocolInitValue';
+import { StreamBuffer, StreamBufferOptions } from '../StreamBuffer';
+export declare abstract class Protocol {
+    _isInitialized: boolean;
+    protected constructor();
+    _initialize<T extends Protocol>(initValue: ProtocolInitValue<T>): void;
+    _createBuffer(options?: StreamBufferOptions): StreamBuffer;
+    get _opcode(): number;
+    static get _opcode(): number;
+    abstract _marshal(): StreamBuffer;
+    abstract _unmarshal(buffer: StreamBuffer): void;
+}

package/dist/Protocol/Protocol.js

@@ -0,0 +1,84 @@
+"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.Protocol = void 0;
+const utils = __importStar(require("../utils"));
+const StreamBuffer_1 = require("../StreamBuffer");
+const errors_1 = require("../errors");
+const reservedPropertyNames = new Set([
+    '_opcode', '_isInitialized', '__proto__', 'constructor', 'prototype'
+]);
+class Protocol {
+    constructor() {
+        this._isInitialized = false;
+    }
+    _initialize(initValue) {
+        if (initValue instanceof StreamBuffer_1.StreamBuffer) {
+            this._unmarshal(initValue);
+        }
+        else if (utils.isPlainObject(initValue)) {
+            for (const [key, value] of Object.entries(initValue)) {
+                if (reservedPropertyNames.has(key)) {
+                    throw new errors_1.StreamProtocolToolkitTypeError(`FORBIDDEN_KEY`);
+                }
+                if (this[key] !== undefined) {
+                    throw new errors_1.StreamProtocolToolkitTypeError(`FIELD_ALREADY_EXISTS`);
+                }
+                Object.defineProperty(this, key, {
+                    value,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+        }
+        else {
+            throw new errors_1.StreamProtocolToolkitTypeError('INVALID_PROTOCOL_INIT_VALUE_TYPE');
+        }
+        this._isInitialized = true;
+    }
+    _createBuffer(options) {
+        const buffer = new StreamBuffer_1.StreamBuffer(options);
+        return buffer.allocEnd(buffer.getWritableSize());
+    }
+    get _opcode() {
+        return this.constructor._opcode;
+    }
+    static get _opcode() {
+        throw new errors_1.StreamProtocolToolkitNotImplementedError('PROTOCOL_OPCODE_NOT_DEFINED');
+    }
+    ;
+}
+exports.Protocol = Protocol;

package/dist/Protocol/ProtocolInitValue.d.ts

@@ -0,0 +1,4 @@
+import type { Protocol } from './Protocol';
+import type { StreamBuffer } from '../StreamBuffer';
+import type { NonFunctionKeys } from 'utility-types';
+export type ProtocolInitValue<T extends Protocol> = StreamBuffer | Omit<Pick<T, NonFunctionKeys<T>>, '_opcode' | '_isInitialized'>;

package/dist/Protocol/ProtocolInitValue.js

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

package/dist/Protocol/ProtocolOptions.d.ts

@@ -0,0 +1 @@
+export type ProtocolOptions = void;

package/dist/Protocol/ProtocolOptions.js

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

package/dist/Protocol/index.d.ts

@@ -0,0 +1,3 @@
+export { Protocol } from './Protocol';
+export type { ProtocolOptions } from './ProtocolOptions';
+export type { ProtocolInitValue } from './ProtocolInitValue';

package/dist/Protocol/index.js

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

package/dist/ProtocolHandler/ProtocolHandler.d.ts

@@ -0,0 +1,6 @@
+import type { Protocol } from '../Protocol';
+import type { Readable, Writable } from 'stream';
+import type { HandleInputDTO, HandleOutputDTO } from './handle';
+export declare abstract class ProtocolHandler<PROT extends Protocol, ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> {
+    abstract handle(input: HandleInputDTO<PROT, ISTREAM, OSTREAM, AS, SCS>): Promise<HandleOutputDTO>;
+}

package/dist/ProtocolHandler/ProtocolHandler.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolHandler = void 0;
+class ProtocolHandler {
+}
+exports.ProtocolHandler = ProtocolHandler;

package/dist/ProtocolHandler/ProtocolHandlerOptions.d.ts

@@ -0,0 +1 @@
+export type ProtocolHandlerOptions = void;

package/dist/ProtocolHandler/ProtocolHandlerOptions.js

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

package/dist/ProtocolHandler/handle/HandleInputDTO.d.ts

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

package/dist/ProtocolHandler/handle/HandleInputDTO.js

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

package/dist/ProtocolHandler/handle/HandleOutputDTO.d.ts

@@ -0,0 +1,3 @@
+import type { Protocol } from '../../Protocol';
+import type { StreamBuffer } from '../../StreamBuffer';
+export type HandleOutputDTO = StreamBuffer | Protocol | void;

package/dist/ProtocolHandler/handle/HandleOutputDTO.js

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

package/dist/ProtocolHandler/handle/index.d.ts

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

package/dist/ProtocolHandler/handle/index.js

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

package/dist/ProtocolHandler/index.d.ts

@@ -0,0 +1,3 @@
+export * from './handle';
+export { ProtocolHandler } from './ProtocolHandler';
+export type { ProtocolHandlerOptions } from './ProtocolHandlerOptions';

package/dist/ProtocolHandler/index.js

@@ -0,0 +1,20 @@
+"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 });
+exports.ProtocolHandler = void 0;
+__exportStar(require("./handle"), exports);
+var ProtocolHandler_1 = require("./ProtocolHandler");
+Object.defineProperty(exports, "ProtocolHandler", { enumerable: true, get: function () { return ProtocolHandler_1.ProtocolHandler; } });

package/dist/RawPacket/RawPacket.d.ts

@@ -0,0 +1,5 @@
+import type { StreamBuffer } from '../StreamBuffer';
+import type { RawPacketHeader } from './RawPacketHeader';
+export type RawPacket = {
+    payload: StreamBuffer;
+} & RawPacketHeader;

package/dist/RawPacket/RawPacket.js

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

package/dist/RawPacket/RawPacketHeader.d.ts

@@ -0,0 +1,4 @@
+export type RawPacketHeader = {
+    opcode: number;
+    length: number;
+};

package/dist/RawPacket/RawPacketHeader.js

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

package/dist/RawPacket/index.d.ts

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

package/dist/RawPacket/index.js

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

package/dist/StreamBuffer/StreamBuffer.d.ts

@@ -0,0 +1,14 @@
+import { ExtendedBuffer } from 'extended-buffer';
+import type { StreamBufferOptions } from './StreamBufferOptions';
+export declare class StreamBuffer<SBO extends StreamBufferOptions = StreamBufferOptions> extends ExtendedBuffer<SBO> {
+    readonly packetStringLengthSize: number;
+    readonly packetStringEncoding: BufferEncoding;
+    constructor(options?: StreamBufferOptions);
+    protected createInstanceOptions(options?: StreamBufferOptions): StreamBufferOptions;
+    readPacketStringLength(): number;
+    writePacketStringLength(value: number, unshift?: boolean): this;
+    packetStringLengthIsReadable(): boolean;
+    readPacketString(encoding?: BufferEncoding): string;
+    writePacketString(string: string, unshift?: boolean, encoding?: BufferEncoding): this;
+    packetStringIsReadable(): boolean;
+}

package/dist/StreamBuffer/StreamBuffer.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamBuffer = void 0;
+const buffer_1 = require("buffer");
+const extended_buffer_1 = require("extended-buffer");
+const DEFAULT_PACKET_STRING_PAYLOAD_LENGTH_SIZE = 4;
+const DEFAULT_PACKET_STRING_ENCODING = 'utf8';
+class StreamBuffer extends extended_buffer_1.ExtendedBuffer {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.packetStringEncoding = (_a = options === null || options === void 0 ? void 0 : options.packetStringEncoding) !== null && _a !== void 0 ? _a : DEFAULT_PACKET_STRING_ENCODING;
+        this.packetStringLengthSize = (_b = options === null || options === void 0 ? void 0 : options.packetStringLengthSize) !== null && _b !== void 0 ? _b : DEFAULT_PACKET_STRING_PAYLOAD_LENGTH_SIZE;
+    }
+    createInstanceOptions(options) {
+        return Object.assign({
+            packetStringEncoding: this.packetStringEncoding,
+            packetStringLengthSize: this.packetStringLengthSize
+        }, super.createInstanceOptions(options));
+    }
+    readPacketStringLength() {
+        return this.readUIntBE(this.packetStringLengthSize);
+    }
+    writePacketStringLength(value, unshift) {
+        return this.writeUIntBE(value, this.packetStringLengthSize, unshift);
+    }
+    packetStringLengthIsReadable() {
+        return this.isReadable(this.packetStringLengthSize);
+    }
+    readPacketString(encoding) {
+        const savedPointer = this.getPointer();
+        try {
+            const stringLength = this.readPacketStringLength();
+            return this.readString(stringLength, encoding !== null && encoding !== void 0 ? encoding : this.packetStringEncoding);
+        }
+        catch (e) {
+            this.setPointer(savedPointer);
+            throw e;
+        }
+    }
+    writePacketString(string, unshift, encoding) {
+        const bytes = buffer_1.Buffer.from(string, encoding !== null && encoding !== void 0 ? encoding : this.packetStringEncoding);
+        const data = (new StreamBuffer({
+            capacity: bytes.length + this.packetStringLengthSize,
+            capacityStep: 0
+        })).writePacketStringLength(bytes.length).writeNativeBuffer(bytes);
+        return this.writeNativeBuffer(data.nativeBufferView, unshift);
+    }
+    packetStringIsReadable() {
+        const savedPointer = this.getPointer();
+        try {
+            return this.packetStringLengthIsReadable() && this.isReadable(this.readPacketStringLength());
+        }
+        finally {
+            this.setPointer(savedPointer);
+        }
+    }
+}
+exports.StreamBuffer = StreamBuffer;

package/dist/StreamBuffer/StreamBufferOptions.d.ts

@@ -0,0 +1,5 @@
+import type { ExtendedBufferOptions } from 'extended-buffer';
+export type StreamBufferOptions = {
+    packetStringLengthSize?: number;
+    packetStringEncoding?: BufferEncoding;
+} & ExtendedBufferOptions;

package/dist/StreamBuffer/StreamBufferOptions.js

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

package/dist/StreamBuffer/index.d.ts

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

package/dist/StreamBuffer/index.js

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

package/dist/StreamContext/StreamContext.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from 'events';
+import type { Application } from '../Application';
+import type { Readable, Transform, Writable } from 'stream';
+import type { StreamContextOptions } from './StreamContextOptions';
+import type { StreamProtocolProcessor } from '../StreamProtocolProcessor';
+export declare class StreamContext<ISTREAM extends Readable, OSTREAM extends Writable, AS extends object, SCS extends object> {
+    readonly input: ISTREAM;
+    readonly output?: OSTREAM;
+    readonly eventBus: EventEmitter;
+    readonly streamContextState: SCS;
+    readonly inputTransform?: Transform[];
+    readonly outputTransform?: Transform[];
+    readonly abortController: AbortController;
+    readonly application: Application<ISTREAM, OSTREAM, AS, SCS>;
+    readonly streamProtocolProcessor: StreamProtocolProcessor<ISTREAM, OSTREAM, AS, SCS>;
+    constructor(options: StreamContextOptions<ISTREAM, OSTREAM, AS, SCS>);
+}