@hashsome/integration.music-assistant 0.1.0

package/dist/position.js

@@ -0,0 +1,94 @@
+/**
+ * Where playback is, as the dashboard shows it, for one Music Assistant player and its queue.
+ *
+ * Music Assistant does not make this easy. It sends no queue updates while a track plays, only on
+ * changes, so a position has to be carried forward from the last one. A pause on a player that
+ * cannot hold a stream open is really a stop: the queue's counter goes back to the start and only
+ * its `resume_pos` says where playback will pick up, and that number is cleared as playback starts.
+ * Reading each message as the truth makes the counter jump back and forth around a pause.
+ *
+ * So this keeps a position of its own, and follows two rules. While stopped, show where it was
+ * stopped. Once playing, the queue's own counter is the truth, from its first message on.
+ *
+ * Everything here is pure: a state in, a message in, a state out.
+ */
+/** Only `idle` is a stop. Playing, buffering, paused and a state not yet known all follow the counter. */
+const following = (playback) => playback !== 'idle';
+/** How far before where it was a resumed stream may start, which is not shown as going back. */
+const REWIND_SECONDS = 2;
+export function onQueue(position, message, playback, now) {
+    // A different track has nothing to do with where the last one was, and starts out carrying its
+    // resume spot, which is not its own.
+    const same = message.item === undefined || position.item === undefined || message.item === position.item;
+    const base = same
+        ? position
+        : position.resume !== undefined
+            ? { inherited: position.resume }
+            : {};
+    // What the message says about the resume spot, less the old track's number.
+    const resume = message.resume !== base.inherited ? message.resume : undefined;
+    const { inherited, ...own } = base;
+    const stopped = !following(playback);
+    // Stopped, a resume spot that goes down is Music Assistant clearing it as playback is about to
+    // start, and not where it will resume.
+    const spot = stopped && resume !== undefined && own.resume !== undefined
+        ? Math.max(own.resume, resume)
+        : resume;
+    const next = {
+        ...own,
+        ...(message.item !== undefined ? { item: message.item } : {}),
+        ...(spot !== undefined ? { resume: spot } : {}),
+        // Until the track has a resume spot of its own, the old one is still to be ignored.
+        ...(resume === undefined && inherited !== undefined ? { inherited } : {}),
+    };
+    if (message.elapsed === undefined) {
+        return next;
+    }
+    if (stopped) {
+        // Its counter is back at the start: only the first number is of any use.
+        return next.elapsed === undefined && next.held === undefined
+            ? { ...next, elapsed: message.elapsed, elapsedAt: now }
+            : next;
+    }
+    // Playing: the queue's counter is the truth, apart from the stream starting a moment before the
+    // spot it was stopped at, which is not shown as a step back.
+    const { held, ...rest } = next;
+    const elapsed = held !== undefined && message.elapsed >= held - REWIND_SECONDS
+        ? Math.max(message.elapsed, held)
+        : message.elapsed;
+    return { ...rest, elapsed, elapsedAt: now };
+}
+/** The player's state changed: a stop remembers where it got to, and a start from a stop begins there. */
+export function onPlayback(position, from, to, now) {
+    if (from === to) {
+        return position;
+    }
+    if (following(from) && !following(to)) {
+        if (position.elapsed === undefined) {
+            return position;
+        }
+        const since = from === 'playing' && position.elapsedAt !== undefined
+            ? Math.max(0, now - position.elapsedAt)
+            : 0;
+        // The resume spot is of the last stop, and the next one brings its own.
+        const { resume: _resume, ...rest } = position;
+        return { ...rest, held: position.elapsed + since };
+    }
+    if (!following(from) && following(to)) {
+        // Starting from a stop: from where it was held or, if that stop was not seen, the spot Music
+        // Assistant says it will resume at. Its first queue message says where it really starts.
+        const origin = position.held ?? position.resume ?? position.elapsed;
+        return origin === undefined
+            ? position
+            : { ...position, held: origin, elapsed: origin, elapsedAt: now };
+    }
+    return position;
+}
+/** What to show: playing, the counter; stopped, the later of where it was held and the resume spot. */
+export function positionOf(position, playback) {
+    if (following(playback)) {
+        return position.elapsed;
+    }
+    const spots = [position.held, position.resume].filter((spot) => spot !== undefined);
+    return spots.length > 0 ? Math.max(...spots) : position.elapsed;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@hashsome/integration.music-assistant",
+  "version": "0.1.0",
+  "description": "Music Assistant integration: direct WebSocket client, not via Home Assistant",
+  "type": "module",
+  "dependencies": {
+    "@hashsome/core": "0.1.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./mock": {
+      "types": "./dist/mock.d.ts",
+      "default": "./dist/mock.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "GPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dstoyanoff/hashsome.git",
+    "directory": "packages/integrations/music-assistant"
+  },
+  "homepage": "https://github.com/dstoyanoff/hashsome#readme",
+  "bugs": "https://github.com/dstoyanoff/hashsome/issues",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "players": "node scripts/print-players.ts",
+    "build": "tsc -b tsconfig.build.json"
+  }
+}