node-red-zenbus 1.0.9 → 1.0.10

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "node-red-zenbus",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Real-time next bus ETA from Zenbus networks via direct API (protobuf)",
   "type": "commonjs",
-  "bin": {
-    "zenbus-next-bus": "./zenbus-next-bus.mjs"
-  },
-  "main": "zenbus-core.mjs",
+  "main": "zenbus-next-bus.js",
   "node-red": {
     "version": ">=2.0.0",
     "nodes": {
-      "zenbus-next-bus": "zenbus-node-red.cjs"
+      "zenbus-next-bus": "zenbus-next-bus.js"
     },
     "examples": {
       "zenbus-next-bus": [
@@ -18,26 +15,22 @@
       ]
     }
   },
-  "scripts": {
-    "start": "node zenbus-next-bus.mjs --alias gpso --itinerary 5426824545828864 --stop 5366312231501824"
-  },
   "files": [
-    "zenbus-core.mjs",
-    "zenbus-next-bus.mjs",
-    "zenbus-node-red.cjs",
+    "zenbus-next-bus.js",
     "zenbus-next-bus.html",
     "icons",
-    "examples"
+    "examples",
+    "LICENSE",
+    "README.md"
   ],
   "keywords": [
+    "node-red",
     "zenbus",
     "bus",
     "transit",
     "real-time",
     "eta",
-    "protobuf",
-    "cli",
-    "node-red"
+    "protobuf"
   ],
   "author": "gautric",
   "license": "MIT",
@@ -53,7 +46,6 @@
     "node": ">=18"
   },
   "dependencies": {
-    "protobufjs": "^8.0.1",
-    "yargs": "^17.7.2"
+    "protobufjs": "^8.0.1"
   }
 }

package/zenbus-next-bus.html

@@ -1,7 +1,7 @@
 <script type="text/javascript">
   RED.nodes.registerType('zenbus-next-bus', {
-    category: 'location',
-    color: '#DEB887',
+    category: 'network',
+    color: '#5BA8A8',
     defaults: {
       name: { value: '' },
       alias: { value: '', required: true },
@@ -11,14 +11,14 @@
     },
     inputs: 0,
     outputs: 1,
-    icon: 'zenbus.svg',
+    icon: 'zenbus.png',
     label: function () {
       return this.name || 'zenbus ' + (this.alias || '');
     },
     labelStyle: function () {
       return this.name ? 'node_label_italic' : '';
     },
-    paletteLabel: 'zenbus next bus',
+    paletteLabel: 'zenbus',
     outputLabels: ['bus ETA data']
   });
 </script>

package/zenbus-next-bus.js

@@ -0,0 +1,169 @@
+var protobuf = require('protobufjs');
+
+var BASE = 'https://zenbus.net';
+
+function fetchProto(url, Type) {
+    return fetch(url)
+        .then(function (r) { return r.arrayBuffer(); })
+        .then(function (ab) { return Type.decode(Buffer.from(ab)); });
+}
+
+function secsToHHMM(secs) {
+    var h = Math.floor(secs / 3600);
+    var m = Math.floor((secs % 3600) / 60);
+    return h + 'h' + String(m).padStart(2, '0');
+}
+
+function createClient(opts) {
+    var alias = opts.alias, itinerary = opts.itinerary, stop = opts.stop;
+    return fetch(BASE + '/poll/cdn/zenbus.proto')
+        .then(function (r) { return r.text(); })
+        .then(function (protoText) {
+            var root = protobuf.parse(protoText).root;
+            var StaticMessage = root.lookupType('zenbus_realtime.StaticMessage');
+            var LiveMessage = root.lookupType('zenbus_realtime.LiveMessage');
+
+            return fetchProto(BASE + '/publicapp/static-data?alias=' + alias, StaticMessage)
+                .then(function (staticData) {
+                    var shape = (staticData.shape || []).find(function (s) { return s.itineraryId && s.itineraryId.toString() === itinerary; });
+                    var stopAnchor = shape && (shape.anchor || []).find(function (a) { return a.stopId && a.stopId.toString() === stop; });
+                    var stopIndex = stopAnchor ? (stopAnchor.stopIndexInItinerary != null ? stopAnchor.stopIndexInItinerary : -1) : -1;
+                    var stopDistanceM = stopAnchor ? (stopAnchor.distanceTravelled || 0) : 0;
+                    var stopEntry = (staticData.stop || []).find(function (s) { return s.stopId && s.stopId.toString() === stop; });
+                    var stopName = stopEntry ? stopEntry.name : 'Unknown';
+                    var itin = (staticData.itinerary || []).find(function (i) { return i.itineraryId && i.itineraryId.toString() === itinerary; });
+                    var lineEntry = (staticData.line || []).find(function (l) { return itin && l.lineId && l.lineId.toString() === (itin.lineId && itin.lineId.toString()); });
+                    var lineCode = lineEntry ? lineEntry.code : 'Unknown';
+                    var pollUrl = BASE + '/publicapp/poll?alias=' + alias + '&itinerary=' + itinerary;
+
+                    return {
+                        stopName: stopName,
+                        lineCode: lineCode,
+                        poll: function () {
+                            return fetchProto(pollUrl, LiveMessage).then(function (liveData) {
+                                var now = new Date();
+                                var midnightUtcSecs = (liveData.timetable && liveData.timetable[0] && liveData.timetable[0].midnight && liveData.timetable[0].midnight.toNumber)
+                                    ? liveData.timetable[0].midnight.toNumber()
+                                    : Math.floor(new Date(now).setHours(0, 0, 0, 0) / 1000);
+                                var nowSecs = Math.floor(now.getTime() / 1000) - midnightUtcSecs;
+
+                                var allColumns = (liveData.tripColumn || []).slice();
+                                (liveData.timetable || []).forEach(function (tt) {
+                                    (tt.column || []).forEach(function (col) { allColumns.push(col); });
+                                });
+
+                                var candidates = [];
+                                allColumns.forEach(function (tc) {
+                                    var est = (tc.estimactual || []).find(function (s) { return s.stopIndexInItinerary === stopIndex; });
+                                    var etaSecs = est ? (est.arrival || est.departure || 0) : 0;
+                                    if (!etaSecs || etaSecs <= nowSecs) return;
+
+                                    var vehicleDist = tc.distanceTravelled || 0;
+                                    var hasStarted = tc.previousIndexInItinerary >= 0 && tc.pos && tc.pos.length > 0;
+                                    if (hasStarted && vehicleDist > stopDistanceM) return;
+
+                                    var remainingDist = hasStarted ? Math.max(0, stopDistanceM - vehicleDist) : stopDistanceM;
+                                    var aimed = (tc.aimed || []).find(function (s) { return s.stopIndexInItinerary === stopIndex; });
+                                    var schedSecs = aimed ? (aimed.arrival || aimed.departure || aimed.arriparture || 0) : 0;
+
+                                    candidates.push({
+                                        etaMinutes: Math.round((etaSecs - nowSecs) / 60),
+                                        distanceM: Math.round(remainingDist),
+                                        estimatedArrival: secsToHHMM(etaSecs),
+                                        scheduledTime: schedSecs ? secsToHHMM(schedSecs) : null,
+                                        isLive: hasStarted
+                                    });
+                                });
+
+                                candidates.sort(function (a, b) { return a.etaMinutes - b.etaMinutes; });
+                                var best = candidates[0] || null;
+                                var second = candidates.find(function (c, i) { return i > 0 && c.isLive; }) || null;
+
+                                return {
+                                    stop: stopName,
+                                    line: lineCode,
+                                    timestamp: now.toISOString(),
+                                    now: secsToHHMM(nowSecs),
+                                    next: best,
+                                    secondBus: second
+                                };
+                            });
+                        }
+                    };
+                });
+        });
+}
+
+module.exports = function (RED) {
+
+    function ZenbusNextBusNode(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+        var timer = null;
+        var client = null;
+        var closing = false;
+        var interval = (parseInt(config.interval, 10) || 10) * 1000;
+
+        node.status({ fill: 'yellow', shape: 'ring', text: 'initializing...' });
+
+        createClient({
+            alias: config.alias,
+            itinerary: config.itinerary,
+            stop: config.stop
+        }).then(function (c) {
+            if (closing) return;
+            client = c;
+            node.log('Client ready – stop=' + client.stopName + ' line=' + client.lineCode);
+            node.status({ fill: 'green', shape: 'ring', text: 'connected' });
+            scheduleTick();
+        }).catch(function (e) {
+            node.error('Init failed: ' + e.message);
+            node.status({ fill: 'red', shape: 'ring', text: 'init failed' });
+        });
+
+        function scheduleTick() {
+            if (closing) return;
+            tick().then(function () {
+                if (!closing) timer = setTimeout(scheduleTick, interval);
+            });
+        }
+
+        function tick() {
+            if (!client || closing) return Promise.resolve();
+            return client.poll().then(function (data) {
+                node.send({ payload: data });
+                if (data.next) {
+                    node.status({
+                        fill: data.next.isLive ? 'green' : 'yellow',
+                        shape: 'dot',
+                        text: data.next.etaMinutes + ' min (' + data.next.estimatedArrival + ')'
+                    });
+                } else {
+                    node.status({ fill: 'grey', shape: 'ring', text: 'no bus' });
+                }
+            }).catch(function (e) {
+                node.error('Poll error: ' + e.message, {});
+                node.status({ fill: 'red', shape: 'ring', text: 'error' });
+            });
+        }
+
+        node.on('input', function (msg, send, done) {
+            send = send || function () { node.send.apply(node, arguments); };
+            done = done || function (err) { if (err) node.error(err, msg); };
+            if (!client) { done(new Error('Client not initialized')); return; }
+            client.poll().then(function (data) {
+                send({ payload: data });
+                done();
+            }).catch(function (e) { done(e); });
+        });
+
+        node.on('close', function (removed, done) {
+            closing = true;
+            if (timer) { clearTimeout(timer); timer = null; }
+            client = null;
+            done();
+        });
+    }
+
+    RED.nodes.registerType('zenbus-next-bus', ZenbusNextBusNode);
+};

package/icons/zenbus.svg

@@ -1,9 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 60" width="40" height="60">
-  <path d="M20 0C9 0 0 9 0 20c0 15 20 40 20 40s20-25 20-40C40 9 31 0 20 0z" fill="#8e6538"/>
-  <rect x="10" y="10" width="20" height="18" rx="3" fill="#fff"/>
-  <rect x="12" y="13" width="7" height="6" rx="1" fill="#8e6538"/>
-  <rect x="21" y="13" width="7" height="6" rx="1" fill="#8e6538"/>
-  <rect x="10" y="22" width="20" height="4" fill="#fff"/>
-  <circle cx="14" cy="29" r="2" fill="#fff"/>
-  <circle cx="26" cy="29" r="2" fill="#fff"/>
-</svg>

package/zenbus-core.mjs

@@ -1,82 +0,0 @@
-import protobuf from 'protobufjs';
-
-const BASE = 'https://zenbus.net';
-
-async function fetchProto(url, Type) {
-  const buf = Buffer.from(await (await fetch(url)).arrayBuffer());
-  return Type.decode(buf);
-}
-
-function secsToHHMM(secs) {
-  const h = Math.floor(secs / 3600);
-  const m = Math.floor((secs % 3600) / 60);
-  return `${h}h${String(m).padStart(2, '0')}`;
-}
-
-export async function createClient({ alias, itinerary, stop }) {
-  const protoText = await (await fetch(`${BASE}/poll/cdn/zenbus.proto`)).text();
-  const { root } = protobuf.parse(protoText);
-  const StaticMessage = root.lookupType('zenbus_realtime.StaticMessage');
-  const LiveMessage = root.lookupType('zenbus_realtime.LiveMessage');
-
-  const staticData = await fetchProto(`${BASE}/publicapp/static-data?alias=${alias}`, StaticMessage);
-  const shape = staticData.shape?.find(s => s.itineraryId?.toString() === itinerary);
-  const stopAnchor = shape?.anchor?.find(a => a.stopId?.toString() === stop);
-  const stopIndex = stopAnchor?.stopIndexInItinerary ?? -1;
-  const stopDistanceM = stopAnchor?.distanceTravelled ?? 0;
-  const stopName = staticData.stop?.find(s => s.stopId?.toString() === stop)?.name || 'Unknown';
-  const itin = staticData.itinerary?.find(i => i.itineraryId?.toString() === itinerary);
-  const lineCode = staticData.line?.find(l => l.lineId?.toString() === itin?.lineId?.toString())?.code || 'Unknown';
-
-  const pollUrl = `${BASE}/publicapp/poll?alias=${alias}&itinerary=${itinerary}`;
-
-  return {
-    stopName, lineCode,
-    async poll() {
-      const liveData = await fetchProto(pollUrl, LiveMessage);
-      const now = new Date();
-      const midnightUtcSecs = liveData.timetable?.[0]?.midnight?.toNumber?.()
-        ?? Math.floor(new Date(now).setHours(0, 0, 0, 0) / 1000);
-      const nowSecs = Math.floor(now.getTime() / 1000) - midnightUtcSecs;
-
-      const allColumns = [...(liveData.tripColumn || [])];
-      for (const tt of liveData.timetable || []) {
-        for (const col of tt.column || []) allColumns.push(col);
-      }
-
-      const candidates = [];
-      for (const tc of allColumns) {
-        const est = tc.estimactual?.find(s => s.stopIndexInItinerary === stopIndex);
-        const etaSecs = est?.arrival || est?.departure || 0;
-        if (!etaSecs || etaSecs <= nowSecs) continue;
-
-        const vehicleDist = tc.distanceTravelled || 0;
-        const hasStarted = tc.previousIndexInItinerary >= 0 && tc.pos?.length > 0;
-        if (hasStarted && vehicleDist > stopDistanceM) continue;
-
-        const remainingDist = hasStarted ? Math.max(0, stopDistanceM - vehicleDist) : stopDistanceM;
-        const aimed = tc.aimed?.find(s => s.stopIndexInItinerary === stopIndex);
-        const schedSecs = aimed?.arrival || aimed?.departure || aimed?.arriparture || 0;
-
-        candidates.push({
-          etaMinutes: Math.round((etaSecs - nowSecs) / 60),
-          distanceM: Math.round(remainingDist),
-          estimatedArrival: secsToHHMM(etaSecs),
-          scheduledTime: schedSecs ? secsToHHMM(schedSecs) : null,
-          isLive: hasStarted,
-        });
-      }
-
-      candidates.sort((a, b) => a.etaMinutes - b.etaMinutes);
-      const best = candidates[0] || null;
-      const second = candidates.find((c, i) => i > 0 && c.isLive) || null;
-
-      return {
-        stop: stopName, line: lineCode,
-        timestamp: now.toISOString(),
-        now: secsToHHMM(nowSecs),
-        next: best, secondBus: second,
-      };
-    },
-  };
-}

package/zenbus-next-bus.mjs

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import { createClient } from './zenbus-core.mjs';
-
-const argv = yargs(hideBin(process.argv))
-  .env('ZENBUS')
-  .option('alias', { type: 'string', demandOption: true, describe: 'Network alias (e.g. gpso)' })
-  .option('itinerary', { type: 'string', demandOption: true, describe: 'Itinerary ID' })
-  .option('stop', { type: 'string', demandOption: true, describe: 'Stop ID' })
-  .option('interval', { type: 'number', default: 10, describe: 'Poll interval in seconds' })
-  .option('output', { type: 'string', choices: ['terminal', 'json'], default: 'terminal', describe: 'Output format' })
-  .strict()
-  .parseSync();
-
-const client = await createClient(argv);
-
-function renderTerminal(data) {
-  process.stdout.write('\x1B[2J\x1B[H');
-  console.log('🚌 ZENBUS - Live Stream (Ctrl+C to quit)\n');
-  console.log('═══════════════════════════════════════');
-  console.log(`  🚏 Stop:       ${data.stop}`);
-  console.log(`  🚌 Line:       ${data.line}`);
-  if (data.next) {
-    const n = data.next;
-    console.log(`  ⏱️  ETA:        ${n.etaMinutes} min${n.isLive ? ' (real-time)' : ' (scheduled)'}`);
-    console.log(`  📏 Distance:   ${n.distanceM} m away`);
-    console.log(`  🕐 Arrival:    ${n.estimatedArrival}`);
-    if (n.scheduledTime) console.log(`  📅 Scheduled:  ${n.scheduledTime}`);
-    if (data.secondBus) {
-      const s = data.secondBus;
-      console.log(`  ───────────────────────────────────`);
-      console.log(`  2️⃣  2nd bus:    ${s.etaMinutes} min (${s.distanceM} m away)`);
-      console.log(`  🕐 Arrival:    ${s.estimatedArrival}`);
-    }
-  } else {
-    console.log(`  ⏱️  ETA:        No upcoming bus`);
-  }
-  console.log(`  🕑 Now:        ${data.now}`);
-  console.log('═══════════════════════════════════════');
-}
-
-const render = argv.output === 'json'
-  ? (data) => console.log(JSON.stringify(data))
-  : renderTerminal;
-
-while (true) {
-  try { render(await client.poll()); } catch (e) { console.error('⚠️', e.message); }
-  await new Promise(r => setTimeout(r, argv.interval * 1000));
-}

package/zenbus-node-red.cjs

@@ -1,59 +0,0 @@
-module.exports = function (RED) {
-  function ZenbusNextBusNode(config) {
-    RED.nodes.createNode(this, config);
-    const node = this;
-    let timer = null;
-
-    const interval = (config.interval || 10) * 1000;
-
-    node.status({ fill: 'yellow', shape: 'ring', text: 'connecting...' });
-
-    import('./zenbus-core.mjs').then(({ createClient }) => {
-      createClient({
-        alias: config.alias,
-        itinerary: config.itinerary,
-        stop: config.stop,
-      }).then(client => {
-        node.log('Zenbus client initialized for ' + config.alias);
-
-        async function tick() {
-          try {
-            const data = await client.poll();
-            node.send({ payload: data });
-            if (data.next) {
-              const text = data.next.etaMinutes + ' min';
-              node.status({
-                fill: data.next.isLive ? 'green' : 'yellow',
-                shape: 'dot',
-                text: text,
-              });
-            } else {
-              node.status({ fill: 'grey', shape: 'ring', text: 'no bus' });
-            }
-          } catch (e) {
-            node.error(e.message);
-            node.status({ fill: 'red', shape: 'ring', text: 'error' });
-          }
-          timer = setTimeout(tick, interval);
-        }
-        tick();
-      }).catch(e => {
-        node.error('Init failed: ' + e.message);
-        node.status({ fill: 'red', shape: 'ring', text: 'init failed' });
-      });
-    });
-
-    node.on('close', function (removed, done) {
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      if (removed) {
-        node.log('Zenbus node removed');
-      }
-      done();
-    });
-  }
-
-  RED.nodes.registerType('zenbus-next-bus', ZenbusNextBusNode);
-};