split-frames 2.4.5 → 2.5.1

package/lib/cjs/SplitFrames.js

@@ -0,0 +1,385 @@
+"use strict";
+// deps
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// natives
+const node_stream_1 = require("node:stream");
+// locals
+const initData_1 = __importDefault(require("./checkers/initData"));
+// module
+class SplitFrames extends node_stream_1.Transform {
+    // constructor
+    constructor(options) {
+        super();
+        this._frame = Buffer.from([]);
+        this._digesting = false;
+        this._timeoutDigest = null;
+        // from params
+        const validatedOptions = (0, initData_1.default)(options);
+        this._startWith = validatedOptions.startWith;
+        this._startTimeout = validatedOptions.startTimeout;
+        this._endWith = validatedOptions.endWith;
+        this._escapeWith = validatedOptions.escapeWith;
+        this._escaped = validatedOptions.escaped;
+        this._specifics = validatedOptions.specifics;
+        this._controlBits = validatedOptions.controlBits;
+        // dynamic digester
+        this._digester = this._chooseDigester();
+    }
+    // methods
+    // public
+    _transform(chunk, enc, cb) {
+        if (chunk.length) {
+            this._frame = Buffer.concat([this._frame, chunk]);
+            if (!this._digesting) {
+                this._digest(enc);
+            }
+        }
+        return cb();
+    }
+    // protected
+    _chooseDigester() {
+        let digester = undefined;
+        if (undefined === this._startWith && undefined === this._endWith) {
+            digester = this._digestNoStartNoEnd;
+        }
+        else if (undefined !== this._startWith && undefined === this._endWith) {
+            digester = this._digestStartOnly;
+        }
+        else if (undefined === this._startWith && undefined !== this._endWith) {
+            digester = this._digestEndOnly;
+        }
+        else {
+            digester = this._digestStartAndEnd;
+        }
+        return digester;
+    }
+    _digest(enc) {
+        if (!this._frame.length) {
+            this._digesting = false;
+        }
+        else {
+            this._digesting = true;
+            try {
+                this._digester(enc);
+            }
+            catch (e) {
+                this.emit("error", e);
+            }
+        }
+    }
+    // private
+    // digesters
+    _digestNoStartNoEnd() {
+        const KEYS = Object.keys(this._specifics);
+        if (KEYS.length) {
+            KEYS.forEach((key) => {
+                const size = "object" === typeof this._specifics[key] && this._specifics[key] instanceof Buffer ? this._specifics[key].length : 1;
+                for (let foundAt = this._searchTags(this._specifics[key]); -1 < foundAt; foundAt = this._searchTags(this._specifics[key])) {
+                    this.emit(key);
+                    this._frame = Buffer.from(Buffer.concat([
+                        this._frame.slice(0, foundAt),
+                        this._frame.slice(foundAt + size, this._frame.length)
+                    ]));
+                }
+            });
+        }
+        this.push(Buffer.from(this._frame));
+        this._frame = Buffer.from([]);
+        this._digesting = false;
+    }
+    _digestStartOnly(enc) {
+        if (this._timeoutDigest) {
+            clearTimeout(this._timeoutDigest);
+            this._timeoutDigest = null;
+        }
+        const firstStart = this._searchFirstStart();
+        // no start tag detected
+        if (!firstStart) {
+            this._digesting = false;
+        }
+        // first start tag detected
+        else {
+            const nextStartAt = this._searchTags(this._startWith, firstStart.end);
+            // second start tag not detected
+            if (-1 >= nextStartAt) {
+                // remove useless bits
+                this._frame = 0 < firstStart.start ? Buffer.from(this._frame.slice(firstStart.start, this._frame.length)) : this._frame;
+                this._digesting = false;
+                this._timeoutDigest = setTimeout(() => {
+                    clearTimeout(this._timeoutDigest);
+                    this._timeoutDigest = null;
+                    this.push(Buffer.from(this._frame.slice(firstStart.start, this._frame.length)));
+                    this._frame = Buffer.from([]);
+                    this._digesting = false;
+                }, this._startTimeout);
+            }
+            // second start tag detected
+            else {
+                // extract first frame
+                this.push(Buffer.from(this._frame.slice(firstStart.start, nextStartAt)));
+                // remove extracted frame from main one
+                this._frame = Buffer.from(this._frame.slice(nextStartAt, this._frame.length));
+                // second full frame detected (force minimal data length)
+                if (-1 < this._searchTags(this._startWith, 1)) {
+                    this._digest(enc);
+                }
+                else {
+                    this._digesting = false;
+                }
+            }
+        }
+    }
+    _digestEndOnly(enc) {
+        this._extractSpecifics();
+        const firstEnd = this._searchFirstEnd(0);
+        // no end tag detected
+        if (!firstEnd) {
+            this._digesting = false;
+        }
+        // first end tag detected
+        else {
+            // extract first frame
+            this.push(Buffer.from(this._frame.slice(0, firstEnd.end)));
+            // remove extracted frame from main one
+            this._frame = Buffer.from(this._frame.slice(firstEnd.end, this._frame.length));
+            // second full frame detected
+            if (-1 < this._searchTags(this._endWith)) {
+                this._digest(enc);
+            }
+            else {
+                this._digesting = false;
+            }
+        }
+    }
+    _extractSpecifics() {
+        let found = false;
+        Object.keys(this._specifics).forEach((key) => {
+            if (0 === this._frame.indexOf(this._specifics[key])) {
+                found = true;
+                const size = "object" === typeof this._specifics[key] && this._specifics[key] instanceof Buffer
+                    ? this._specifics[key].length
+                    : 1;
+                this.emit(key);
+                this._frame = Buffer.from(this._frame.slice(size, this._frame.length));
+            }
+        });
+        if (found) {
+            this._extractSpecifics();
+        }
+    }
+    _digestStartAndEnd(enc) {
+        const KEYS = Object.keys(this._specifics);
+        if (KEYS.length) {
+            KEYS.forEach((key) => {
+                const firstStart = this._searchFirstStart();
+                const size = "object" === typeof this._specifics[key] && this._specifics[key] instanceof Buffer ? this._specifics[key].length : 1;
+                for (let foundAt = this._searchTags(this._specifics[key]), i = 0; -1 < foundAt && (!firstStart || foundAt < firstStart.start - i); foundAt = this._searchTags(this._specifics[key]), i += size) {
+                    this.emit(key);
+                    this._frame = Buffer.from(Buffer.concat([
+                        this._frame.slice(0, foundAt),
+                        this._frame.slice(foundAt + size, this._frame.length)
+                    ]));
+                }
+            });
+        }
+        const firstStart = this._searchFirstStart();
+        // no start tag detected
+        if (!firstStart) {
+            this._digesting = false;
+        }
+        // start tag detected
+        else {
+            const firstEnd = this._searchFirstEnd(firstStart.end);
+            // end tag not detected
+            if (!firstEnd) {
+                // remove useless bits
+                this._frame = 0 < firstStart.start ? Buffer.from(this._frame.slice(firstStart.start, this._frame.length)) : this._frame;
+                this._digesting = false;
+            }
+            // end tag detected
+            else {
+                this.push(Buffer.from(this._frame.slice(firstStart.start, firstEnd.end)));
+                // remove extracted frame from main one
+                this._frame = Buffer.from(this._frame.slice(firstEnd.end, this._frame.length));
+                // search specifics
+                let foundSpecific = false;
+                for (let i = 0; i < KEYS.length && !foundSpecific; ++i) {
+                    if (-1 < this._searchTags(this._specifics[KEYS[i]])) {
+                        foundSpecific = true;
+                        break;
+                    }
+                }
+                // specific detected or second start detected (force minimal data length)
+                if (foundSpecific || -1 < this._searchTags(this._startWith, 1)) {
+                    this._digest(enc);
+                }
+                else {
+                    this._digesting = false;
+                }
+            }
+        }
+    }
+    // search tag
+    _searchFirstTag(tag, beginAt = 0) {
+        let startAt = -1;
+        let endAt = -1;
+        // number
+        if ("number" === typeof tag) {
+            const find = this._searchFirstNumberTag(tag, beginAt);
+            startAt = find.start;
+            endAt = find.end;
+        }
+        // Buffer | Array
+        else if ("object" === typeof tag) {
+            const find = this._searchFirstBufferOrArrayTag(tag, beginAt);
+            startAt = find.start;
+            endAt = find.end;
+        }
+        // not found
+        if (-1 >= startAt || -1 >= endAt) {
+            return undefined;
+        }
+        // escaped
+        else if (0 < startAt
+            && 1 === endAt - startAt // must be a number to be escaped
+            && this._escaped.includes(this._frame[startAt])
+            && this._frame[startAt - 1] === this._escapeWith) {
+            // escaper not escaped
+            if (!this._escaped.includes(this._escapeWith) || 1 >= startAt || this._frame[startAt - 2] !== this._escapeWith) {
+                return this._searchFirstTag(tag, endAt + 1);
+            }
+            else {
+                return {
+                    "start": startAt,
+                    "end": endAt
+                };
+            }
+        }
+        // not escaped
+        else {
+            return {
+                "start": startAt,
+                "end": endAt
+            };
+        }
+    }
+    _searchFirstNumberTag(tag, beginAt) {
+        const startAt = this._frame.indexOf(tag, beginAt);
+        return {
+            "start": startAt,
+            "end": startAt + 1
+        };
+    }
+    _searchFirstBufferOrArrayTag(tag, beginAt) {
+        let startAt = -1;
+        let endAt = -1;
+        // Buffer
+        if (tag instanceof Buffer) {
+            startAt = this._frame.indexOf(tag, beginAt);
+            if (-1 < startAt) {
+                endAt = startAt + tag.length;
+            }
+        }
+        // Array
+        else if (tag instanceof Array) {
+            for (let i = 0; i < tag.length; ++i) {
+                // number | Buffer
+                if ("number" === typeof tag[i]
+                    || ("object" === typeof tag[i] && tag[i] instanceof Buffer)) {
+                    const _startAt = this._frame.indexOf(tag[i], beginAt);
+                    if (-1 < _startAt && (-1 >= startAt || _startAt < startAt)) {
+                        startAt = _startAt;
+                        if (-1 < startAt) {
+                            endAt = startAt + ("number" === typeof tag[i] ? 1 : tag[i].length);
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            "start": startAt,
+            "end": endAt
+        };
+    }
+    _searchFirstStart() {
+        return this._searchFirstTag(this._startWith);
+    }
+    _searchFirstEnd(startEndAt) {
+        const firstTag = this._searchFirstTag(this._endWith, startEndAt);
+        if (firstTag) {
+            if ("end+1" === this._controlBits) {
+                firstTag.end += 1;
+            }
+            else if ("end+2" === this._controlBits) {
+                firstTag.end += 2;
+            }
+            // end tag detected but without valid control bits length
+            if (firstTag.end > this._frame.length) {
+                return undefined;
+            }
+        }
+        return firstTag;
+    }
+    _searchTags(tags, beginAt = 0) {
+        // number
+        if ("number" === typeof tags) {
+            return this._searchNumberTags(tags, beginAt);
+        }
+        // Buffer | Array
+        else if ("object" === typeof tags) {
+            return this._searchBufferOrArrayTags(tags, beginAt);
+        }
+        return -1;
+    }
+    _searchNumberTags(tags, beginAt) {
+        const foundAt = this._frame.indexOf(tags, beginAt);
+        // escaped
+        if (0 < foundAt
+            && this._escaped.includes(this._frame[foundAt])
+            && this._frame[foundAt - 1] === this._escapeWith) {
+            // escaper not escaped
+            if (!this._escaped.includes(this._escapeWith) || 1 >= foundAt || this._frame[foundAt - 2] !== this._escapeWith) {
+                return this._searchTags(tags, foundAt + 1);
+            }
+        }
+        return foundAt;
+    }
+    _searchBufferOrArrayTags(tags, beginAt) {
+        // Buffer
+        if (tags instanceof Buffer) {
+            return this._frame.indexOf(tags, beginAt);
+        }
+        // Array
+        else if (tags instanceof Array) {
+            let foundAt = -1;
+            let type = "undefined";
+            for (let i = 0; i < tags.length; ++i) {
+                // number | Buffer
+                if ("number" === typeof tags[i]
+                    || ("object" === typeof tags[i]
+                        && tags[i] instanceof Buffer)) {
+                    const _foundAt = this._frame.indexOf(tags[i], beginAt);
+                    if (-1 < _foundAt && (-1 >= foundAt || _foundAt < foundAt)) {
+                        foundAt = _foundAt;
+                        type = typeof tags[i];
+                    }
+                }
+            }
+            // escaped
+            if ("number" === type && 0 < foundAt
+                && this._escaped.includes(this._frame[foundAt])
+                && this._frame[foundAt - 1] === this._escapeWith) {
+                // escaper not escaped
+                if (!this._escaped.includes(this._escapeWith) || 1 >= foundAt || this._frame[foundAt - 2] !== this._escapeWith) {
+                    foundAt = this._searchTags(tags, foundAt + 1);
+                }
+            }
+            return foundAt;
+        }
+        return -1;
+    }
+}
+exports.default = SplitFrames;

package/lib/cjs/checkers/checkTagsValidity.d.ts

@@ -0,0 +1,2 @@
+import type { tTag } from "../SplitFrames.js";
+export default function checkTagsValidity(tags: tTag): boolean;

package/lib/cjs/checkers/checkTagsValidity.js

@@ -0,0 +1,20 @@
+"use strict";
+// types & interfaces
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkTagsValidity;
+// module
+function checkTagsValidity(tags) {
+    let result = true;
+    if ("number" !== typeof tags && "object" !== typeof tags) {
+        result = false;
+    }
+    else if ("object" === typeof tags && tags instanceof Array) {
+        for (let i = 0; i < tags.length; ++i) {
+            if ("number" !== typeof tags[i] && "object" !== typeof tags[i] && !(tags[i] instanceof Buffer)) {
+                result = false;
+                break;
+            }
+        }
+    }
+    return result;
+}

package/lib/cjs/checkers/initData.d.ts

@@ -0,0 +1,2 @@
+import type { iOptions, iConf } from "../SplitFrames.js";
+export default function initData(options?: iOptions): iConf;

package/lib/cjs/checkers/initData.js

@@ -0,0 +1,89 @@
+"use strict";
+// deps
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = initData;
+// locals
+const checkTagsValidity_1 = __importDefault(require("./checkTagsValidity"));
+// consts
+const ALLOWED_CONTROL_BITS_OPTIONS = [
+    "none",
+    "end+1",
+    "end+2"
+];
+// module
+function initData(options) {
+    const result = {
+        "startWith": undefined,
+        "startTimeout": 200,
+        "endWith": undefined,
+        "escapeWith": undefined,
+        "escaped": [],
+        "specifics": {},
+        "controlBits": "none"
+    };
+    if ("undefined" !== typeof options) {
+        if ("object" !== typeof options) {
+            throw new TypeError("parameter sended is not an object");
+        }
+        else if ("undefined" !== typeof options.startWith && !(0, checkTagsValidity_1.default)(options.startWith)) {
+            throw new TypeError("startWith parameter sended is not a number, Buffer, or an Array of numbers");
+        }
+        else if ("undefined" !== typeof options.startTimeout && "number" !== typeof options.startTimeout) {
+            throw new TypeError("startTimeout parameter sended is not a number");
+        }
+        else if ("undefined" !== typeof options.endWith && !(0, checkTagsValidity_1.default)(options.endWith)) {
+            throw new TypeError("endWith parameter sended is not a number, Buffer, or an Array of numbers");
+        }
+        else if ("undefined" !== typeof options.escapeWith && "number" !== typeof options.escapeWith) {
+            throw new TypeError("escapeWith parameter sended is not a number");
+        }
+        else if ("undefined" !== typeof options.specifics && "object" !== typeof options.specifics) {
+            throw new TypeError("escapeWith parameter sended is not an object");
+        }
+        else if ("undefined" !== typeof options.controlBits && "string" !== typeof options.controlBits) {
+            throw new TypeError("controlBits parameter sended is not a string");
+        }
+        else if ("undefined" !== typeof options.controlBits && !ALLOWED_CONTROL_BITS_OPTIONS.includes(options.controlBits)) {
+            throw new Error("controlBits option sended is not in [ \"" + ALLOWED_CONTROL_BITS_OPTIONS.join("\", \"") + "\" ]");
+        }
+        else {
+            result.startWith = "undefined" !== typeof options.startWith ? options.startWith : undefined;
+            result.endWith = "undefined" !== typeof options.endWith ? options.endWith : undefined;
+            if ("undefined" !== typeof options.startTimeout) {
+                result.startTimeout = options.startTimeout;
+            }
+            result.escapeWith = "undefined" !== typeof options.escapeWith ? options.escapeWith : undefined;
+            if ("undefined" !== typeof options.escaped) {
+                result.escaped = options.escaped;
+            }
+            for (let i = 0; i < result.escaped.length; ++i) {
+                if ("number" !== typeof result.escaped[i]) {
+                    throw new TypeError("escaped parameter n°" + i + " sended is not a number");
+                }
+            }
+            if ("object" === typeof options.specifics) {
+                const specifics = options.specifics;
+                Object.keys(specifics).forEach((key) => {
+                    if ("undefined" !== typeof specifics[key]) {
+                        if (!(0, checkTagsValidity_1.default)(specifics[key])) {
+                            throw new Error("\"" + specifics[key] + "\" specifics option"
+                                + " sended is not a number, or an Array of numbers");
+                        }
+                        else if (undefined !== specifics[key]
+                            && undefined !== result.startWith
+                            && undefined === result.endWith) {
+                            throw new Error("If you want to use \"" + specifics[key] + "\" specific option,"
+                                + " you have to use \"endWith\" option");
+                        }
+                    }
+                });
+            }
+            result.specifics = "undefined" !== typeof options.specifics ? options.specifics : {};
+            result.controlBits = "undefined" !== typeof options.controlBits ? options.controlBits : "none";
+        }
+    }
+    return result;
+}

package/lib/cjs/main.cjs

@@ -0,0 +1,8 @@
+"use strict";
+// deps
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+// locals
+const SplitFrames_1 = __importDefault(require("./SplitFrames"));
+module.exports = SplitFrames_1.default;

package/lib/cjs/main.d.cts

@@ -0,0 +1,2 @@
+import SplitFrames from "./SplitFrames";
+export = SplitFrames;