peter
cba992379c
Volume-consolidation (conservative — no behaviour or prefs-format change): - playerVolume.ts is now scale-generic (a VolumeScale parameterises range / default / integer rounding). YT_SCALE (0-100 ints) and PLEX_SCALE (0..1 float) bind the same tested core; the YouTube wrappers keep the original API so the existing tests are unchanged. - The Plex usePlayerVolume hook drops its bespoke clamp01 arithmetic for the shared normalizeVolumeIn / stepVolumeIn at PLEX_SCALE. Side effect (a latent bug fix): a corrupt persisted volume now falls back to the default instead of a bare clamp silently muting it. The separate .muted flag stays Plex-only. - clamp01 stays for the seek-bar fraction (its non-volume use). - Tests: the generic core is covered at both scales (float no-round, corrupt -> default, step/clamp) — the Plex-side arithmetic finally has unit coverage. PlexPlayerSettings extraction (verbatim JSX move, behaviour-equivalent): - The ~240-line gear/tuning panel (sync / playback / subtitle / clock tabs) moves out of PlexPlayer into PlexPlayerSettings.tsx (a pure prefs+patchPrefs view owning no state). PlexPlayer shrinks 1402 -> 1173 lines; Slider/Toggle imports it no longer uses are dropped. Gate green (tsc / eslint-0 / prettier / knip / vitest 83 / pytest 234). Dev server smoke: app builds + loads clean, no console errors. The interactive settings panel needs a playing Plex video (unreachable on localdev) -> owed to the user's UAT.
98 lines
4.0 KiB
TypeScript
98 lines
4.0 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
|
|
import {
|
|
DEFAULT_VOLUME,
|
|
PLEX_SCALE,
|
|
YT_SCALE,
|
|
normalizeVolume,
|
|
normalizeVolumeIn,
|
|
stepVolume,
|
|
stepVolumeIn,
|
|
} from "./playerVolume";
|
|
|
|
describe("normalizeVolume", () => {
|
|
it("keeps a valid level", () => {
|
|
expect(normalizeVolume(0)).toBe(0);
|
|
expect(normalizeVolume(37)).toBe(37);
|
|
expect(normalizeVolume(100)).toBe(100);
|
|
});
|
|
|
|
it("clamps out-of-range levels and rounds to whole percents", () => {
|
|
expect(normalizeVolume(-20)).toBe(0);
|
|
expect(normalizeVolume(150)).toBe(100);
|
|
expect(normalizeVolume(42.6)).toBe(43);
|
|
});
|
|
|
|
it.each([
|
|
["a missing key", undefined],
|
|
["an explicit null", null],
|
|
["a stringified number", "80"],
|
|
["NaN from a broken player", NaN],
|
|
["a whole object", { volume: 50 }],
|
|
])("falls back on %s", (_label, raw) => {
|
|
// The regression: a partial stored object made the level undefined, which Math.round turned
|
|
// into NaN — muting playback and persisting `null` for every later session.
|
|
expect(normalizeVolume(raw, 15)).toBe(15);
|
|
});
|
|
|
|
it("prefers the last known level over the default, so a quiet session stays quiet", () => {
|
|
expect(normalizeVolume(NaN, 15)).toBe(15);
|
|
expect(normalizeVolume(NaN, 15)).not.toBe(DEFAULT_VOLUME);
|
|
});
|
|
|
|
it("uses the default when the fallback is unusable too", () => {
|
|
expect(normalizeVolume(NaN, NaN)).toBe(DEFAULT_VOLUME);
|
|
expect(normalizeVolume(null, undefined)).toBe(DEFAULT_VOLUME);
|
|
expect(normalizeVolume(null, "80")).toBe(DEFAULT_VOLUME);
|
|
});
|
|
});
|
|
|
|
describe("stepVolume", () => {
|
|
it("steps up and down from the current level", () => {
|
|
expect(stepVolume(60, { delta: 5, fallback: 100 })).toBe(65);
|
|
expect(stepVolume(60, { delta: -5, fallback: 100 })).toBe(55);
|
|
});
|
|
|
|
it("clamps at both ends instead of wrapping", () => {
|
|
expect(stepVolume(98, { delta: 5, fallback: 100 })).toBe(100);
|
|
expect(stepVolume(3, { delta: -5, fallback: 100 })).toBe(0);
|
|
});
|
|
|
|
it("steps from the fallback when the player answers garbage", () => {
|
|
// A spin must not lose notches to a stale/unusable reading — it continues from what we last set.
|
|
expect(stepVolume(undefined, { delta: -5, fallback: 90 })).toBe(85);
|
|
expect(stepVolume(NaN, { delta: -5, fallback: 90 })).toBe(85);
|
|
});
|
|
});
|
|
|
|
describe("scale-generic core (shared by both players)", () => {
|
|
it("keeps 0..1 floats WITHOUT rounding on the Plex scale", () => {
|
|
// PLEX_SCALE.round is false — the HTML5 <video> takes a float, so 0.37 must stay 0.37 (the YT
|
|
// scale would round it to a whole percent).
|
|
expect(normalizeVolumeIn(0.37, undefined, PLEX_SCALE)).toBeCloseTo(0.37, 10);
|
|
expect(normalizeVolumeIn(1.5, undefined, PLEX_SCALE)).toBe(1); // clamps to max
|
|
expect(normalizeVolumeIn(-0.2, undefined, PLEX_SCALE)).toBe(0); // clamps to min
|
|
});
|
|
|
|
it("falls back to the scale default on a corrupt Plex volume instead of muting", () => {
|
|
// The Plex-side latent bug this consolidation fixes: a bare clamp turned a corrupt persisted
|
|
// volume (null / "0.5" / NaN) into 0 — silently muting — where the shared core falls back to the
|
|
// last-known level, else PLEX_SCALE.default (1).
|
|
expect(normalizeVolumeIn(null, undefined, PLEX_SCALE)).toBe(PLEX_SCALE.default);
|
|
expect(normalizeVolumeIn("0.5", 0.3, PLEX_SCALE)).toBeCloseTo(0.3, 10);
|
|
expect(normalizeVolumeIn(NaN, NaN, PLEX_SCALE)).toBe(PLEX_SCALE.default);
|
|
});
|
|
|
|
it("steps and clamps on the Plex scale", () => {
|
|
expect(stepVolumeIn(0.5, { delta: 0.05, fallback: 0.5 }, PLEX_SCALE)).toBeCloseTo(0.55, 10);
|
|
expect(stepVolumeIn(0.98, { delta: 0.05, fallback: 1 }, PLEX_SCALE)).toBe(1); // clamps at max
|
|
expect(stepVolumeIn(0.03, { delta: -0.05, fallback: 1 }, PLEX_SCALE)).toBe(0); // clamps at min
|
|
});
|
|
|
|
it("still rounds to whole percents on the YouTube scale via the generic core", () => {
|
|
expect(normalizeVolumeIn(42.6, undefined, YT_SCALE)).toBe(43);
|
|
expect(YT_SCALE.round).toBe(true);
|
|
expect(PLEX_SCALE.round).toBe(false);
|
|
});
|
|
});
|