Clean release snapshot

tests/js/playback_test_harness.js

@@ -0,0 +1,166 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { createWindow, ROOT } = require('./capabilities_test_harness');
+
+const CAPABILITIES_JS = path.join(ROOT, 'static', 'capabilities.js');
+const PLAYBACK_JS = path.join(ROOT, 'static', 'capabilities', 'playback.js');
+const INSPECTOR_JS = path.join(ROOT, 'plugins', 'capability_inspector', 'screen.js');
+
+function loadPlayback(options = {}) {
+    const window = createWindow(options);
+    const context = vm.createContext(window);
+    vm.runInContext(fs.readFileSync(CAPABILITIES_JS, 'utf8'), context, { filename: CAPABILITIES_JS });
+    vm.runInContext(fs.readFileSync(PLAYBACK_JS, 'utf8'), context, { filename: PLAYBACK_JS });
+    window.__vmContext = context;
+    return window;
+}
+
+function runBrowserScript(window, filePath) {
+    vm.runInContext(fs.readFileSync(filePath, 'utf8'), window.__vmContext, { filename: filePath });
+}
+
+function loadInspector(window) {
+    runBrowserScript(window, INSPECTOR_JS);
+    return window;
+}
+
+function captureEvents(window, eventName) {
+    const events = [];
+    window.slopsmith.on(eventName, event => events.push(event.detail));
+    return events;
+}
+
+function diagnosticsSnapshot(window, options = {}) {
+    return window.slopsmith.playback.snapshot(options);
+}
+
+function dispatch(window, command, payload = {}, requester = 'test') {
+    return window.slopsmith.capabilities.dispatch({ capability: 'playback', command, args: payload, requester });
+}
+
+function makeTarget(overrides = {}) {
+    return {
+        filename: overrides.filename || '/Users/example/DLC/Secret Artist - Song_p.psarc',
+        title: overrides.title || 'Visible Title',
+        artist: overrides.artist || 'Visible Artist',
+        arrangement: overrides.arrangement || 'Lead',
+        arrangementIndex: overrides.arrangementIndex ?? 0,
+        format: overrides.format || 'psarc',
+        sourceKind: overrides.sourceKind || 'local',
+        ...overrides,
+    };
+}
+
+function makeAdapter(overrides = {}) {
+    const calls = [];
+    let currentTime = overrides.currentTime ?? 0;
+    let duration = overrides.duration ?? 120;
+    let isPlaying = false;
+    let loop = { enabled: false, state: 'inactive' };
+    let route = { routeKind: 'browser-media', state: 'active', preservedTime: true };
+    const adapter = {
+        calls,
+        inspect() {
+            calls.push(['inspect']);
+            return overrides.inspectResult || { currentTime, mediaTime: currentTime, chartTime: currentTime, duration, playbackRate: 1, isPlaying, route, loop };
+        },
+        async start(request) {
+            calls.push(['start', request]);
+            isPlaying = !!overrides.startPlaying;
+            if (overrides.startError) throw new Error(overrides.startError);
+            return overrides.startResult || { currentTime, duration, isPlaying, route, loop };
+        },
+        async pause(request) {
+            calls.push(['pause', request]);
+            isPlaying = false;
+            if (overrides.pauseError) throw new Error(overrides.pauseError);
+            return overrides.pauseResult || { currentTime, duration, isPlaying, route, loop };
+        },
+        async resume(request) {
+            calls.push(['resume', request]);
+            if (overrides.resumeUnavailable) return { unavailable: true, reason: 'unavailable' };
+            if (overrides.resumeError) throw new Error(overrides.resumeError);
+            isPlaying = true;
+            return overrides.resumeResult || { currentTime, duration, isPlaying, route, loop };
+        },
+        async stop(request) {
+            calls.push(['stop', request]);
+            isPlaying = false;
+            if (overrides.stopError) throw new Error(overrides.stopError);
+            return overrides.stopResult || { currentTime, duration, isPlaying, route, loop };
+        },
+        async seek(request) {
+            calls.push(['seek', request]);
+            if (overrides.seekError) throw new Error(overrides.seekError);
+            if (overrides.seekResult) {
+                currentTime = overrides.seekResult.to ?? overrides.seekResult.landedTime ?? currentTime;
+                return overrides.seekResult;
+            }
+            const to = Math.max(0, Math.min(duration, Number(request.time)));
+            const from = currentTime;
+            currentTime = to;
+            return { completed: true, from, to };
+        },
+        async setLoop(request) {
+            calls.push(['setLoop', request]);
+            if (overrides.setLoopError) throw new Error(overrides.setLoopError);
+            if (overrides.setLoopResult !== undefined) return overrides.setLoopResult;
+            loop = { startTime: request.startTime, endTime: request.endTime, enabled: true, state: 'active' };
+            return true;
+        },
+        async clearLoop(request) {
+            calls.push(['clearLoop', request]);
+            loop = { enabled: false, state: 'cleared' };
+            return true;
+        },
+    };
+    return adapter;
+}
+
+function installInspectorDom(window) {
+    const elements = new Map();
+    function element(id) {
+        const item = {
+            id,
+            value: '',
+            textContent: '',
+            innerHTML: '',
+            className: '',
+            dataset: {},
+            style: {},
+            classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
+            addEventListener() {},
+            removeEventListener() {},
+            querySelectorAll() { return []; },
+            querySelector() { return null; },
+            closest() { return null; },
+            getBoundingClientRect() { return { width: 1000, height: 400, left: 0, top: 0 }; },
+            appendChild(child) { return child; },
+        };
+        elements.set(id, item);
+        return item;
+    }
+    element('capability-inspector-filter');
+    element('capability-inspector-content');
+    element('capability-inspector-empty');
+    element('capability-inspector-summary');
+    window.document.getElementById = id => elements.get(id) || null;
+    window.document.querySelectorAll = () => [];
+    window.document.addEventListener = () => {};
+    window.document.createElement = () => element(`created-${elements.size}`);
+    window.requestAnimationFrame = callback => callback();
+    return elements;
+}
+
+module.exports = {
+    ROOT,
+    loadPlayback,
+    loadInspector,
+    captureEvents,
+    diagnosticsSnapshot,
+    dispatch,
+    makeTarget,
+    makeAdapter,
+    installInspectorDom,
+};