node-red-contrib-ntrip 0.2.10 → 0.2.11

package/ntrip/nodes/ntrip-client-node.js

@@ -8,13 +8,15 @@ module.exports = function (RED) {
     const HandshakePrefixBytes = 64;
 
     function formatBps(bps) {
+        let text;
         if (bps < 1000) {
-            return Math.round(bps) + ' bps';
-        }
-        if (bps < 1000000) {
-            return (bps / 1000).toFixed(1) + ' kbps';
+            text = Math.round(bps) + ' bps';
+        } else if (bps < 1000000) {
+            text = (bps / 1000).toFixed(1) + ' kbps';
+        } else {
+            text = (bps / 1000000).toFixed(2) + ' Mbps';
         }
-        return (bps / 1000000).toFixed(2) + ' Mbps';
+        return text;
     }
 
     function NtripClientNode(config) {
@@ -33,168 +35,171 @@ module.exports = function (RED) {
         let authmode = config.authmode || 'legacy';
         let interval = parseInt(config.interval, 10) || 1000;
 
+        let client = null;
+
         if (host === '') {
             node.status({ fill: 'red', shape: 'ring', text: 'Host not configured' });
-            return;
-        }
-
-        let options = {
-            host: host,
-            port: port,
-            mountpoint: mountpoint,
-            username: node.credentials.username,
-            password: node.credentials.password,
-            interval: interval,
-        };
-
-        // Depending on the caster the clients need to provide the location via GGA sentence.
-        let x = parseFloat(config.xcoordinate);
-        let y = parseFloat(config.ycoordinate);
-        let z = parseFloat(config.zcoordinate);
-
-        if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z) && !(x === 0 && y === 0 && z === 0)) {
-            options.xyz = [x, y, z];
-        }
-
-        let client;
-        if (mode === 'download') {
-            client = NtripClient.createDownloader(options);
-        } else if (mode === 'upload') {
-            options.authmode = authmode;
-            try {
-                client = NtripClient.createUploader(options);
-            } catch (error) {
-                node.status({ fill: 'red', shape: 'ring', text: String(error.message || error) });
-                node.error('Failed to create uploader: ' + (error.message || error));
-                return;
-            }
         } else {
-            node.status({ fill: 'red', shape: 'ring', text: 'Unsupported mode: ' + mode });
-            node.error('Mode not supported: ' + mode);
-            return;
-        }
-
-        // Track handshake state so we only intercept control replies during the handshake,
-        // not on every subsequent data packet. Reset on socket close so reconnects work.
-        let connected = false;
-
-        function updateStatus() {
-            node.status({
-                fill: 'green',
-                shape: 'ring',
-                text: formatBps(node.currentBps) + ' Rx ' + node.messagesReceived + ' Tx ' + node.messagesSent,
-            });
-        }
-
-        // Sample inbound byte counter once per second to compute the bps shown in the
-        // status badge. Counter is reset each tick — currentBps reflects the most
-        // recent 1-second window.
-        const bpsSampler = setInterval(() => {
-            node.currentBps = node.bytesAccum * 8;
-            node.bytesAccum = 0;
-            updateStatus();
-        }, 1000);
-
-        client.on('data', (data) => {
-            node.bytesAccum += data.length;
-            if (!connected) {
-                let prefix = data.toString('utf8', 0, Math.min(data.length, HandshakePrefixBytes));
-                if (prefix.startsWith(NtripServerOkReply)) {
-                    connected = true;
-                    node.status({ fill: 'green', shape: 'ring', text: 'NTRIP server connected.' });
-                    // Forward any RTCM bytes that arrived in the same TCP segment as the handshake reply.
-                    let headerEnd = data.indexOf('\r\n\r\n');
-                    if (headerEnd !== -1 && headerEnd + 4 < data.length) {
-                        node.messagesReceived++;
-                        node.send({ payload: data.slice(headerEnd + 4) });
-                        updateStatus();
-                    }
-                    return;
-                }
-                if (prefix.startsWith(NtripServerNotOkReply)) {
-                    node.status({ fill: 'red', shape: 'ring', text: 'NTRIP server rejected connection.' });
-                    node.error('Server rejected connect: ' + prefix);
-                    return;
-                }
-                if (prefix.startsWith(NtripServerMissingMountpoint)) {
-                    node.status({ fill: 'red', shape: 'ring', text: 'No mountpoint ' + mountpoint });
-                    node.error('No mountpoint: ' + prefix);
-                    return;
-                }
-                // Unexpected: data arrived before any recognised handshake reply.
-                // Treat as connected so we don't drop further frames.
-                connected = true;
+            let options = {
+                host: host,
+                port: port,
+                mountpoint: mountpoint,
+                username: node.credentials.username,
+                password: node.credentials.password,
+                interval: interval,
+            };
+
+            // Depending on the caster the clients need to provide the location via GGA sentence.
+            let x = parseFloat(config.xcoordinate);
+            let y = parseFloat(config.ycoordinate);
+            let z = parseFloat(config.zcoordinate);
+
+            if (Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z) && !(x === 0 && y === 0 && z === 0)) {
+                options.xyz = [x, y, z];
             }
 
-            node.messagesReceived++;
-            node.send({ payload: data });
-            updateStatus();
-        });
-
-        client.on('close', () => {
-            connected = false;
-            node.log('Closed NTRIP connection.');
-        });
-
-        client.on('error', (error) => {
-            connected = false;
-            if (typeof AggregateError !== 'undefined' && error instanceof AggregateError) {
-                error.errors.forEach((e, i) => {
-                    node.log('Error ' + (i + 1) + ': ' + e.message);
-                    node.error('Error: ' + e.message);
-                });
+            if (mode === 'download') {
+                client = NtripClient.createDownloader(options);
+            } else if (mode === 'upload') {
+                options.authmode = authmode;
+                try {
+                    client = NtripClient.createUploader(options);
+                } catch (error) {
+                    node.status({ fill: 'red', shape: 'ring', text: String(error.message || error) });
+                    node.error('Failed to create uploader: ' + (error.message || error));
+                }
             } else {
-                let text = error && error.message ? error.message : String(error);
-                node.log(text);
-                node.error('Error: ' + text);
+                node.status({ fill: 'red', shape: 'ring', text: 'Unsupported mode: ' + mode });
+                node.error('Mode not supported: ' + mode);
             }
-        });
-
-        try {
-            client.run();
-        } catch (error) {
-            node.status({ fill: 'red', shape: 'ring', text: String(error.message || error) });
-            node.error('Failed to start client: ' + (error.message || error));
-            return;
         }
 
-        node.status({ fill: 'yellow', shape: 'ring', text: 'connecting...' });
+        if (client !== null) {
+            // Track handshake state so we only intercept control replies during the handshake,
+            // not on every subsequent data packet. Reset on socket close so reconnects work.
+            let connected = false;
 
-        this.on('input', function (msg) {
-            let payload = msg.payload;
-            if (payload === undefined || payload === null) {
-                return;
+            function updateStatus() {
+                node.status({
+                    fill: 'green',
+                    shape: 'ring',
+                    text: formatBps(node.currentBps) + ' Rx ' + node.messagesReceived + ' Tx ' + node.messagesSent,
+                });
             }
 
-            try {
-                if (Array.isArray(payload)) {
-                    client.setXYZ(payload);
-                } else {
-                    client.write(payload);
-                    node.messagesSent++;
-                    if (node.passthrough) {
-                        node.send(msg);
+            // Sample inbound byte counter once per second to compute the bps shown in the
+            // status badge. Counter is reset each tick — currentBps reflects the most
+            // recent 1-second window.
+            const bpsSampler = setInterval(() => {
+                node.currentBps = node.bytesAccum * 8;
+                node.bytesAccum = 0;
+                updateStatus();
+            }, 1000);
+
+            client.on('data', (data) => {
+                node.bytesAccum += data.length;
+                let handled = false;
+                if (!connected) {
+                    let prefix = data.toString('utf8', 0, Math.min(data.length, HandshakePrefixBytes));
+                    if (prefix.startsWith(NtripServerOkReply)) {
+                        connected = true;
+                        node.status({ fill: 'green', shape: 'ring', text: 'NTRIP server connected.' });
+                        // Forward any RTCM bytes that arrived in the same TCP segment as the handshake reply.
+                        let headerEnd = data.indexOf('\r\n\r\n');
+                        if (headerEnd !== -1 && headerEnd + 4 < data.length) {
+                            node.messagesReceived++;
+                            node.send({ payload: data.slice(headerEnd + 4) });
+                            updateStatus();
+                        }
+                        handled = true;
+                    } else if (prefix.startsWith(NtripServerNotOkReply)) {
+                        node.status({ fill: 'red', shape: 'ring', text: 'NTRIP server rejected connection.' });
+                        node.error('Server rejected connect: ' + prefix);
+                        handled = true;
+                    } else if (prefix.startsWith(NtripServerMissingMountpoint)) {
+                        node.status({ fill: 'red', shape: 'ring', text: 'No mountpoint ' + mountpoint });
+                        node.error('No mountpoint: ' + prefix);
+                        handled = true;
+                    } else {
+                        // Unexpected: data arrived before any recognised handshake reply.
+                        // Treat as connected so we don't drop further frames.
+                        connected = true;
                     }
+                }
+
+                if (!handled) {
+                    node.messagesReceived++;
+                    node.send({ payload: data });
                     updateStatus();
                 }
+            });
+
+            client.on('close', () => {
+                connected = false;
+                node.log('Closed NTRIP connection.');
+            });
+
+            client.on('error', (error) => {
+                connected = false;
+                if (typeof AggregateError !== 'undefined' && error instanceof AggregateError) {
+                    error.errors.forEach((e, i) => {
+                        node.log('Error ' + (i + 1) + ': ' + e.message);
+                        node.error('Error: ' + e.message);
+                    });
+                } else {
+                    let text = error && error.message ? error.message : String(error);
+                    node.log(text);
+                    node.error('Error: ' + text);
+                }
+            });
+
+            let running = true;
+            try {
+                client.run();
             } catch (error) {
-                let text = error && error.message ? error.message : String(error);
-                node.status({ fill: 'red', shape: 'ring', text: text });
-                node.error('Failed to write data: ' + text, msg);
+                running = false;
+                node.status({ fill: 'red', shape: 'ring', text: String(error.message || error) });
+                node.error('Failed to start client: ' + (error.message || error));
             }
-        });
 
-        this.on('close', function (done) {
-            clearInterval(bpsSampler);
-            try {
-                client.removeAllListeners();
-                client.close();
-            } catch {
-                // ignore — node is shutting down anyway
+            if (running) {
+                node.status({ fill: 'yellow', shape: 'ring', text: 'connecting...' });
+
+                this.on('input', function (msg) {
+                    let payload = msg.payload;
+                    if (payload !== undefined && payload !== null) {
+                        try {
+                            if (Array.isArray(payload)) {
+                                client.setXYZ(payload);
+                            } else {
+                                client.write(payload);
+                                node.messagesSent++;
+                                if (node.passthrough) {
+                                    node.send(msg);
+                                }
+                                updateStatus();
+                            }
+                        } catch (error) {
+                            let text = error && error.message ? error.message : String(error);
+                            node.status({ fill: 'red', shape: 'ring', text: text });
+                            node.error('Failed to write data: ' + text, msg);
+                        }
+                    }
+                });
+
+                this.on('close', function (done) {
+                    clearInterval(bpsSampler);
+                    try {
+                        client.removeAllListeners();
+                        client.close();
+                    } catch {
+                        // ignore — node is shutting down anyway
+                    }
+                    node.status({});
+                    done();
+                });
             }
-            node.status({});
-            done();
-        });
+        }
     }
 
     return NtripClientNode;

package/ntrip/nodes/rtcm-decoder-node.js

@@ -23,59 +23,62 @@ module.exports = function (RED) {
         }
 
         this.on('input', function (msg) {
-            if (msg.payload === undefined || msg.payload === null) {
-                return;
-            }
-
-            let chunk = Buffer.isBuffer(msg.payload) ? msg.payload : Buffer.from(msg.payload);
-            let buffer = node.pendingBuffer.length > 0 ? Buffer.concat([node.pendingBuffer, chunk]) : chunk;
+            if (msg.payload !== undefined && msg.payload !== null) {
+                let chunk = Buffer.isBuffer(msg.payload) ? msg.payload : Buffer.from(msg.payload);
+                let buffer = node.pendingBuffer.length > 0 ? Buffer.concat([node.pendingBuffer, chunk]) : chunk;
 
-            while (buffer.length > 0) {
-                let message;
-                let length;
-                try {
-                    [message, length] = RtcmTransport.decode(buffer);
-                } catch (ex) {
-                    // Likely a partial frame at the tail of this chunk — keep the bytes
-                    // for the next input event. If we've accumulated too much without a
-                    // successful decode, drop and emit an error.
-                    if (buffer.length > MaxPendingBytes) {
-                        let errMsg = {
-                            payload: {
-                                error: ex,
-                                input: buffer,
-                                inputString: buffer.toString(),
-                            },
-                        };
-                        node.send([null, errMsg]);
-                        node.invalidMessagesReceived++;
-                        buffer = Buffer.alloc(0);
+                let keepLooping = true;
+                while (keepLooping && buffer.length > 0) {
+                    let message;
+                    let length;
+                    let decoded = true;
+                    try {
+                        [message, length] = RtcmTransport.decode(buffer);
+                    } catch (ex) {
+                        decoded = false;
+                        // Likely a partial frame at the tail of this chunk — keep the bytes
+                        // for the next input event. If we've accumulated too much without a
+                        // successful decode, drop and emit an error.
+                        if (buffer.length > MaxPendingBytes) {
+                            let errMsg = {
+                                payload: {
+                                    error: ex,
+                                    input: buffer,
+                                    inputString: buffer.toString(),
+                                },
+                            };
+                            node.send([null, errMsg]);
+                            node.invalidMessagesReceived++;
+                            buffer = Buffer.alloc(0);
+                        }
+                        keepLooping = false;
                     }
-                    break;
-                }
 
-                if (!Number.isInteger(length) || length <= 0 || length > buffer.length) {
-                    // Defensive — guarantees forward progress even if the decoder ever
-                    // returns a non-positive length.
-                    break;
+                    if (decoded) {
+                        if (!Number.isInteger(length) || length <= 0 || length > buffer.length) {
+                            // Defensive — guarantees forward progress even if the decoder ever
+                            // returns a non-positive length.
+                            keepLooping = false;
+                        } else {
+                            let messageType = message.constructor.name.replace('RtcmMessage', '');
+                            let outMsg = {
+                                payload: {
+                                    rtcm: message.messageType,
+                                    messageType: messageType,
+                                    message: message,
+                                    input: buffer.slice(0, length),
+                                },
+                            };
+                            node.send([outMsg, null]);
+                            node.rtcmMessagesReceived++;
+                            buffer = buffer.slice(length);
+                        }
+                    }
                 }
 
-                let messageType = message.constructor.name.replace('RtcmMessage', '');
-                let outMsg = {
-                    payload: {
-                        rtcm: message.messageType,
-                        messageType: messageType,
-                        message: message,
-                        input: buffer.slice(0, length),
-                    },
-                };
-                node.send([outMsg, null]);
-                node.rtcmMessagesReceived++;
-                buffer = buffer.slice(length);
+                node.pendingBuffer = buffer;
+                updateStatus();
             }
-
-            node.pendingBuffer = buffer;
-            updateStatus();
         });
 
         this.on('close', function (done) {

package/ntrip/nodes/rtcm-encoder-node.js

@@ -31,7 +31,9 @@ module.exports = function (RED) {
                 message = payload;
             } else if (payload != null && payload.message instanceof RtcmMessage) {
                 message = payload.message;
-            } else {
+            }
+
+            if (message === undefined) {
                 node.send([
                     null,
                     {
@@ -43,40 +45,39 @@ module.exports = function (RED) {
                 ]);
                 node.invalidMessagesReceived++;
                 updateStatus(false);
-                return;
-            }
-
-            try {
-                let buffer = Buffer.alloc(MaxFrameBytes);
-                let length = RtcmTransport.encode(message, buffer);
-                let encoded = buffer.slice(0, length);
-                let messageType = message.constructor.name.replace('RtcmMessage', '');
+            } else {
+                try {
+                    let buffer = Buffer.alloc(MaxFrameBytes);
+                    let length = RtcmTransport.encode(message, buffer);
+                    let encoded = buffer.slice(0, length);
+                    let messageType = message.constructor.name.replace('RtcmMessage', '');
 
-                node.send([
-                    {
-                        payload: {
-                            rtcmMessage: encoded,
-                            rtcm: message.messageType,
-                            messageType: messageType,
-                            input: payload,
+                    node.send([
+                        {
+                            payload: {
+                                rtcmMessage: encoded,
+                                rtcm: message.messageType,
+                                messageType: messageType,
+                                input: payload,
+                            },
                         },
-                    },
-                    null,
-                ]);
-                node.rtcmMessagesReceived++;
-                updateStatus(true);
-            } catch (ex) {
-                node.send([
-                    null,
-                    {
-                        payload: {
-                            error: ex,
-                            input: payload,
+                        null,
+                    ]);
+                    node.rtcmMessagesReceived++;
+                    updateStatus(true);
+                } catch (ex) {
+                    node.send([
+                        null,
+                        {
+                            payload: {
+                                error: ex,
+                                input: payload,
+                            },
                         },
-                    },
-                ]);
-                node.invalidMessagesReceived++;
-                updateStatus(false);
+                    ]);
+                    node.invalidMessagesReceived++;
+                    updateStatus(false);
+                }
             }
         });
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ntrip",
-    "version": "0.2.10",
+    "version": "0.2.11",
     "description": "Node for ntrip and rtcm handling.",
     "node-red": {
         "version": ">=0.1.0",
@@ -9,7 +9,7 @@
         }
     },
     "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
     },
     "keywords": [
         "node-red",
@@ -18,6 +18,12 @@
         "gnss",
         "mmea"
     ],
+    "files": [
+        "ntrip/",
+        "examples/",
+        "images/",
+        "CHANGELOG.md"
+    ],
     "repository": {
         "type": "git",
         "url": "git+https://github.com/windkh/node-red-contrib-ntrip.git"
@@ -25,11 +31,15 @@
     "author": "Karl-Heinz Wind",
     "license": "MIT",
     "scripts": {
-        "test": "mocha test/**/*.spec.js --timeout 5000",
+        "test": "node --test --test-force-exit --test-timeout=30000 --test-concurrency=1",
         "lint": "eslint .",
         "lint:fix": "eslint . --fix",
         "format": "prettier --write .",
-        "format:check": "prettier --check ."
+        "format:check": "prettier --check .",
+        "coverage": "c8 npm test",
+        "coverage:check": "c8 --check-coverage npm test",
+        "standards:audit": "nrstd audit",
+        "standards:sync": "nrstd sync"
     },
     "dependencies": {
         "@gnss/nmea": "^0.1.2",
@@ -38,13 +48,13 @@
     },
     "devDependencies": {
         "@eslint/js": "^10.0.1",
-        "chai": "^4.5.0",
+        "c8": "^10.0.0",
         "eslint": "^10.3.0",
         "eslint-config-prettier": "^10.1.8",
         "globals": "^17.6.0",
-        "mocha": "^11.7.5",
         "node-red": "^5.0.1",
         "node-red-node-test-helper": "^0.3.6",
+        "node-red-standards": "https://codeload.github.com/windkh/node-red-standards/tar.gz/refs/heads/main",
         "prettier": "^3.8.3"
     }
 }

package/.github/dependabot.yml

@@ -1,23 +0,0 @@
-version: 2
-updates:
-    - package-ecosystem: 'npm'
-      directory: '/'
-      schedule:
-          interval: 'weekly'
-      open-pull-requests-limit: 5
-      # The following packages are transitive devDependencies pulled in by
-      # `node-red` / `node-red-node-test-helper`. They have known advisories
-      # but no patched version is currently resolvable, so Dependabot's
-      # security-update PRs fail noisily on every retry. Since these packages
-      # are dev-only (not reachable from the published runtime tree of
-      # @gnss/nmea, @gnss/rtcm, ntrip-client), the advisories don't affect
-      # end users. Remove the ignore once upstream ships a fixed version.
-      ignore:
-          - dependency-name: 'picomatch'
-          - dependency-name: 'ip-address'
-          - dependency-name: 'serialize-javascript'
-
-    - package-ecosystem: 'github-actions'
-      directory: '/'
-      schedule:
-          interval: 'monthly'

package/.github/workflows/node.js.yml

@@ -1,32 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-    push:
-        branches: ['main']
-    pull_request:
-        branches: ['main']
-
-jobs:
-    build:
-        runs-on: ubuntu-latest
-
-        strategy:
-            matrix:
-                node-version: [18.x, 20.x, 22.x]
-                # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-        steps:
-            - uses: actions/checkout@v7
-            - name: Use Node.js ${{ matrix.node-version }}
-              uses: actions/setup-node@v6
-              with:
-                  node-version: ${{ matrix.node-version }}
-                  cache: 'npm'
-            - run: npm ci
-            - run: npm run build --if-present
-            - run: npm run lint
-            - run: npm run format:check
-            - run: npm test