wavegrid 0.1.1

package/receiver.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * The Receiver — the brain of the Illuminate installation.
+ *
+ * A pure state engine that:
+ *   1. Receives grid state from an InputAdapter (upstream source)
+ *   2. Runs an independent low-pass filter (smooth, never jolts)
+ *   3. Falls back to 3D sine waves on signal loss
+ *   4. Sends filtered output to an OutputAdapter (hardware target)
+ *
+ * Both input and output are pluggable adapters — swap them to connect
+ * to any protocol or hardware without modifying the receiver core.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Receiver = exports.DEFAULT_RECEIVER_CONFIG = void 0;
+const adapters_1 = require("./adapters");
+const fallback_1 = require("./fallback");
+const filter_1 = require("./filter");
+exports.DEFAULT_RECEIVER_CONFIG = {
+    input: new adapters_1.WebSocketInput({ url: 'ws://localhost:3000' }),
+    output: new adapters_1.ConsoleOutput(),
+    alpha: filter_1.DEFAULT_RECEIVER_ALPHA,
+    fallbackDelay: 3000,
+    fallback: fallback_1.DEFAULT_FALLBACK_CONFIG,
+    tickMs: 1000 / 60
+};
+class Receiver {
+    config;
+    grid;
+    tickTimer = null;
+    tick = 0;
+    lastDataAt = Date.now();
+    _status = 'reconnecting';
+    _fallbackActive = false;
+    _running = false;
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_RECEIVER_CONFIG, ...config };
+        this.grid = (0, filter_1.createFilteredGrid)();
+    }
+    get status() { return this._status; }
+    get fallbackActive() { return this._fallbackActive; }
+    /** Get the current output state (after filtering). */
+    getOutputState() {
+        return this.grid.map(c => ({
+            h: c.h,
+            s: c.s,
+            b: c.b
+        }));
+    }
+    /** Start the receiver — connects input and begins the tick loop. */
+    start() {
+        if (this._running)
+            return;
+        this._running = true;
+        this.bindInput();
+        this.startTickLoop();
+        console.log('  \u25C8 Receiver started');
+    }
+    /** Stop the receiver — disconnects and stops the tick loop. */
+    stop() {
+        this._running = false;
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+        this.config.input.disconnect();
+        this.config.output.close();
+        console.log('  \u25C8 Receiver stopped');
+    }
+    bindInput() {
+        const input = this.config.input;
+        input.on('connected', () => {
+            this._status = 'connected';
+            this.lastDataAt = Date.now();
+            console.log('  \u25C8 Input connected');
+        });
+        input.on('state', (upstream) => {
+            this.lastDataAt = Date.now();
+            (0, filter_1.applyUpstreamState)(this.grid, upstream);
+            if (this._fallbackActive) {
+                console.log('\n  \u25C8 Signal restored \u2014 blending back from fallback');
+                this._fallbackActive = false;
+            }
+        });
+        input.on('disconnected', () => {
+            this._status = 'reconnecting';
+            console.log('\n  \u25C8 Input disconnected');
+        });
+        input.connect();
+    }
+    startTickLoop() {
+        this.tickTimer = setInterval(() => {
+            this.tick++;
+            const now = Date.now();
+            const timeSinceData = now - this.lastDataAt;
+            // Check if we should switch to fallback
+            if (timeSinceData > this.config.fallbackDelay && !this._fallbackActive) {
+                this._fallbackActive = true;
+                this._status = 'fallback';
+                console.log('\n  \u25C8 Signal lost \u2014 entering sine wave fallback');
+            }
+            // If fallback is active, compute sine wave targets
+            if (this._fallbackActive) {
+                (0, fallback_1.computeFallbackFrame)(this.grid, this.tick, this.config.fallback);
+            }
+            // Always tick the low-pass filter — this ensures smooth output
+            // whether receiving data, transitioning to fallback, or in fallback
+            (0, filter_1.tickFilter)(this.grid, this.config.alpha);
+            // Send filtered output to the output adapter
+            this.config.output.send(this.getOutputState());
+        }, this.config.tickMs);
+    }
+}
+exports.Receiver = Receiver;