mirror of
https://github.com/got-feedBack/feedBack.git
synced 2026-08-10 18:59:56 +00:00
5fb28d5c5a
static/js/player-state.js — one exported object, two fields. app.js's 70 reference
sites rewritten. Provably a no-op; nothing shrinks.
WHY NOW. Every slice carved out of app.js so far only ever READ the state it shared
(loopA/loopB, _audioSeekGen, currentFilename), so a read-only getter hook was enough
and no container was needed — twice I checked and twice I got away with it. That
runs out at count-in: it genuinely WRITES `isPlaying` (it starts and stops playback,
4 sites) and `lastAudioTime` (2). `import { isPlaying }` then `isPlaying = true`
THROWS — an imported binding cannot be assigned to. So the state has to live on an
object: `S.isPlaying = true` is a property write, and works from any module holding
the same S. Same shape stems, studio, and editor all converged on.
DELIBERATELY SMALL. app.js has ~104 top-level `let` scalars; lifting all of them is
a ~977-site rewrite for no benefit, because most are private to one cluster and
travel with it. Only what a carved module must WRITE goes here. Add on demand.
THE REWRITE IS AST-DRIVEN, NOT TEXTUAL — and that is not fussiness. Of 100 textual
occurrences of these two names, only 70 resolve to the module binding:
* 22 are member accesses (`someObj.isPlaying`, `window.feedBack.isPlaying`)
* 4 are the LOCAL PARAMETER of `function setPlayButtonState(isPlaying)` — a blind
replace yields `function setPlayButtonState(S.isPlaying)`
* 1 is an object key
* 2 are shorthand properties `{ isPlaying }`, which must become
`{ isPlaying: S.isPlaying }` — and acorn gives a shorthand's key and value the
SAME range, so rewriting both produced `isPlaying: S.isPlaying: S.isPlaying`
until I deduped by range
A find-and-replace corrupts all 29. The rewrite walks the AST, skips shadows, member
properties and keys, and replaces identifier RANGES.
`window.feedBack.isPlaying` — the PUBLIC mirror — is a different thing and is
untouched. Two test sandboxes stub it; those were left alone deliberately.
VERIFIED WITH REAL PLAYBACK. A/B against origin/main in two browsers, real song:
togglePlay -> the public mirror goes true -> false -> true across two toggles, the
audio element's paused state follows, seekBy works — IDENTICAL, zero page errors.
Harnesses: 8 vm-sandbox suites slice playback code out of app.js and now see
S.isPlaying — juce_engine_reroute, loop_restart, play_button_reroute_guard,
playback_app_adapter, song_restart, song_seek, speed_reset, and the python
idempotence source-assert. Each gets the same container in its sandbox; every
assertion is unchanged.
pytest 2396, node 1040/1040, ESLint 0, tailwind clean, Codex 0.
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
73 lines
3.6 KiB
JavaScript
73 lines
3.6 KiB
JavaScript
// Regression: the play/pause button must not be reset to "Play" when an
|
|
// in-flight togglePlay() audio.play() is rejected *because the engine reroute
|
|
// (HTML5 -> JUCE) deliberately paused the <audio> element*. Playback continues
|
|
// on the JUCE transport, so the button must stay "Pause" (isPlaying true).
|
|
//
|
|
// Bug: first song after a fresh load on desktop — the reroute's audio.pause()
|
|
// aborts autoplay's play(); togglePlay's catch then flipped the button to Play
|
|
// while the song kept playing, so it took two clicks to actually pause.
|
|
//
|
|
// Same isolation strategy as autoplay_exit.test.js: extract togglePlay() from
|
|
// app.js by brace-matching and run it in a vm sandbox with stubbed deps.
|
|
|
|
const { test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
|
|
const { extractFunction } = require('./test_utils');
|
|
|
|
const APP_JS = path.join(__dirname, '..', '..', 'static', 'app.js');
|
|
const SRC = fs.readFileSync(APP_JS, 'utf8');
|
|
const TOGGLE_PLAY_SRC = extractFunction(SRC, 'async function togglePlay(');
|
|
|
|
// Drive togglePlay() from the not-playing state with an HTML5 audio.play() that
|
|
// rejects, optionally with a reroute in progress. Returns the observed button
|
|
// states and the final isPlaying flag.
|
|
async function runTogglePlayRejecting({ rerouteInProgress }) {
|
|
const buttonStates = [];
|
|
const sandbox = {
|
|
console: { log() {}, warn() {}, error() {} },
|
|
// not-playing -> togglePlay takes the HTML5 play branch.
|
|
// isPlaying / lastAudioTime moved onto the shared player-state container
|
|
// (static/js/player-state.js) so a carved module can WRITE them — an imported
|
|
// binding is read-only. Same values, same assertions, one indirection.
|
|
S: { isPlaying: false, lastAudioTime: 0 },
|
|
_audioSeekGen: 0,
|
|
_playAttemptGen: 0,
|
|
setPlayButtonState(v) { buttonStates.push(v); },
|
|
audio: {
|
|
// Reject like the browser does when a pending play() is interrupted
|
|
// by a pause() (the reroute's deliberate audio.pause()).
|
|
play: () => Promise.reject(new DOMException('aborted by pause', 'AbortError')),
|
|
pause() {},
|
|
},
|
|
jucePlayer: { play: () => Promise.resolve(true), pause: () => Promise.resolve() },
|
|
window: {
|
|
_juceMode: false,
|
|
_juceRerouteInProgress: rerouteInProgress ? 1 : 0,
|
|
feedBack: { isPlaying: false, emit() {} },
|
|
},
|
|
};
|
|
sandbox.globalThis = sandbox;
|
|
vm.createContext(sandbox);
|
|
vm.runInContext(TOGGLE_PLAY_SRC, sandbox, { filename: 'app.js#togglePlay' });
|
|
await vm.runInContext('togglePlay()', sandbox);
|
|
return { buttonStates, isPlaying: sandbox.S.isPlaying };
|
|
}
|
|
|
|
test('reroute-aborted play() leaves the button on Pause (isPlaying stays true)', async () => {
|
|
const { buttonStates, isPlaying } = await runTogglePlayRejecting({ rerouteInProgress: true });
|
|
// Optimistic flip to Pause happened; the reroute guard must prevent the
|
|
// catch from flipping it back to Play.
|
|
assert.deepEqual(buttonStates, [true], 'button should only have been set to Pause, never reset to Play');
|
|
assert.equal(isPlaying, true, 'isPlaying must stay true — the JUCE transport owns playback');
|
|
});
|
|
|
|
test('a genuine play() rejection (no reroute) still resets the button to Play', async () => {
|
|
const { buttonStates, isPlaying } = await runTogglePlayRejecting({ rerouteInProgress: false });
|
|
assert.deepEqual(buttonStates, [true, false], 'button set to Pause then correctly reset to Play on real failure');
|
|
assert.equal(isPlaying, false, 'isPlaying must reflect the failed start');
|
|
});
|