split-frames 2.4.4 → 2.5.0

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2019, Sébastien Vidal
+Copyright (c) 2023, Sébastien Vidal
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/lib/cjs/SplitFrames.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Transform } from "node:stream";
+export declare type tTagObject = {
+    [key: string]: tTag;
+};
+export declare type tControlBits = "none" | "end+1" | "end+2";
+export declare type tTag = number | Buffer | Array<number> | Array<Buffer>;
+export interface iSearchedBits {
+    "start": number;
+    "end": number;
+}
+export interface iOptions {
+    "startWith"?: tTag;
+    "startTimeout"?: number;
+    "endWith"?: tTag;
+    "escapeWith"?: tTag;
+    "escaped"?: Array<number>;
+    "specifics"?: tTagObject;
+    "controlBits"?: tControlBits;
+}
+export interface iConf extends iOptions {
+    "escaped": Array<number>;
+    "specifics": tTagObject;
+    "controlBits": tControlBits;
+}
+export default class SplitFrames extends Transform {
+    protected _frame: Buffer;
+    protected _digesting: boolean;
+    protected _timeoutDigest: NodeJS.Timeout | null;
+    protected _startWith: iConf["startWith"];
+    protected _startTimeout: iConf["startTimeout"];
+    protected _endWith: iConf["endWith"];
+    protected _escapeWith: iConf["escapeWith"];
+    protected _escaped: iConf["escaped"];
+    protected _specifics: iConf["specifics"];
+    protected _controlBits: iConf["controlBits"];
+    protected _digester: (enc?: BufferEncoding) => void;
+    constructor(options?: iOptions);
+    _transform(chunk: Buffer, enc: BufferEncoding, cb: (err?: Error | null, data?: any) => void): void;
+    protected _chooseDigester(): (enc?: BufferEncoding) => void;
+    protected _digest(enc?: BufferEncoding): void;
+    private _digestNoStartNoEnd;
+    private _digestStartOnly;
+    private _digestEndOnly;
+    private _extractSpecifics;
+    private _digestStartAndEnd;
+    private _searchFirstTag;
+    private _searchFirstNumberTag;
+    private _searchFirstBufferOrArrayTag;
+    private _searchFirstStart;
+    private _searchFirstEnd;
+    private _searchTags;
+    private _searchNumberTags;
+    private _searchBufferOrArrayTags;
+}

package/lib/cjs/SplitFrames.js

@@ -0,0 +1,384 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// 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._frame = Buffer.from([]);
+            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();
+        // 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._frame = Buffer.from([]);
+            this._digesting = false;
+        }
+        // start tag detected
+        else {
+            const firstEnd = this._searchFirstEnd();
+            // 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 &&
+            // must be a number to be escaped
+            1 === endAt - startAt &&
+            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);
+            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;
+                        endAt = startAt + ("number" === typeof tag[i] ? 1 : tag[i].length);
+                    }
+                }
+            }
+        }
+        return {
+            "start": startAt,
+            "end": endAt
+        };
+    }
+    _searchFirstStart() {
+        return this._searchFirstTag(this._startWith);
+    }
+    _searchFirstEnd() {
+        const firstTag = this._searchFirstTag(this._endWith);
+        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,3 @@
+import { tTag } from "../SplitFrames.js";
+declare const _default: (tags: tTag) => boolean;
+export default _default;

package/lib/cjs/checkers/checkTagsValidity.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+exports.default = (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 { iOptions, iConf } from "../SplitFrames.js";
+export default function initData(options?: iOptions): iConf;

package/lib/cjs/checkers/initData.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// deps
+// 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;
+}
+exports.default = initData;
+;

package/lib/cjs/main.cjs

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+// deps
+// 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;

package/package.json

@@ -1,26 +1,62 @@
 {
+
   "name": "split-frames",
-  "version": "2.4.4",
+  "version": "2.5.0",
   "description": "Split Buffer frames from streams",
-  "main": "lib/main.js",
-  "typings": "lib/index.d.ts",
+
+  "type": "commonjs",
+  "typings": "./lib/cjs/main.d.cts",
+  "main": "./lib/cjs/main.cjs",
+
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./lib/cjs/main.d.cts",
+        "default": "./lib/cjs/main.cjs"
+      }
+    }
+  },
+
   "scripts": {
-    "lint": "npx eslint ./lib/**/*.js ./test/**/*.js",
+
+    "build": "node ./removeOldBuild.js && npx tsc --project \"./tsconfig.json\"",
+
+    "lint": "npx eslint ./test/**/*.js",
+    "check-requires": "npx used-deps-analyzer \"./package.json\" \"./src\" --no-dev --overkill \"fs-extra\" \"node-promfs\"",
     "check-updates": "npx check-version-modules",
-    "unit-tests": "npx nyc --reporter=html --reporter=text mocha",
-    "tests": "npm run-script lint && npm run-script check-updates && npm run-script unit-tests",
+    "unit-tests": "npm run build && npx nyc --reporter=html --reporter=text mocha",
+
+    "tests": "npm run-script lint && npm run check-requires && npm run-script check-updates && npm run-script unit-tests",
     "ci": "npm run-script tests && npx nyc report --reporter=text-lcov | coveralls"
+
+  },
+
+  "files": [
+    "/lib"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "20.5.7",
+    "check-version-modules": "1.5.0",
+    "coveralls": "3.1.1",
+    "eslint": "8.48.0",
+    "husky": "8.0.3",
+    "mocha": "10.2.0",
+    "nyc": "15.1.0",
+    "used-deps-analyzer": "0.1.6"
   },
+  "optionalDependencies": {},
+
   "husky": {
     "hooks": {
       "pre-commit": "npm run-script lint",
       "pre-push": "npm run-script tests"
     }
   },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/Psychopoulet/split-frames"
-  },
   "keywords": [
     "frame",
     "Buffer",
@@ -47,21 +83,14 @@
   ],
   "author": "Sébastien VIDAL",
   "license": "ISC",
+
+  "homepage": "https://github.com/Psychopoulet/split-frames#readme",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Psychopoulet/split-frames"
+  },
   "bugs": {
     "url": "https://github.com/Psychopoulet/split-frames/issues"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@types/node": "18.11.9",
-    "check-version-modules": "1.3.5",
-    "coveralls": "3.1.1",
-    "eslint": "8.27.0",
-    "husky": "8.0.2",
-    "mocha": "10.1.0",
-    "nyc": "15.1.0"
-  },
-  "homepage": "https://github.com/Psychopoulet/split-frames#readme",
-  "engines": {
-    "node": ">=16.0.0"
   }
+
 }

package/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci