node-opcua-packet-assembler 2.64.1 → 2.66.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,14 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (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("./packet_assembler"), exports);
+"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("./packet_assembler"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,qDAAmC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC"}

package/dist/packet_assembler.d.ts

@@ -1,33 +1,33 @@
-/// <reference types="node" />
-import { EventEmitter } from "events";
-/***
- * @class PacketAssembler
- * @constructor
- */
-export interface MessageHeader {
-    msgType: string;
-    isFinal: string;
-    length: number;
-}
-export interface PacketInfo {
-    length: number;
-    messageHeader: MessageHeader;
-    extra: string;
-}
-export declare type ReadMessageFuncType = (data: Buffer) => PacketInfo;
-export interface PacketAssemblerOptions {
-    readMessageFunc: ReadMessageFuncType;
-    minimumSizeInBytes: number;
-}
-export declare class PacketAssembler extends EventEmitter {
-    private readonly _stack;
-    private expectedLength;
-    private currentLength;
-    private readonly readMessageFunc;
-    private readonly minimumSizeInBytes;
-    private packetInfo?;
-    constructor(options: PacketAssemblerOptions);
-    feed(data: Buffer): void;
-    private _readPacketInfo;
-    private _buildData;
-}
+/// <reference types="node" />
+import { EventEmitter } from "events";
+/***
+ * @class PacketAssembler
+ * @constructor
+ */
+export interface MessageHeader {
+    msgType: string;
+    isFinal: string;
+    length: number;
+}
+export interface PacketInfo {
+    length: number;
+    messageHeader: MessageHeader;
+    extra: string;
+}
+export declare type ReadMessageFuncType = (data: Buffer) => PacketInfo;
+export interface PacketAssemblerOptions {
+    readMessageFunc: ReadMessageFuncType;
+    minimumSizeInBytes: number;
+}
+export declare class PacketAssembler extends EventEmitter {
+    private readonly _stack;
+    private expectedLength;
+    private currentLength;
+    private readonly readMessageFunc;
+    private readonly minimumSizeInBytes;
+    private packetInfo?;
+    constructor(options: PacketAssemblerOptions);
+    feed(data: Buffer): void;
+    private _readPacketInfo;
+    private _buildData;
+}

package/dist/packet_assembler.js

@@ -1,86 +1,86 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PacketAssembler = void 0;
-const events_1 = require("events");
-const node_opcua_assert_1 = require("node-opcua-assert");
-const doDebug = false;
-class PacketAssembler extends events_1.EventEmitter {
-    constructor(options) {
-        super();
-        this._stack = [];
-        this.expectedLength = 0;
-        this.currentLength = 0;
-        this.readMessageFunc = options.readMessageFunc;
-        this.minimumSizeInBytes = options.minimumSizeInBytes || 8;
-        (0, node_opcua_assert_1.assert)(typeof this.readMessageFunc === "function", "packet assembler requires a readMessageFunc");
-    }
-    feed(data) {
-        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;
-            (0, node_opcua_assert_1.assert)(this.currentLength === 0);
-            (0, node_opcua_assert_1.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);
-                (0, node_opcua_assert_1.assert)(this.packetInfo && this.packetInfo.length === packetInfo.length);
-                (0, node_opcua_assert_1.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);
-            }
-        }
-    }
-    _readPacketInfo(data) {
-        return this.readMessageFunc(data);
-    }
-    _buildData(data) {
-        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;
-    }
-}
-exports.PacketAssembler = PacketAssembler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacketAssembler = void 0;
+const events_1 = require("events");
+const node_opcua_assert_1 = require("node-opcua-assert");
+const doDebug = false;
+class PacketAssembler extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this._stack = [];
+        this.expectedLength = 0;
+        this.currentLength = 0;
+        this.readMessageFunc = options.readMessageFunc;
+        this.minimumSizeInBytes = options.minimumSizeInBytes || 8;
+        (0, node_opcua_assert_1.assert)(typeof this.readMessageFunc === "function", "packet assembler requires a readMessageFunc");
+    }
+    feed(data) {
+        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;
+            (0, node_opcua_assert_1.assert)(this.currentLength === 0);
+            (0, node_opcua_assert_1.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);
+                (0, node_opcua_assert_1.assert)(this.packetInfo && this.packetInfo.length === packetInfo.length);
+                (0, node_opcua_assert_1.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);
+            }
+        }
+    }
+    _readPacketInfo(data) {
+        return this.readMessageFunc(data);
+    }
+    _buildData(data) {
+        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;
+    }
+}
+exports.PacketAssembler = PacketAssembler;
 //# sourceMappingURL=packet_assembler.js.map

package/package.json

@@ -1,18 +1,18 @@
 {
     "name": "node-opcua-packet-assembler",
-    "version": "2.64.1",
+    "version": "2.66.0",
     "description": "pure nodejs OPCUA SDK - module -packet-assembler",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "scripts": {
         "build": "tsc -b",
-        "clean": "node -e \"require('rimraf').sync('dist');\"",
+        "clean": "npx rimraf dist *.tsbuildinfo",
         "test": "mocha"
     },
     "author": "Etienne Rossignon",
     "license": "MIT",
     "dependencies": {
-        "node-opcua-assert": "2.64.1"
+        "node-opcua-assert": "2.66.0"
     },
     "devDependencies": {
         "should": "^13.2.3"
@@ -30,5 +30,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "b65b8738603cd475d7d99a2b20b0ae9d32b4110c"
+    "gitHead": "97f47e2e242a1fd737495fd64cb65e8fb7a9964b"
 }