node-opcua-packet-assembler 2.55.0 → 2.62.7

package/LICENSE

@@ -1,20 +1,20 @@
-The MIT License (MIT)
-
-Copyright (c) 2014-2021 Etienne Rossignon
-
-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.
+The MIT License (MIT)
+
+Copyright (c) 2014-2021 Etienne Rossignon
+
+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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-packet-assembler",
-    "version": "2.55.0",
+    "version": "2.62.7",
     "description": "pure nodejs OPCUA SDK - module -packet-assembler",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -30,5 +30,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "28fdbfe1c5306fd0e69758ccacfa2c6d1722115c"
+    "gitHead": "90bb9139261a0edbb531081afcc6904c74e9ee52"
 }

package/source/index.ts

@@ -1 +1 @@
-export * from "./packet_assembler";
+export * from "./packet_assembler";

package/source/packet_assembler.ts

@@ -1,124 +1,124 @@
-import { EventEmitter } from "events";
-import { assert } from "node-opcua-assert";
-
-const doDebug = false;
-
-/***
- * @class PacketAssembler
- * @constructor
- */
-
-export interface MessageHeader {
-    msgType: string;
-    isFinal: string;
-    length: number;
-}
-
-export interface PacketInfo {
-    length: number;
-    messageHeader: MessageHeader;
-    extra: string;
-}
-
-export type ReadMessageFuncType = (data: Buffer) => PacketInfo;
-
-export interface PacketAssemblerOptions {
-    readMessageFunc: ReadMessageFuncType;
-
-    // the minimum number of bytes that need to be received before the readMessageFunc can be called
-    minimumSizeInBytes: number;
-}
-
-export class PacketAssembler extends EventEmitter {
-    private readonly _stack: Buffer[];
-    private expectedLength: number;
-    private currentLength: number;
-    private readonly readMessageFunc: ReadMessageFuncType;
-    private readonly minimumSizeInBytes: number;
-    private packetInfo?: PacketInfo;
-
-    constructor(options: PacketAssemblerOptions) {
-        super();
-        this._stack = [];
-        this.expectedLength = 0;
-        this.currentLength = 0;
-        this.readMessageFunc = options.readMessageFunc;
-        this.minimumSizeInBytes = options.minimumSizeInBytes || 8;
-        assert(typeof this.readMessageFunc === "function", "packet assembler requires a readMessageFunc");
-    }
-
-    public feed(data: Buffer) {
-        let messageChunk;
-
-        if (this.expectedLength === 0 && this.currentLength + data.length >= this.minimumSizeInBytes) {
-            // we are at a start of a block and there is enough data provided to read the length  of the block
-            // let's build the whole data block with previous blocks already read.
-            if (this._stack.length > 0) {
-                data = this._buildData(data);
-                this.currentLength = 0;
-            }
-
-            // we can extract the expected length here
-            this.packetInfo = this._readPacketInfo(data);
-            this.expectedLength = this.packetInfo.length;
-            assert(this.currentLength === 0);
-            assert(this.expectedLength > 0);
-
-            // we can now emit an event to signal the start of a new packet
-            this.emit("newMessage", this.packetInfo, data);
-        }
-
-        if (this.expectedLength === 0 || this.currentLength + data.length < this.expectedLength) {
-            this._stack.push(data);
-            this.currentLength += data.length;
-            // expecting more data to complete current message chunk
-        } else if (this.currentLength + data.length === this.expectedLength) {
-            this.currentLength += data.length;
-
-            messageChunk = this._buildData(data);
-
-            // istanbul ignore next
-            if (doDebug) {
-                const packetInfo = this._readPacketInfo(messageChunk);
-                assert(this.packetInfo && this.packetInfo.length === packetInfo.length);
-                assert(messageChunk.length === packetInfo.length);
-            }
-            // reset
-            this.currentLength = 0;
-            this.expectedLength = 0;
-
-            this.emit("message", messageChunk);
-        } else {
-            // there is more data in this chunk than expected...
-            // the chunk need to be split
-            const size1 = this.expectedLength - this.currentLength;
-            if (size1 > 0) {
-                const chunk1 = data.slice(0, size1);
-                this.feed(chunk1);
-            }
-            const chunk2 = data.slice(size1);
-            if (chunk2.length > 0) {
-                this.feed(chunk2);
-            }
-        }
-    }
-
-    private _readPacketInfo(data: Buffer) {
-        return this.readMessageFunc(data);
-    }
-
-    private _buildData(data: Buffer) {
-        if (data && this._stack.length === 0) {
-            return data;
-        }
-        if (!data && this._stack.length === 1) {
-            data = this._stack[0];
-            this._stack.length = 0; // empty stack array
-            return data;
-        }
-        this._stack.push(data);
-        data = Buffer.concat(this._stack);
-        this._stack.length = 0;
-        return data;
-    }
-}
+import { EventEmitter } from "events";
+import { assert } from "node-opcua-assert";
+
+const doDebug = false;
+
+/***
+ * @class PacketAssembler
+ * @constructor
+ */
+
+export interface MessageHeader {
+    msgType: string;
+    isFinal: string;
+    length: number;
+}
+
+export interface PacketInfo {
+    length: number;
+    messageHeader: MessageHeader;
+    extra: string;
+}
+
+export type ReadMessageFuncType = (data: Buffer) => PacketInfo;
+
+export interface PacketAssemblerOptions {
+    readMessageFunc: ReadMessageFuncType;
+
+    // the minimum number of bytes that need to be received before the readMessageFunc can be called
+    minimumSizeInBytes: number;
+}
+
+export class PacketAssembler extends EventEmitter {
+    private readonly _stack: Buffer[];
+    private expectedLength: number;
+    private currentLength: number;
+    private readonly readMessageFunc: ReadMessageFuncType;
+    private readonly minimumSizeInBytes: number;
+    private packetInfo?: PacketInfo;
+
+    constructor(options: PacketAssemblerOptions) {
+        super();
+        this._stack = [];
+        this.expectedLength = 0;
+        this.currentLength = 0;
+        this.readMessageFunc = options.readMessageFunc;
+        this.minimumSizeInBytes = options.minimumSizeInBytes || 8;
+        assert(typeof this.readMessageFunc === "function", "packet assembler requires a readMessageFunc");
+    }
+
+    public feed(data: Buffer) {
+        let messageChunk;
+
+        if (this.expectedLength === 0 && this.currentLength + data.length >= this.minimumSizeInBytes) {
+            // we are at a start of a block and there is enough data provided to read the length  of the block
+            // let's build the whole data block with previous blocks already read.
+            if (this._stack.length > 0) {
+                data = this._buildData(data);
+                this.currentLength = 0;
+            }
+
+            // we can extract the expected length here
+            this.packetInfo = this._readPacketInfo(data);
+            this.expectedLength = this.packetInfo.length;
+            assert(this.currentLength === 0);
+            assert(this.expectedLength > 0);
+
+            // we can now emit an event to signal the start of a new packet
+            this.emit("newMessage", this.packetInfo, data);
+        }
+
+        if (this.expectedLength === 0 || this.currentLength + data.length < this.expectedLength) {
+            this._stack.push(data);
+            this.currentLength += data.length;
+            // expecting more data to complete current message chunk
+        } else if (this.currentLength + data.length === this.expectedLength) {
+            this.currentLength += data.length;
+
+            messageChunk = this._buildData(data);
+
+            // istanbul ignore next
+            if (doDebug) {
+                const packetInfo = this._readPacketInfo(messageChunk);
+                assert(this.packetInfo && this.packetInfo.length === packetInfo.length);
+                assert(messageChunk.length === packetInfo.length);
+            }
+            // reset
+            this.currentLength = 0;
+            this.expectedLength = 0;
+
+            this.emit("message", messageChunk);
+        } else {
+            // there is more data in this chunk than expected...
+            // the chunk need to be split
+            const size1 = this.expectedLength - this.currentLength;
+            if (size1 > 0) {
+                const chunk1 = data.slice(0, size1);
+                this.feed(chunk1);
+            }
+            const chunk2 = data.slice(size1);
+            if (chunk2.length > 0) {
+                this.feed(chunk2);
+            }
+        }
+    }
+
+    private _readPacketInfo(data: Buffer) {
+        return this.readMessageFunc(data);
+    }
+
+    private _buildData(data: Buffer) {
+        if (data && this._stack.length === 0) {
+            return data;
+        }
+        if (!data && this._stack.length === 1) {
+            data = this._stack[0];
+            this._stack.length = 0; // empty stack array
+            return data;
+        }
+        this._stack.push(data);
+        data = Buffer.concat(this._stack);
+        this._stack.length = 0;
+        return data;
+    }
+}