init

jsonws.js

@@ -0,0 +1,206 @@
+/**
+ * Lightweight JSON-RPC over WebSocket client (vanilla JS).
+ *
+ * Usage:
+ *   const client = new JsonRpcWsClient({ url: 'wss://vill.now/mopidy/ws/' });
+ *   client.on('open', () => console.log('connected'));
+ *   client.call('core.playback.get_state').then(result => console.log(result));
+ *   client.on('notification', (notif) => console.log('notif', notif));
+ *   client.connect();
+ *
+ * Works with wss:// if your page is https. If you pass ws:// on an https page,
+ * the browser will block it (mixed content). Use a reverse proxy or wss.
+ */
+
+class JsonRpcWsClient {
+  constructor(opts = {}) {
+    this.url = opts.url || this._defaultUrl(); // ws/wss endpoint
+    this.reconnect = opts.reconnect ?? true;
+    this.reconnectDelay = opts.reconnectDelay ?? 1000; // initial ms
+    this.maxReconnectDelay = opts.maxReconnectDelay ?? 30000; // max ms
+    this.requestTimeout = opts.requestTimeout ?? 15000; // ms
+    this._ws = null;
+    this._nextId = 1;
+    this._pending = new Map(); // id -> {resolve,reject,timeout}
+    this._listeners = new Map(); // event -> [fn,...]
+    this._sendQueue = []; // queue while disconnected
+    this._backoff = this.reconnectDelay;
+    this._manuallyClosed = false;
+  }
+
+  // ---------- public API ----------
+
+  connect() {
+    if (this._ws && (this._ws.readyState === WebSocket.OPEN || this._ws.readyState === WebSocket.CONNECTING)) return;
+    this._manuallyClosed = false;
+    this._openWebSocket();
+  }
+
+  disconnect() {
+    this._manuallyClosed = true;
+    if (this._ws) {
+      try { this._ws.close(1000, 'client disconnect'); } catch (e) {}
+    }
+    this._clearPending(new Error('Client disconnected'));
+  }
+
+  /**
+   * Send a JSON-RPC request. Returns a Promise which resolves with result or rejects on error/timeout.
+   * method: string, params: array or object or undefined.
+   */
+  call(method, params) {
+    const id = this._nextId++;
+    const payload = { jsonrpc: '2.0', method, params, id };
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error('JSON-RPC request timed out'));
+      }, this.requestTimeout);
+
+      this._pending.set(id, { resolve, reject, timeout });
+
+      const str = JSON.stringify(payload);
+      if (this._isWsOpen()) {
+        this._ws.send(str);
+      } else {
+        // queue until connected
+        this._sendQueue.push(str);
+      }
+    });
+  }
+
+  /**
+   * Send a raw notification (no id expected).
+   */
+  notify(method, params) {
+    const payload = { jsonrpc: '2.0', method, params };
+    const str = JSON.stringify(payload);
+    if (this._isWsOpen()) this._ws.send(str);
+    else this._sendQueue.push(str);
+  }
+
+  on(event, fn) {
+    if (!this._listeners.has(event)) this._listeners.set(event, []);
+    this._listeners.get(event).push(fn);
+    return () => this.off(event, fn);
+  }
+
+  off(event, fn) {
+    if (!this._listeners.has(event)) return;
+    this._listeners.set(event, this._listeners.get(event).filter(f => f !== fn));
+  }
+
+  // ---------- internal helpers ----------
+
+  _defaultUrl() {
+    // if page is https, prefer wss, else ws.
+    const loc = window.location;
+    const proto = loc.protocol === 'https:' ? 'wss:' : 'ws:';
+    // default path used by Mopidy is often /mopidy/ws/ — but we don't assume that; user can pass url.
+    return `${proto}//${loc.host}/mopidy/ws/`;
+  }
+
+  _emit(event, ...args) {
+    const list = this._listeners.get(event) || [];
+    for (const fn of list.slice()) { try { fn(...args); } catch (e) { console.error('listener error', e); } }
+  }
+
+  _openWebSocket() {
+    try {
+      this._ws = new WebSocket(this.url);
+    } catch (err) {
+      // e.g. invalid URL or blocked
+      this._emit('error', err);
+      this._scheduleReconnect();
+      return;
+    }
+
+    this._ws.addEventListener('open', () => {
+      this._backoff = this.reconnectDelay;
+      this._emit('open');
+      // flush queue
+      while (this._sendQueue.length && this._isWsOpen()) {
+        this._ws.send(this._sendQueue.shift());
+      }
+    });
+
+    this._ws.addEventListener('message', (ev) => this._handleMessage(ev.data));
+    this._ws.addEventListener('close', (ev) => {
+      this._emit('close', ev);
+      // reject pending requests
+      this._clearPending(new Error(`WebSocket closed (code=${ev.code})`));
+      if (!this._manuallyClosed && this.reconnect) this._scheduleReconnect();
+    });
+    this._ws.addEventListener('error', (err) => {
+      this._emit('error', err);
+      // errors are followed by close; clear pending on close
+    });
+  }
+
+  _isWsOpen() {
+    return this._ws && this._ws.readyState === WebSocket.OPEN;
+  }
+
+  _scheduleReconnect() {
+    if (!this.reconnect) return;
+    const delay = this._backoff;
+    this._emit('reconnect_scheduled', delay);
+    setTimeout(() => {
+      if (this._manuallyClosed) return;
+      this._openWebSocket();
+    }, delay);
+    this._backoff = Math.min(this._backoff * 1.8, this.maxReconnectDelay);
+  }
+
+  _clearPending(err) {
+    for (const [id, p] of this._pending) {
+      clearTimeout(p.timeout);
+      p.reject(err);
+    }
+    this._pending.clear();
+  }
+
+    _handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch (err) {
+      // not JSON at all
+      this._emit('raw', raw);
+      return;
+    }
+
+    // JSON-RPC response (has id)
+    if (msg && Object.prototype.hasOwnProperty.call(msg, 'id')) {
+      const id = msg.id;
+      const pending = this._pending.get(id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this._pending.delete(id);
+
+        if (msg.error !== undefined) {
+          pending.reject(msg.error);
+          this._emit('response', { id, error: msg.error });
+        } else {
+          pending.resolve(msg.result);
+          this._emit('response', { id, result: msg.result });
+        }
+      } else {
+        // response to unknown request
+        this._emit('response', msg);
+      }
+      return;
+    }
+
+    // JSON-RPC notification (has method but no id)
+    if (msg && Object.prototype.hasOwnProperty.call(msg, 'method')) {
+      this._emit('notification', msg);
+      return;
+    }
+
+    // Fallback: just emit as plain message
+    this._emit('message', msg);
+  }
+}
+