wavesurfer.js 7.0.0-alpha.2 → 7.0.0-alpha.21

package/dist/plugins/envelope.d.ts

@@ -0,0 +1,58 @@
+import BasePlugin from '../base-plugin.js';
+import type { WaveSurferPluginParams } from '../index.js';
+export type EnvelopePluginOptions = {
+    startTime?: number;
+    endTime?: number;
+    fadeInEnd?: number;
+    fadeOutStart?: number;
+    volume?: number;
+    lineWidth?: string;
+    lineColor?: string;
+    dragPointSize?: number;
+    dragPointFill?: string;
+    dragPointStroke?: string;
+};
+declare const defaultOptions: {
+    startTime: number;
+    endTime: number;
+    fadeInEnd: number;
+    fadeOutStart: number;
+    lineWidth: number;
+    lineColor: string;
+    dragPointSize: number;
+    dragPointFill: string;
+    dragPointStroke: string;
+};
+export type EnvelopePluginEvents = {
+    'fade-in-change': {
+        time: number;
+    };
+    'fade-out-change': {
+        time: number;
+    };
+    'volume-change': {
+        volume: number;
+    };
+};
+declare class EnvelopePlugin extends BasePlugin<EnvelopePluginEvents, EnvelopePluginOptions> {
+    protected options: EnvelopePluginOptions & typeof defaultOptions;
+    private svg;
+    private audioContext;
+    private gainNode;
+    private volume;
+    private isFadingIn;
+    private isFadingOut;
+    constructor(params: WaveSurferPluginParams, options: EnvelopePluginOptions);
+    private makeDraggable;
+    private renderPolyline;
+    private initSvg;
+    destroy(): void;
+    private initWebAudio;
+    private naturalVolume;
+    private onVolumeChange;
+    private initFadeEffects;
+    getCurrentVolume(): number;
+    setStartTime(time: number): void;
+    setEndTime(time: number): void;
+}
+export default EnvelopePlugin;

package/dist/plugins/envelope.js

@@ -0,0 +1,292 @@
+import BasePlugin from '../base-plugin.js';
+const defaultOptions = {
+    startTime: 0,
+    endTime: 0,
+    fadeInEnd: 0,
+    fadeOutStart: 0,
+    lineWidth: 4,
+    lineColor: 'rgba(0, 0, 255, 0.5)',
+    dragPointSize: 10,
+    dragPointFill: 'rgba(255, 255, 255, 0.8)',
+    dragPointStroke: 'rgba(255, 255, 255, 0.8)',
+};
+class EnvelopePlugin extends BasePlugin {
+    options;
+    svg = null;
+    audioContext = null;
+    gainNode = null;
+    volume = 1;
+    isFadingIn = false;
+    isFadingOut = false;
+    constructor(params, options) {
+        super(params, options);
+        this.options = Object.assign({}, defaultOptions, options);
+        this.options.lineColor = this.options.lineColor || defaultOptions.lineColor;
+        this.options.dragPointFill = this.options.dragPointFill || defaultOptions.dragPointFill;
+        this.options.dragPointStroke = this.options.dragPointStroke || defaultOptions.dragPointStroke;
+        this.volume = this.options.volume ?? 1;
+        this.subscriptions.push(this.wavesurfer.once('decode', ({ duration }) => {
+            this.options.startTime = this.options.startTime || 0;
+            this.options.endTime = this.options.endTime || duration;
+            this.options.fadeInEnd = this.options.fadeInEnd || this.options.startTime;
+            this.options.fadeOutStart = this.options.fadeOutStart || this.options.endTime;
+            this.initWebAudio();
+            this.initSvg();
+            this.initFadeEffects();
+        }));
+        let delay;
+        this.subscriptions.push(this.wavesurfer.on('zoom', () => {
+            if (delay)
+                clearTimeout(delay);
+            delay = setTimeout(() => {
+                this.svg?.remove();
+                this.initSvg();
+            }, 100);
+        }));
+    }
+    makeDraggable(draggable, onDrag) {
+        draggable.addEventListener('mousedown', (e) => {
+            let x = e.clientX;
+            let y = e.clientY;
+            const wasInteractive = this.wavesurfer.options.interactive;
+            let delay;
+            // Make the wavesurfer ignore clicks when we're dragging
+            this.wavesurfer.toggleInteractive(false);
+            const move = (e) => {
+                const dx = e.clientX - x;
+                const dy = e.clientY - y;
+                x = e.clientX;
+                y = e.clientY;
+                onDrag(dx, dy);
+            };
+            const up = () => {
+                document.removeEventListener('mousemove', move);
+                document.removeEventListener('mouseup', up);
+                // Restore interactive state
+                if (delay)
+                    clearTimeout(delay);
+                delay = setTimeout(() => {
+                    this.wavesurfer.toggleInteractive(wasInteractive);
+                }, 100);
+            };
+            document.addEventListener('mousemove', move);
+            document.addEventListener('mouseup', up);
+            e.preventDefault();
+            e.stopPropagation();
+        });
+    }
+    renderPolyline() {
+        if (!this.svg)
+            return;
+        const polyline = this.svg.querySelector('polyline');
+        const points = polyline.points;
+        const top = points.getItem(1).y;
+        const width = this.wrapper.clientWidth;
+        const duration = this.wavesurfer.getDuration();
+        points.getItem(0).x = (this.options.startTime / duration) * width;
+        points.getItem(3).x = (this.options.endTime / duration) * width;
+        const line = this.svg.querySelector('line');
+        line.setAttribute('x1', points.getItem(1).x.toString());
+        line.setAttribute('x2', points.getItem(2).x.toString());
+        line.setAttribute('y1', top.toString());
+        line.setAttribute('y2', top.toString());
+        const circles = this.svg.querySelectorAll('circle');
+        for (let i = 0; i < circles.length; i++) {
+            const circle = circles[i];
+            const point = polyline.points.getItem(i + 1);
+            circle.setAttribute('cx', point.x.toString());
+            circle.setAttribute('cy', top.toString());
+        }
+    }
+    initSvg() {
+        const width = this.wrapper.clientWidth;
+        const height = this.wrapper.clientHeight;
+        const duration = this.wavesurfer.getDuration();
+        // SVG element
+        const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+        svg.setAttribute('width', '100%');
+        svg.setAttribute('height', '100%');
+        svg.setAttribute('viewBox', `0 0 ${width} ${height}`);
+        svg.setAttribute('preserveAspectRatio', 'none');
+        svg.setAttribute('style', 'position: absolute; left: 0; top: 0; z-index: 4; pointer-events: none;');
+        this.svg = svg;
+        // A polyline representing the envelope
+        const polyline = document.createElementNS('http://www.w3.org/2000/svg', 'polyline');
+        polyline.setAttribute('points', '0,0 0,0 0,0 0,0');
+        polyline.setAttribute('stroke', this.options.lineColor);
+        polyline.setAttribute('stroke-width', this.options.lineWidth);
+        polyline.setAttribute('fill', 'none');
+        polyline.setAttribute('style', 'pointer-events: none');
+        svg.appendChild(polyline);
+        // Draggable top line
+        const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
+        line.setAttribute('stroke', 'none');
+        line.setAttribute('stroke-width', (this.options.lineWidth * 3).toString());
+        line.setAttribute('style', 'cursor: ns-resize; pointer-events: all;');
+        svg.appendChild(line);
+        const points = polyline.points;
+        const offset = this.options.dragPointSize / 2;
+        const top = height - this.volume * height + offset;
+        points.getItem(0).x = (this.options.startTime / duration) * width;
+        points.getItem(0).y = height;
+        points.getItem(1).x = (this.options.fadeInEnd / duration) * width;
+        points.getItem(1).y = top;
+        points.getItem(2).x = (this.options.fadeOutStart / duration) * width;
+        points.getItem(2).y = top;
+        points.getItem(3).x = (this.options.endTime / duration) * width;
+        points.getItem(3).y = height;
+        // Drag points
+        const dragPoints = [1, 2];
+        dragPoints.forEach(() => {
+            const circle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+            circle.setAttribute('r', (this.options.dragPointSize / 2).toString());
+            circle.setAttribute('fill', this.options.dragPointFill);
+            circle.setAttribute('stroke', this.options.dragPointStroke || this.options.dragPointFill);
+            circle.setAttribute('stroke-width', '2');
+            circle.setAttribute('style', 'cursor: ew-resize; pointer-events: all;');
+            svg.appendChild(circle);
+        });
+        this.wrapper.appendChild(svg);
+        // Initial polyline
+        this.renderPolyline();
+        // On top line drag
+        const onDragY = (dy) => {
+            const newTop = points.getItem(1).y + dy - offset;
+            if (newTop < -0.5 || newTop > height)
+                return;
+            points.getItem(1).y = newTop + offset;
+            points.getItem(2).y = newTop + offset;
+            this.renderPolyline();
+            const newVolume = Math.min(1, Math.max(0, (height - newTop) / height));
+            this.onVolumeChange(newVolume);
+            this.renderPolyline();
+        };
+        // On points drag
+        const onDragX = (dx, dy, index) => {
+            const point = polyline.points.getItem(index);
+            const newX = point.x + dx;
+            const newTime = (newX / width) * duration;
+            if ((index === 1 && newTime > this.options.fadeOutStart) || newTime < this.options.startTime)
+                return;
+            if ((index === 2 && newTime < this.options.fadeInEnd) || newTime > this.options.endTime)
+                return;
+            point.x = newX;
+            if (index === 1) {
+                this.options.fadeInEnd = newTime;
+                this.emit('fade-in-change', { time: newTime });
+            }
+            else if (index === 2) {
+                this.options.fadeOutStart = newTime;
+                this.emit('fade-out-change', { time: newTime });
+            }
+            // Also allow dragging points vertically
+            if (dy > 1) {
+                onDragY(dy);
+            }
+            else {
+                this.renderPolyline();
+            }
+        };
+        // Draggable top line of the polyline
+        this.makeDraggable(line, (_, dy) => onDragY(dy));
+        // Make each point draggable
+        const draggables = svg.querySelectorAll('circle');
+        for (let i = 0; i < draggables.length; i++) {
+            const index = i + 1;
+            this.makeDraggable(draggables[i], (dx, dy) => onDragX(dx, dy, index));
+        }
+    }
+    destroy() {
+        this.svg?.remove();
+        super.destroy();
+    }
+    initWebAudio() {
+        const audio = this.wavesurfer.getMediaElement();
+        if (!audio)
+            return null;
+        this.volume = this.options.volume ?? audio.volume;
+        // Create an AudioContext
+        const audioContext = new window.AudioContext();
+        // Create a GainNode for controlling the volume
+        this.gainNode = audioContext.createGain();
+        this.gainNode.gain.value = this.volume;
+        // Create a MediaElementAudioSourceNode using the audio element
+        const source = audioContext.createMediaElementSource(audio);
+        // Connect the source to the GainNode, and the GainNode to the destination (speakers)
+        source.connect(this.gainNode);
+        this.gainNode.connect(audioContext.destination);
+        this.audioContext = audioContext;
+    }
+    naturalVolume(value) {
+        const minValue = 0.0001;
+        const maxValue = 1;
+        const exponent = 3; // Adjust the exponent to change the curve of the volume control
+        const interpolatedValue = minValue + (maxValue - minValue) * Math.pow(value, exponent);
+        return interpolatedValue;
+    }
+    onVolumeChange(volume) {
+        volume = this.naturalVolume(volume);
+        this.volume = volume;
+        this.emit('volume-change', { volume });
+        if (!this.gainNode)
+            return;
+        this.gainNode.gain.value = volume;
+    }
+    initFadeEffects() {
+        if (!this.audioContext)
+            return;
+        const unsub = this.wavesurfer.on('timeupdate', ({ currentTime }) => {
+            if (!this.audioContext || !this.gainNode)
+                return;
+            if (!this.wavesurfer.isPlaying())
+                return;
+            if (this.audioContext.state === 'suspended') {
+                this.audioContext.resume();
+            }
+            // Fade in
+            if (!this.isFadingIn && currentTime >= this.options.startTime && currentTime <= this.options.fadeInEnd) {
+                this.isFadingIn = true;
+                // Set the initial gain (volume) to 0 (silent)
+                this.gainNode.gain.setValueAtTime(0, this.audioContext.currentTime);
+                // Set the target gain (volume) to 1 (full volume) over N seconds
+                this.gainNode.gain.linearRampToValueAtTime(this.volume, this.audioContext.currentTime + (this.options.fadeInEnd - currentTime));
+                return;
+            }
+            // Fade out
+            if (!this.isFadingOut && currentTime >= this.options.fadeOutStart && currentTime <= this.options.endTime) {
+                this.isFadingOut = true;
+                // Set the target gain (volume) to 0 (silent) over N seconds
+                this.gainNode.gain.linearRampToValueAtTime(0, this.audioContext.currentTime + (this.options.endTime - currentTime));
+                return;
+            }
+            // Reset fade in/out
+            let cancelRamp = false;
+            if (this.isFadingIn && (currentTime < this.options.startTime || currentTime > this.options.fadeInEnd)) {
+                this.isFadingIn = false;
+                cancelRamp = true;
+            }
+            if (this.isFadingOut && (currentTime < this.options.fadeOutStart || currentTime >= this.options.endTime)) {
+                this.isFadingOut = false;
+                cancelRamp = true;
+            }
+            if (cancelRamp) {
+                this.gainNode.gain.cancelScheduledValues(this.audioContext.currentTime);
+                this.gainNode.gain.value = this.volume;
+            }
+        });
+        this.subscriptions.push(unsub);
+    }
+    getCurrentVolume() {
+        return this.gainNode ? this.gainNode.gain.value : this.volume;
+    }
+    setStartTime(time) {
+        this.options.startTime = time;
+        console.log(time);
+        this.renderPolyline();
+    }
+    setEndTime(time) {
+        this.options.endTime = time;
+        this.renderPolyline();
+    }
+}
+export default EnvelopePlugin;

package/dist/plugins/minimap.d.ts

@@ -0,0 +1,25 @@
+import BasePlugin from '../base-plugin.js';
+import { type WaveSurferPluginParams, type WaveSurferOptions } from '../index.js';
+export type MinimapPluginOptions = {
+    overlayColor?: string;
+} & WaveSurferOptions;
+declare const defaultOptions: {
+    height: number;
+    overlayColor: string;
+};
+export type MinimapPluginEvents = {
+    ready: void;
+};
+declare class TimelinePlugin extends BasePlugin<MinimapPluginEvents, MinimapPluginOptions> {
+    protected options: MinimapPluginOptions & typeof defaultOptions;
+    private minimapWrapper;
+    private miniWavesurfer;
+    private overlay;
+    constructor(params: WaveSurferPluginParams, options: MinimapPluginOptions);
+    private initMinimapWrapper;
+    private initOverlay;
+    private initMinimap;
+    /** Unmount */
+    destroy(): void;
+}
+export default TimelinePlugin;

package/dist/plugins/minimap.js

@@ -0,0 +1,63 @@
+import BasePlugin from '../base-plugin.js';
+import WaveSurfer from '../index.js';
+const defaultOptions = {
+    height: 50,
+    overlayColor: 'rgba(100, 100, 100, 0.1)',
+};
+class TimelinePlugin extends BasePlugin {
+    options;
+    minimapWrapper;
+    miniWavesurfer = null;
+    overlay;
+    constructor(params, options) {
+        super(params, options);
+        this.options = Object.assign({}, defaultOptions, options);
+        this.minimapWrapper = this.initMinimapWrapper();
+        this.overlay = this.initOverlay();
+        this.subscriptions.push(this.wavesurfer.on('decode', () => {
+            this.initMinimap();
+        }));
+    }
+    initMinimapWrapper() {
+        const div = document.createElement('div');
+        div.style.position = 'relative';
+        this.container.insertAdjacentElement('afterend', div);
+        return div;
+    }
+    initOverlay() {
+        const div = document.createElement('div');
+        div.setAttribute('style', 'position: absolute; z-index: 2; left: 0; top: 0; bottom: 0;');
+        div.style.backgroundColor = this.options.overlayColor;
+        this.minimapWrapper.appendChild(div);
+        return div;
+    }
+    initMinimap() {
+        const data = this.wavesurfer.getDecodedData();
+        const media = this.wavesurfer.getMediaElement();
+        if (!data || !media)
+            return;
+        this.miniWavesurfer = WaveSurfer.create({
+            ...this.options,
+            container: this.minimapWrapper,
+            minPxPerSec: 1,
+            fillParent: true,
+            media,
+            url: media.src,
+            peaks: [data.getChannelData(0)],
+            duration: data.duration,
+        });
+        const overlayWidth = Math.round((this.minimapWrapper.clientWidth / this.wrapper.clientWidth) * 100);
+        this.overlay.style.width = `${overlayWidth}%`;
+        this.wavesurfer.on('timeupdate', ({ currentTime }) => {
+            const offset = Math.max(0, Math.min((currentTime / this.wavesurfer.getDuration()) * 100 - overlayWidth / 2, 100 - overlayWidth)).toFixed(2);
+            this.overlay.style.left = `${offset}%`;
+        });
+    }
+    /** Unmount */
+    destroy() {
+        this.miniWavesurfer?.destroy();
+        this.minimapWrapper.remove();
+        super.destroy();
+    }
+}
+export default TimelinePlugin;

package/dist/plugins/multitrack.d.ts

@@ -0,0 +1,111 @@
+import { type WaveSurferOptions } from '../index.js';
+import { type EnvelopePluginOptions } from './envelope.js';
+import EventEmitter from '../event-emitter.js';
+export type TrackId = string | number;
+export type TrackOptions = {
+    id: TrackId;
+    url?: string;
+    peaks?: WaveSurferOptions['peaks'];
+    draggable?: boolean;
+    startPosition: number;
+    startCue?: number;
+    endCue?: number;
+    fadeInEnd?: number;
+    fadeOutStart?: number;
+    volume?: number;
+    markers?: Array<{
+        time: number;
+        label?: string;
+        color?: string;
+    }>;
+    intro?: {
+        endTime: number;
+        label?: string;
+        color?: string;
+    };
+    options?: WaveSurferOptions;
+};
+export type MultitrackOptions = {
+    container: HTMLElement;
+    minPxPerSec?: number;
+    cursorColor?: string;
+    cursorWidth?: number;
+    trackBackground?: string;
+    trackBorderColor?: string;
+    rightButtonDrag?: boolean;
+    envelopeOptions?: EnvelopePluginOptions;
+};
+export type MultitrackEvents = {
+    canplay: void;
+    'start-position-change': {
+        id: TrackId;
+        startPosition: number;
+    };
+    'start-cue-change': {
+        id: TrackId;
+        startCue: number;
+    };
+    'end-cue-change': {
+        id: TrackId;
+        endCue: number;
+    };
+    'fade-in-change': {
+        id: TrackId;
+        fadeInEnd: number;
+    };
+    'fade-out-change': {
+        id: TrackId;
+        fadeOutStart: number;
+    };
+    'volume-change': {
+        id: TrackId;
+        volume: number;
+    };
+    'intro-end-change': {
+        id: TrackId;
+        endTime: number;
+    };
+    drop: {
+        id: TrackId;
+    };
+};
+export type MultitrackTracks = Array<TrackOptions>;
+declare class MultiTrack extends EventEmitter<MultitrackEvents> {
+    private tracks;
+    private options;
+    private audios;
+    private wavesurfers;
+    private durations;
+    private currentTime;
+    private maxDuration;
+    private rendering;
+    private isDragging;
+    private frameRequest;
+    private timer;
+    private subscriptions;
+    private timeline;
+    static create(tracks: MultitrackTracks, options: MultitrackOptions): MultiTrack;
+    constructor(tracks: MultitrackTracks, options: MultitrackOptions);
+    private initDurations;
+    private initAudio;
+    private initAllAudios;
+    private initWavesurfer;
+    private initAllWavesurfers;
+    private initTimeline;
+    private updatePosition;
+    private setIsDragging;
+    private onDrag;
+    private onMove;
+    private findCurrentTracks;
+    private startSync;
+    play(): void;
+    pause(): void;
+    isPlaying(): boolean;
+    getCurrentTime(): number;
+    seekTo(time: number): void;
+    zoom(pxPerSec: number): void;
+    addTrack(track: TrackOptions): void;
+    destroy(): void;
+    setSinkId(sinkId: string): Promise<void[]>;
+}
+export default MultiTrack;