wavesurfer.js 7.9.5 → 7.9.7

package/dist/__tests__/base-plugin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/base-plugin.test.js

@@ -0,0 +1,29 @@
+import { BasePlugin } from '../base-plugin.js';
+class TestPlugin extends BasePlugin {
+    constructor() {
+        super(...arguments);
+        this.initCalled = false;
+    }
+    onInit() {
+        this.initCalled = true;
+    }
+}
+describe('BasePlugin', () => {
+    test('_init calls onInit and sets wavesurfer', () => {
+        const plugin = new TestPlugin({});
+        const ws = {};
+        plugin._init(ws);
+        expect(plugin.wavesurfer).toBe(ws);
+        expect(plugin.initCalled).toBe(true);
+    });
+    test('destroy emits destroy and unsubscribes', () => {
+        const plugin = new TestPlugin({});
+        const unsub = jest.fn();
+        plugin.subscriptions = [unsub];
+        const spy = jest.fn();
+        plugin.on('destroy', spy);
+        plugin.destroy();
+        expect(spy).toHaveBeenCalled();
+        expect(unsub).toHaveBeenCalled();
+    });
+});

package/dist/__tests__/dom.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/dom.test.js

@@ -0,0 +1,16 @@
+import createElement from '../dom.js';
+describe('createElement', () => {
+    test('creates DOM structure', () => {
+        var _a;
+        const container = document.createElement('div');
+        const el = createElement('div', {
+            id: 'root',
+            children: {
+                span: { textContent: 'child' },
+            },
+        }, container);
+        expect(container.firstChild).toBe(el);
+        expect(el.id).toBe('root');
+        expect((_a = el.querySelector('span')) === null || _a === void 0 ? void 0 : _a.textContent).toBe('child');
+    });
+});

package/dist/__tests__/draggable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/draggable.test.js

@@ -0,0 +1,50 @@
+import { makeDraggable } from '../draggable.js';
+describe('makeDraggable', () => {
+    beforeAll(() => {
+        Object.defineProperty(window, 'matchMedia', {
+            writable: true,
+            value: jest.fn().mockReturnValue({
+                matches: false,
+                addListener: jest.fn(),
+                removeListener: jest.fn(),
+            }),
+        });
+        if (typeof window.PointerEvent === 'undefined') {
+            class FakePointerEvent extends MouseEvent {
+                constructor(type, props) {
+                    super(type, props);
+                }
+            }
+            // @ts-ignore
+            window.PointerEvent = FakePointerEvent;
+            // @ts-ignore
+            global.PointerEvent = FakePointerEvent;
+        }
+    });
+    test('invokes callbacks on drag', () => {
+        const el = document.createElement('div');
+        document.body.appendChild(el);
+        jest.spyOn(el, 'getBoundingClientRect').mockReturnValue({
+            left: 0,
+            top: 0,
+            width: 100,
+            height: 100,
+            right: 100,
+            bottom: 100,
+            x: 0,
+            y: 0,
+            toJSON: () => { },
+        });
+        const onDrag = jest.fn();
+        const onStart = jest.fn();
+        const onEnd = jest.fn();
+        const unsubscribe = makeDraggable(el, onDrag, onStart, onEnd, 0);
+        el.dispatchEvent(new PointerEvent('pointerdown', { clientX: 10, clientY: 10 }));
+        document.dispatchEvent(new PointerEvent('pointermove', { clientX: 20, clientY: 20 }));
+        document.dispatchEvent(new PointerEvent('pointerup', { clientX: 20, clientY: 20 }));
+        expect(onStart).toHaveBeenCalled();
+        expect(onDrag).toHaveBeenCalled();
+        expect(onEnd).toHaveBeenCalled();
+        unsubscribe();
+    });
+});

package/dist/__tests__/event-emitter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/event-emitter.test.js

@@ -0,0 +1,26 @@
+import EventEmitter from '../event-emitter.js';
+describe('EventEmitter', () => {
+    test('on and emit', () => {
+        const emitter = new EventEmitter();
+        const handler = jest.fn();
+        emitter.on('foo', handler);
+        emitter.emit('foo', 42);
+        expect(handler).toHaveBeenCalledWith(42);
+    });
+    test('once', () => {
+        const emitter = new EventEmitter();
+        const handler = jest.fn();
+        emitter.once('bar', handler);
+        emitter.emit('bar');
+        emitter.emit('bar');
+        expect(handler).toHaveBeenCalledTimes(1);
+    });
+    test('unAll', () => {
+        const emitter = new EventEmitter();
+        const handler = jest.fn();
+        emitter.on('foo', handler);
+        emitter.unAll();
+        emitter.emit('foo', 1);
+        expect(handler).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/fetcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/fetcher.test.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Fetcher from '../fetcher.js';
+import { TextEncoder } from 'util';
+import { Blob as NodeBlob } from 'buffer';
+describe('Fetcher', () => {
+    test('fetchBlob returns blob and reports progress', () => __awaiter(void 0, void 0, void 0, function* () {
+        const data = 'hello';
+        const reader = {
+            read: jest
+                .fn()
+                .mockResolvedValueOnce({ done: false, value: new TextEncoder().encode(data) })
+                .mockResolvedValueOnce({ done: true, value: undefined }),
+        };
+        const response = {
+            status: 200,
+            statusText: 'OK',
+            headers: new Headers({ 'Content-Length': data.length.toString() }),
+            body: { getReader: () => reader },
+            clone() {
+                return this;
+            },
+            blob: () => __awaiter(void 0, void 0, void 0, function* () { return new NodeBlob([data]); }),
+        };
+        global.fetch = jest.fn().mockResolvedValue(response);
+        const progress = jest.fn();
+        const blob = yield Fetcher.fetchBlob('url', progress);
+        expect(yield blob.text()).toBe(data);
+        // wait for watchProgress to process
+        yield new Promise(process.nextTick);
+        expect(progress).toHaveBeenCalledWith(100);
+    }));
+});

package/dist/__tests__/player.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/player.test.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Player from '../player.js';
+describe('Player', () => {
+    const createMedia = () => {
+        const media = document.createElement('audio');
+        media.play = jest.fn().mockResolvedValue(undefined);
+        media.pause = jest.fn();
+        media.setSinkId = jest.fn().mockResolvedValue(undefined);
+        return media;
+    };
+    test('play and pause', () => __awaiter(void 0, void 0, void 0, function* () {
+        const media = createMedia();
+        const player = new Player({ media });
+        yield player.play();
+        expect(media.play).toHaveBeenCalled();
+        player.pause();
+        expect(media.pause).toHaveBeenCalled();
+    }));
+    test('volume and muted', () => {
+        const media = createMedia();
+        const player = new Player({ media });
+        player.setVolume(0.5);
+        expect(player.getVolume()).toBe(0.5);
+        player.setMuted(true);
+        expect(player.getMuted()).toBe(true);
+    });
+    test('setTime clamps to duration', () => {
+        const media = createMedia();
+        Object.defineProperty(media, 'duration', { configurable: true, value: 10 });
+        const player = new Player({ media });
+        player.setTime(-1);
+        expect(player.getCurrentTime()).toBe(0);
+        player.setTime(11);
+        expect(player.getCurrentTime()).toBe(10);
+    });
+    test('setSinkId uses media method', () => __awaiter(void 0, void 0, void 0, function* () {
+        const media = createMedia();
+        const player = new Player({ media });
+        yield player.setSinkId('id');
+        expect(media.setSinkId).toHaveBeenCalledWith('id');
+    }));
+});

package/dist/__tests__/renderer.test.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface Window {
+        HTMLCanvasElement: typeof HTMLCanvasElement;
+    }
+}
+export {};

package/dist/__tests__/renderer.test.js

@@ -0,0 +1,180 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Renderer from '../renderer.js';
+const createAudioBuffer = (channels, duration = 1) => {
+    return {
+        duration,
+        length: channels[0].length,
+        sampleRate: channels[0].length / duration,
+        numberOfChannels: channels.length,
+        getChannelData: (i) => Float32Array.from(channels[i]),
+        copyFromChannel: jest.fn(),
+        copyToChannel: jest.fn(),
+    };
+};
+describe('Renderer', () => {
+    let container;
+    let renderer;
+    const originalGetContext = window.HTMLCanvasElement.prototype.getContext;
+    const originalToDataURL = window.HTMLCanvasElement.prototype.toDataURL;
+    const originalToBlob = window.HTMLCanvasElement.prototype.toBlob;
+    beforeAll(() => {
+        Object.defineProperty(window, 'devicePixelRatio', { value: 1, writable: true });
+        window.HTMLCanvasElement.prototype.getContext = jest.fn(() => ({
+            beginPath: jest.fn(),
+            rect: jest.fn(),
+            roundRect: jest.fn(),
+            moveTo: jest.fn(),
+            lineTo: jest.fn(),
+            closePath: jest.fn(),
+            fill: jest.fn(),
+            drawImage: jest.fn(),
+            fillRect: jest.fn(),
+            createLinearGradient: jest.fn(() => ({ addColorStop: jest.fn() })),
+            globalCompositeOperation: '',
+            canvas: { width: 100, height: 100 },
+        }));
+        window.HTMLCanvasElement.prototype.toDataURL = jest.fn(() => 'data:mock');
+        window.HTMLCanvasElement.prototype.toBlob = jest.fn(cb => cb(new Blob([''])));
+    });
+    afterAll(() => {
+        window.HTMLCanvasElement.prototype.getContext = originalGetContext;
+        window.HTMLCanvasElement.prototype.toDataURL = originalToDataURL;
+        window.HTMLCanvasElement.prototype.toBlob = originalToBlob;
+    });
+    beforeEach(() => {
+        container = document.createElement('div');
+        container.id = 'root';
+        document.body.appendChild(container);
+        renderer = new Renderer({ container });
+    });
+    afterEach(() => {
+        renderer.destroy();
+        container.remove();
+        jest.clearAllMocks();
+    });
+    test('parentFromOptionsContainer returns element and throws', () => {
+        expect(renderer.parentFromOptionsContainer(container)).toBe(container);
+        expect(renderer.parentFromOptionsContainer('#root')).toBe(container);
+        expect(() => renderer.parentFromOptionsContainer('#missing')).toThrow();
+    });
+    test('initHtml creates shadow root', () => {
+        const [el, shadow] = renderer.initHtml();
+        expect(el.shadowRoot).toBe(shadow);
+        expect(shadow.querySelector('.scroll')).not.toBeNull();
+    });
+    test('getHeight calculates values', () => {
+        ;
+        renderer.audioData = { numberOfChannels: 2 };
+        expect(renderer.getHeight(undefined, undefined)).toBe(128);
+        expect(renderer.getHeight(50, undefined)).toBe(50);
+        container.style.height = '200px';
+        expect(renderer.getHeight('auto', [{ overlay: false }])).toBe(64);
+    });
+    test('createDelay resolves after time', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.useFakeTimers();
+        const delay = renderer.createDelay(10);
+        const spy = jest.fn();
+        const p = delay().then(spy);
+        jest.advanceTimersByTime(10);
+        yield p;
+        expect(spy).toHaveBeenCalled();
+        jest.useRealTimers();
+    }));
+    test('convertColorValues supports gradients', () => {
+        const result = renderer.convertColorValues(['red', 'blue']);
+        expect(typeof result).toBe('object');
+        expect((renderer.convertColorValues('red'))).toBe('red');
+    });
+    test('getPixelRatio returns positive', () => {
+        window.devicePixelRatio = 2;
+        expect(renderer.getPixelRatio()).toBe(2);
+    });
+    test('renderBarWaveform and renderLineWaveform draw on context', () => {
+        const ctx = renderer.canvasWrapper.ownerDocument.createElement('canvas').getContext('2d');
+        const data = [new Float32Array([0, 0.5, -0.5]), new Float32Array([0, -0.5, 0.5])];
+        renderer.renderBarWaveform(data, {}, ctx, 1);
+        expect(ctx.beginPath).toHaveBeenCalled();
+        renderer.renderLineWaveform(data, {}, ctx, 1);
+        expect(ctx.lineTo).toHaveBeenCalled();
+    });
+    test('renderWaveform chooses rendering path', () => {
+        const ctx = document.createElement('canvas').getContext('2d');
+        const data = [new Float32Array([0, 1])];
+        const spyBar = jest.spyOn(renderer, 'renderBarWaveform');
+        const spyLine = jest.spyOn(renderer, 'renderLineWaveform');
+        renderer.renderWaveform(data, { barWidth: 1 }, ctx);
+        expect(spyBar).toHaveBeenCalled();
+        renderer.renderWaveform(data, {}, ctx);
+        expect(spyLine).toHaveBeenCalled();
+    });
+    test('renderSingleCanvas appends canvases', () => {
+        const canvasContainer = document.createElement('div');
+        const progressContainer = document.createElement('div');
+        const data = [new Float32Array([0, 1])];
+        renderer.renderSingleCanvas(data, {}, 10, 10, 0, canvasContainer, progressContainer);
+        expect(canvasContainer.querySelector('canvas')).not.toBeNull();
+        expect(progressContainer.querySelector('canvas')).not.toBeNull();
+    });
+    test('renderMultiCanvas draws and subscribes', () => {
+        const canvasContainer = document.createElement('div');
+        const progressContainer = document.createElement('div');
+        const data = [new Float32Array([0, 1])];
+        Object.defineProperty(renderer.scrollContainer, 'clientWidth', { configurable: true, value: 200 });
+        renderer.renderMultiCanvas(data, { barWidth: 1 }, 200, 10, canvasContainer, progressContainer);
+        expect(canvasContainer.querySelector('canvas')).not.toBeNull();
+    });
+    test('renderChannel creates containers', () => {
+        const data = [new Float32Array([0, 1])];
+        renderer.renderChannel(data, {}, 10, 0);
+        expect(renderer.canvasWrapper.children.length).toBeGreaterThan(0);
+    });
+    test('render processes audio buffer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const buffer = createAudioBuffer([[0, 0.5, -0.5]]);
+        const spy = jest.fn();
+        renderer.on('render', spy);
+        yield renderer.render(buffer);
+        expect(spy).toHaveBeenCalled();
+    }));
+    test('reRender keeps scroll position', () => __awaiter(void 0, void 0, void 0, function* () {
+        const buffer = createAudioBuffer([[0, 0.5, -0.5]]);
+        yield renderer.render(buffer);
+        renderer.setScroll(10);
+        renderer.reRender();
+        expect(renderer.getScroll()).toBe(10);
+    }));
+    test('zoom updates option', () => {
+        renderer.zoom(20);
+        expect(renderer.options.minPxPerSec).toBe(20);
+    });
+    test('scrollIntoView updates scroll', () => {
+        Object.defineProperty(renderer.scrollContainer, 'scrollWidth', { configurable: true, value: 100 });
+        Object.defineProperty(renderer.scrollContainer, 'clientWidth', { configurable: true, value: 50 });
+        renderer.renderProgress(0);
+        renderer.scrollIntoView(0.8);
+        expect(renderer.getScroll()).toBeGreaterThanOrEqual(0);
+    });
+    test('renderProgress updates styles', () => {
+        renderer.renderProgress(0.5);
+        expect(renderer.progressWrapper.style.width).toBe('50%');
+    });
+    test('exportImage returns data', () => __awaiter(void 0, void 0, void 0, function* () {
+        const canvas = document.createElement('canvas');
+        renderer.canvasWrapper.appendChild(canvas);
+        const urls = yield renderer.exportImage('image/png', 1, 'dataURL');
+        expect(urls).toHaveLength(1);
+        const blobs = yield renderer.exportImage('image/png', 1, 'blob');
+        expect(blobs).toHaveLength(1);
+    }));
+    test('destroy cleans up', () => {
+        renderer.destroy();
+        expect(container.contains(renderer.getWrapper())).toBe(false);
+    });
+});

package/dist/__tests__/timer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/timer.test.js

@@ -0,0 +1,18 @@
+import Timer from '../timer.js';
+describe('Timer', () => {
+    test('start schedules ticks', () => {
+        const timer = new Timer();
+        const tick = jest.fn();
+        timer.on('tick', tick);
+        const raf = jest
+            .fn()
+            .mockImplementationOnce((cb) => {
+            cb(0);
+            return 1;
+        })
+            .mockImplementation(() => 1);
+        global.requestAnimationFrame = raf;
+        timer.start();
+        expect(tick).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/__tests__/wavesurfer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/wavesurfer.test.js

@@ -0,0 +1,227 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+jest.mock('../renderer.js', () => {
+    let lastInstance;
+    class Renderer {
+        constructor(options) {
+            this.wrapper = document.createElement('div');
+            this.renderProgress = jest.fn();
+            this.on = jest.fn(() => () => undefined);
+            this.setOptions = jest.fn();
+            this.getWrapper = jest.fn(() => this.wrapper);
+            this.getWidth = jest.fn(() => 100);
+            this.getScroll = jest.fn(() => 0);
+            this.setScroll = jest.fn();
+            this.setScrollPercentage = jest.fn();
+            this.render = jest.fn();
+            this.zoom = jest.fn();
+            this.exportImage = jest.fn(() => []);
+            this.destroy = jest.fn();
+            this.options = options;
+            lastInstance = this;
+        }
+    }
+    return { __esModule: true, default: Renderer, getLastInstance: () => lastInstance };
+});
+jest.mock('../timer.js', () => {
+    let lastInstance;
+    class Timer {
+        constructor() {
+            this.on = jest.fn(() => () => undefined);
+            this.start = jest.fn();
+            this.stop = jest.fn();
+            this.destroy = jest.fn();
+        }
+    }
+    const ctor = jest.fn(() => {
+        lastInstance = new Timer();
+        return lastInstance;
+    });
+    return { __esModule: true, default: ctor, getLastInstance: () => lastInstance };
+});
+jest.mock('../decoder.js', () => {
+    const createBuffer = jest.fn((data, duration) => ({
+        duration,
+        numberOfChannels: data.length,
+        getChannelData: (i) => Float32Array.from(data[i]),
+    }));
+    return { __esModule: true, default: { decode: jest.fn(), createBuffer } };
+});
+import WaveSurfer from '../wavesurfer.js';
+import { BasePlugin } from '../base-plugin.js';
+import * as RendererModule from '../renderer.js';
+import * as TimerModule from '../timer.js';
+const getRenderer = RendererModule.getLastInstance;
+const getTimer = TimerModule.getLastInstance;
+const createMedia = () => {
+    const media = document.createElement('audio');
+    media.play = jest.fn().mockResolvedValue(undefined);
+    media.pause = jest.fn();
+    Object.defineProperty(media, 'duration', { configurable: true, value: 100, writable: true });
+    return media;
+};
+const createWs = (opts = {}) => {
+    const container = document.createElement('div');
+    return WaveSurfer.create(Object.assign({ container, media: createMedia() }, opts));
+};
+afterEach(() => {
+    jest.clearAllMocks();
+});
+describe('WaveSurfer public methods', () => {
+    test('create returns instance', () => {
+        const ws = createWs();
+        expect(ws).toBeInstanceOf(WaveSurfer);
+    });
+    test('setOptions merges options and updates renderer', () => {
+        const ws = createWs();
+        ws.setOptions({ height: 200, audioRate: 2, mediaControls: true });
+        const renderer = getRenderer();
+        expect(ws.options.height).toBe(200);
+        expect(renderer.setOptions).toHaveBeenCalledWith(ws.options);
+        expect(ws.getPlaybackRate()).toBe(2);
+        expect(ws.getMediaElement().controls).toBe(true);
+    });
+    test('registerPlugin adds and removes plugin', () => {
+        const ws = createWs();
+        class TestPlugin extends BasePlugin {
+        }
+        const plugin = new TestPlugin({});
+        ws.registerPlugin(plugin);
+        expect(ws.getActivePlugins()).toContain(plugin);
+        plugin.destroy();
+        expect(ws.getActivePlugins()).not.toContain(plugin);
+    });
+    test('wrapper and scroll helpers call renderer', () => {
+        const ws = createWs();
+        const renderer = getRenderer();
+        ws.getWrapper();
+        expect(renderer.getWrapper).toHaveBeenCalled();
+        ws.getWidth();
+        expect(renderer.getWidth).toHaveBeenCalled();
+        ws.getScroll();
+        expect(renderer.getScroll).toHaveBeenCalled();
+        ws.setScroll(42);
+        expect(renderer.setScroll).toHaveBeenCalledWith(42);
+        jest.spyOn(ws, 'getDuration').mockReturnValue(10);
+        ws.setScrollTime(5);
+        expect(renderer.setScrollPercentage).toHaveBeenCalledWith(0.5);
+    });
+    test('load and loadBlob call loadAudio', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ws = createWs();
+        const spy = jest.spyOn(ws, 'loadAudio').mockResolvedValue(undefined);
+        yield ws.load('url');
+        expect(spy).toHaveBeenCalledWith('url', undefined, undefined, undefined);
+        const blob = new Blob([]);
+        yield ws.loadBlob(blob);
+        expect(spy).toHaveBeenCalledWith('', blob, undefined, undefined);
+    }));
+    test('zoom requires decoded data', () => {
+        const ws = createWs();
+        expect(() => ws.zoom(10)).toThrow();
+        ws.decodedData = { duration: 1 };
+        ws.zoom(10);
+        expect(getRenderer().zoom).toHaveBeenCalledWith(10);
+    });
+    test('getDecodedData returns buffer', () => {
+        const ws = createWs();
+        ws.decodedData = 123;
+        expect(ws.getDecodedData()).toBe(123);
+    });
+    test('exportPeaks reads data from buffer', () => {
+        const ws = createWs();
+        ws.decodedData = {
+            numberOfChannels: 1,
+            getChannelData: () => new Float32Array([0, 1, -1]),
+            duration: 3,
+        };
+        const peaks = ws.exportPeaks({ maxLength: 3, precision: 100 });
+        expect(peaks[0]).toEqual([0, 1, -1]);
+    });
+    test('getDuration falls back to decoded data', () => {
+        const ws = createWs();
+        const media = ws.getMediaElement();
+        Object.defineProperty(media, 'duration', { configurable: true, value: Infinity });
+        ws.decodedData = { duration: 2 };
+        expect(ws.getDuration()).toBe(2);
+    });
+    test('toggleInteraction sets option', () => {
+        const ws = createWs();
+        ws.toggleInteraction(false);
+        expect(ws.options.interact).toBe(false);
+    });
+    test('setTime updates progress and emits event', () => {
+        const ws = createWs();
+        const spy = jest.fn();
+        ws.on('timeupdate', spy);
+        ws.setTime(1);
+        expect(spy).toHaveBeenCalledWith(1);
+        expect(getRenderer().renderProgress).toHaveBeenCalled();
+    });
+    test('seekTo calculates correct time', () => {
+        const ws = createWs();
+        jest.spyOn(ws, 'getDuration').mockReturnValue(10);
+        const setTimeSpy = jest.spyOn(ws, 'setTime');
+        ws.seekTo(0.5);
+        expect(setTimeSpy).toHaveBeenCalledWith(5);
+    });
+    test('play sets start and end', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ws = createWs();
+        const spy = jest.spyOn(ws, 'setTime');
+        yield ws.play(2, 4);
+        expect(spy).toHaveBeenCalledWith(2);
+        expect(ws.stopAtPosition).toBe(4);
+    }));
+    test('playPause toggles play and pause', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ws = createWs();
+        const media = ws.getMediaElement();
+        yield ws.playPause();
+        expect(media.play).toHaveBeenCalled();
+        Object.defineProperty(media, 'paused', { configurable: true, value: false });
+        yield ws.playPause();
+        expect(media.pause).toHaveBeenCalled();
+    }));
+    test('stop resets time', () => {
+        const ws = createWs();
+        ws.setTime(5);
+        ws.stop();
+        expect(ws.getCurrentTime()).toBe(0);
+    });
+    test('skip and empty', () => {
+        const ws = createWs();
+        ws.getMediaElement().currentTime = 1;
+        const spy = jest.spyOn(ws, 'setTime');
+        ws.skip(2);
+        expect(spy).toHaveBeenCalledWith(3);
+        const loadSpy = jest.spyOn(ws, 'load').mockResolvedValue(undefined);
+        ws.empty();
+        expect(loadSpy).toHaveBeenCalledWith('', [[0]], 0.001);
+    });
+    test('setMediaElement reinitializes events', () => {
+        const ws = createWs();
+        const unsub = jest.spyOn(ws, 'unsubscribePlayerEvents');
+        const init = jest.spyOn(ws, 'initPlayerEvents');
+        const el = createMedia();
+        ws.setMediaElement(el);
+        expect(unsub).toHaveBeenCalled();
+        expect(init).toHaveBeenCalled();
+        expect(ws.getMediaElement()).toBe(el);
+    });
+    test('exportImage uses renderer', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ws = createWs();
+        yield ws.exportImage('image/png', 1, 'dataURL');
+        expect(getRenderer().exportImage).toHaveBeenCalled();
+    }));
+    test('destroy cleans up renderer and timer', () => {
+        const ws = createWs();
+        ws.destroy();
+        expect(getRenderer().destroy).toHaveBeenCalled();
+        expect(getTimer().destroy).toHaveBeenCalled();
+    });
+});