smooth-player 1.0.0

package/dist/SmoothPlayer.js

@@ -0,0 +1,930 @@
+import { TypedEventEmitter } from "./events.js";
+const DEFAULT_ANALYZER = {
+    fftSize: 2048,
+    smoothingTimeConstant: 0.8,
+    minDecibels: -90,
+    maxDecibels: -10,
+};
+const DEFAULT_ACCENT_COLOR = "#0ed2a4";
+const DEFAULT_PLAYLIST_ID = "default";
+const DEFAULT_PLAYLIST_TITLE = "My playlist";
+export class SmoothPlayer {
+    constructor(options = {}) {
+        this.events = new TypedEventEmitter();
+        this.playlists = [];
+        this.activePlaylistId = null;
+        this.currentTrackIndex = -1;
+        this.resolvedDuration = Number.NaN;
+        this.durationFallbackCache = new Map();
+        this.resolvingDurationSrc = null;
+        this.on = this.events.on.bind(this.events);
+        this.off = this.events.off.bind(this.events);
+        if (typeof window === "undefined") {
+            throw new Error("SmoothPlayer requires a browser environment.");
+        }
+        this.audio = options.audio ?? new Audio();
+        this.audio.crossOrigin = options.crossOrigin ?? "anonymous";
+        this.audio.autoplay = options.autoplay ?? false;
+        this.audio.loop = options.loop ?? false;
+        this.audio.preload = this.audio.preload || "metadata";
+        this.audio.volume = this.clamp(options.initialVolume ?? 1);
+        this.visualizerMode = options.visualizer ?? "spectrum";
+        this.accentColor = options.accentColor ?? DEFAULT_ACCENT_COLOR;
+        this.shuffleEnabled = options.initialShuffle ?? false;
+        this.debugEnabled = options.debug ?? false;
+        this.durationFallbackEnabled = options.durationFallback ?? true;
+        this.context = new AudioContext();
+        this.sourceNode = this.context.createMediaElementSource(this.audio);
+        this.analyser = this.context.createAnalyser();
+        this.configureAnalyzer(options.analyzer);
+        this.sourceNode.connect(this.analyser);
+        this.analyser.connect(this.context.destination);
+        this.bindAudioEvents();
+        if (options.playlist?.length) {
+            this.setPlaylist(options.playlist, options.initialTrackIndex ?? 0);
+        }
+        else {
+            this.currentTrackIndex = options.initialTrackIndex ?? -1;
+            this.emitPlaylistChange();
+        }
+        this.events.emit("ready", undefined);
+    }
+    destroy() {
+        this.audio.pause();
+        this.events.removeAllListeners();
+        void this.context.close();
+    }
+    setAccentColor(color) {
+        this.accentColor = color;
+    }
+    getAccentColor() {
+        return this.accentColor;
+    }
+    applyAccentColor(target) {
+        target.style.setProperty("--smooth-player-accent", this.accentColor);
+    }
+    setShuffle(enabled) {
+        this.shuffleEnabled = enabled;
+    }
+    getShuffle() {
+        return this.shuffleEnabled;
+    }
+    setDebug(enabled) {
+        this.debugEnabled = enabled;
+    }
+    getDebug() {
+        return this.debugEnabled;
+    }
+    setPlaylist(entries, startIndex = 0) {
+        const resolved = this.resolvePlaylists(entries);
+        this.playlists = resolved;
+        if (!resolved.length) {
+            this.activePlaylistId = null;
+            this.currentTrackIndex = -1;
+            this.audio.removeAttribute("src");
+            this.audio.load();
+            this.resolvedDuration = Number.NaN;
+            this.resolvingDurationSrc = null;
+            this.events.emit("trackchange", { index: -1, track: null });
+            this.emitPlaylistChange();
+            this.emitDurationChange();
+            this.emitTimeUpdate();
+            return;
+        }
+        const firstResolved = resolved[0];
+        if (!firstResolved)
+            return;
+        const preferred = this.activePlaylistId && resolved.some((p) => p.id === this.activePlaylistId)
+            ? this.activePlaylistId
+            : firstResolved.id;
+        this.selectPlaylist(preferred ?? firstResolved.id, startIndex);
+    }
+    selectPlaylist(playlistId, startIndex = 0) {
+        const playlist = this.playlists.find((item) => item.id === playlistId);
+        if (!playlist) {
+            throw new Error(`Playlist ${playlistId} not found.`);
+        }
+        this.activePlaylistId = playlist.id;
+        this.emitPlaylistChange();
+        if (!playlist.tracks.length) {
+            this.currentTrackIndex = -1;
+            this.events.emit("trackchange", { index: -1, track: null });
+            this.emitDurationChange();
+            this.emitTimeUpdate();
+            return;
+        }
+        const safeIndex = Math.max(0, Math.min(startIndex, playlist.tracks.length - 1));
+        this.loadTrackByIndex(safeIndex);
+    }
+    getPlaylists() {
+        return this.playlists.map((playlist) => ({
+            id: playlist.id,
+            title: playlist.title,
+            count: playlist.tracks.length,
+        }));
+    }
+    getCurrentPlaylist() {
+        const playlist = this.getActivePlaylist();
+        if (!playlist)
+            return null;
+        return { id: playlist.id, title: playlist.title, tracks: [...playlist.tracks] };
+    }
+    getPlaylist() {
+        return [...this.getActiveTracks()];
+    }
+    getCurrentTrack() {
+        return this.getActiveTracks()[this.currentTrackIndex] ?? null;
+    }
+    getCurrentTrackIndex() {
+        return this.currentTrackIndex;
+    }
+    formatTime(value) {
+        if (!Number.isFinite(value) || value < 0)
+            return "--:--";
+        const m = Math.floor(value / 60).toString().padStart(2, "0");
+        const s = Math.floor(value % 60).toString().padStart(2, "0");
+        return `${m}:${s}`;
+    }
+    mountPlaylist(container, options = {}) {
+        const settings = {
+            listRole: options.listRole ?? "listbox",
+            itemClassName: options.itemClassName ?? "smooth-player__playlist-item",
+            titleClassName: options.titleClassName ?? "smooth-player__playlist-title",
+            artistClassName: options.artistClassName ?? "smooth-player__playlist-artist",
+            selectedAriaAttr: options.selectedAriaAttr ?? "aria-current",
+            getTitle: options.getTitle ?? ((track, index) => track.metadata?.title ?? `Track ${index + 1}`),
+            getArtist: options.getArtist ?? ((track) => track.metadata?.artist ?? "Unknown artist"),
+        };
+        const onSelect = options.onSelect;
+        const render = () => {
+            container.innerHTML = "";
+            container.setAttribute("role", settings.listRole);
+            const tracks = this.getActiveTracks();
+            tracks.forEach((track, index) => {
+                const item = document.createElement("li");
+                const entry = document.createElement("div");
+                entry.className = settings.itemClassName;
+                entry.setAttribute("role", "option");
+                entry.setAttribute("tabindex", "0");
+                entry.setAttribute(settings.selectedAriaAttr, String(index === this.currentTrackIndex));
+                const icon = document.createElement("span");
+                icon.className = "smooth-player__playlist-note";
+                icon.setAttribute("aria-hidden", "true");
+                const content = document.createElement("span");
+                content.className = "smooth-player__playlist-content";
+                const title = document.createElement("span");
+                title.className = settings.titleClassName;
+                title.textContent = settings.getTitle(track, index);
+                const artist = document.createElement("span");
+                artist.className = settings.artistClassName;
+                artist.textContent = settings.getArtist(track, index);
+                content.append(title, artist);
+                entry.append(icon, content);
+                const activate = async () => {
+                    await this.play(index);
+                    onSelect?.({ index, track });
+                };
+                entry.addEventListener("click", () => {
+                    void activate();
+                });
+                entry.addEventListener("keydown", (event) => {
+                    if (event.key !== "Enter" && event.key !== " ")
+                        return;
+                    event.preventDefault();
+                    void activate();
+                });
+                item.append(entry);
+                container.append(item);
+            });
+        };
+        render();
+        const offTrackChange = this.on("trackchange", render);
+        const offPlaylistChange = this.on("playlistchange", render);
+        return () => {
+            offTrackChange();
+            offPlaylistChange();
+            container.innerHTML = "";
+        };
+    }
+    mountPlaylistSwitcher(container, options = {}) {
+        const itemClassName = options.itemClassName ?? "smooth-player__playlist-switcher-item";
+        const activeClassName = options.activeClassName ?? "is-active";
+        const onSelect = options.onSelect;
+        const doc = container.ownerDocument ?? document;
+        let isOpen = false;
+        const render = () => {
+            const playlists = this.getPlaylists();
+            container.innerHTML = "";
+            container.hidden = playlists.length <= 1;
+            if (container.hidden) {
+                isOpen = false;
+                return;
+            }
+            const currentPlaylist = this.getCurrentPlaylist();
+            const trigger = doc.createElement("button");
+            trigger.type = "button";
+            trigger.className = "smooth-player__playlist-switcher-trigger";
+            trigger.setAttribute("aria-haspopup", "listbox");
+            trigger.setAttribute("aria-expanded", String(isOpen));
+            trigger.textContent = currentPlaylist?.title ?? playlists[0]?.title ?? "Playlist";
+            const menu = doc.createElement("div");
+            menu.className = "smooth-player__playlist-switcher-menu";
+            menu.hidden = !isOpen;
+            menu.setAttribute("role", "listbox");
+            playlists.forEach((playlist) => {
+                const button = doc.createElement("button");
+                button.type = "button";
+                button.className = itemClassName;
+                button.textContent = `${playlist.title} (${playlist.count})`;
+                button.setAttribute("aria-pressed", String(playlist.id === this.activePlaylistId));
+                button.setAttribute("role", "option");
+                button.classList.toggle(activeClassName, playlist.id === this.activePlaylistId);
+                button.addEventListener("click", () => {
+                    this.selectPlaylist(playlist.id, 0);
+                    onSelect?.({ id: playlist.id, title: playlist.title });
+                    isOpen = false;
+                    render();
+                });
+                menu.append(button);
+            });
+            trigger.addEventListener("click", () => {
+                isOpen = !isOpen;
+                render();
+            });
+            container.classList.toggle("is-open", isOpen);
+            container.append(trigger, menu);
+        };
+        const onOutsidePointerDown = (event) => {
+            if (!isOpen)
+                return;
+            const target = event.target;
+            if (!(target instanceof Node))
+                return;
+            if (container.contains(target))
+                return;
+            isOpen = false;
+            render();
+        };
+        const onEscape = (event) => {
+            if (!isOpen)
+                return;
+            if (event.key !== "Escape")
+                return;
+            isOpen = false;
+            render();
+        };
+        doc.addEventListener("pointerdown", onOutsidePointerDown);
+        doc.addEventListener("keydown", onEscape);
+        render();
+        const offPlaylistChange = this.on("playlistchange", render);
+        return () => {
+            offPlaylistChange();
+            doc.removeEventListener("pointerdown", onOutsidePointerDown);
+            doc.removeEventListener("keydown", onEscape);
+            container.innerHTML = "";
+        };
+    }
+    mountPlaylistTitle(element, options = {}) {
+        const fallbackTitle = options.fallbackTitle ?? DEFAULT_PLAYLIST_TITLE;
+        const render = () => {
+            const playlist = this.getCurrentPlaylist();
+            element.textContent = playlist?.title ?? fallbackTitle;
+        };
+        render();
+        const off = this.on("playlistchange", render);
+        return () => off();
+    }
+    mountTrackInfo(titleElement, artistElement, options = {}) {
+        const unknownTitle = options.unknownTitle ?? "Unknown title";
+        const unknownArtist = options.unknownArtist ?? "Unknown artist";
+        const render = () => {
+            const track = this.getCurrentTrack();
+            titleElement.textContent = track?.metadata?.title ?? unknownTitle;
+            artistElement.textContent = track?.metadata?.artist ?? unknownArtist;
+        };
+        render();
+        const offTrackChange = this.on("trackchange", render);
+        return () => offTrackChange();
+    }
+    mountPlayButton(button, options = {}) {
+        const labelElement = options.labelElement ?? null;
+        const playLabel = options.playLabel ?? "Riproduci";
+        const pauseLabel = options.pauseLabel ?? "Pausa";
+        const render = () => {
+            const isPlaying = !this.audio.paused;
+            const label = isPlaying ? pauseLabel : playLabel;
+            button.setAttribute("aria-pressed", String(isPlaying));
+            button.setAttribute("aria-label", label);
+            if (labelElement) {
+                labelElement.textContent = label;
+            }
+        };
+        const onClick = async () => {
+            await this.toggle();
+        };
+        button.addEventListener("click", onClick);
+        render();
+        const offPlay = this.on("play", render);
+        const offPause = this.on("pause", render);
+        return () => {
+            button.removeEventListener("click", onClick);
+            offPlay();
+            offPause();
+        };
+    }
+    mountTransportControls(options) {
+        const { previousButton, nextButton } = options;
+        const onPrevious = () => this.previous();
+        const onNext = () => this.next();
+        previousButton.addEventListener("click", onPrevious);
+        nextButton.addEventListener("click", onNext);
+        return () => {
+            previousButton.removeEventListener("click", onPrevious);
+            nextButton.removeEventListener("click", onNext);
+        };
+    }
+    mountShuffleToggle(options) {
+        const { button, labelElement = null, activeClassName = "smooth-player__toggle-on", enabledLabel = "Disattiva shuffle", disabledLabel = "Attiva shuffle", initialEnabled = false, } = options;
+        const render = () => {
+            const enabled = this.getShuffle();
+            const label = enabled ? enabledLabel : disabledLabel;
+            button.setAttribute("aria-pressed", String(enabled));
+            button.setAttribute("aria-label", label);
+            button.classList.toggle(activeClassName, enabled);
+            if (labelElement) {
+                labelElement.textContent = label;
+            }
+        };
+        const toggle = () => {
+            this.setShuffle(!this.getShuffle());
+            render();
+        };
+        this.setShuffle(initialEnabled);
+        render();
+        button.addEventListener("click", toggle);
+        return () => {
+            button.removeEventListener("click", toggle);
+        };
+    }
+    mountPlaylistPanel(options) {
+        const { root, toggleButton, panel, closeButton = null, openClassName = "smooth-player--playlist-open", openLabel = "Apri playlist", closeLabel = "Chiudi playlist", } = options;
+        let isOpen = false;
+        const hasPlaylist = () => this.getPlaylists().length > 1 || this.getActiveTracks().length > 1;
+        const syncVisibility = () => {
+            toggleButton.hidden = !hasPlaylist();
+        };
+        const setOpen = (open) => {
+            if (!hasPlaylist()) {
+                isOpen = false;
+                root.classList.remove(openClassName);
+                panel.setAttribute("aria-hidden", "true");
+                toggleButton.setAttribute("aria-expanded", "false");
+                toggleButton.setAttribute("aria-label", openLabel);
+                return;
+            }
+            isOpen = open;
+            root.classList.toggle(openClassName, open);
+            panel.setAttribute("aria-hidden", String(!open));
+            toggleButton.setAttribute("aria-expanded", String(open));
+            toggleButton.setAttribute("aria-label", open ? closeLabel : openLabel);
+        };
+        const onToggle = () => setOpen(!isOpen);
+        const onClose = () => setOpen(false);
+        toggleButton.addEventListener("click", onToggle);
+        closeButton?.addEventListener("click", onClose);
+        const offPlaylistChange = this.on("playlistchange", () => {
+            syncVisibility();
+            if (!hasPlaylist())
+                setOpen(false);
+        });
+        syncVisibility();
+        setOpen(false);
+        return {
+            setOpen,
+            getOpen: () => isOpen,
+            destroy: () => {
+                offPlaylistChange();
+                toggleButton.removeEventListener("click", onToggle);
+                closeButton?.removeEventListener("click", onClose);
+            },
+        };
+    }
+    mountDebugPanel(options) {
+        const { enabled = this.debugEnabled, panel, sourceElement, currentTimeElement, durationElement, readyStateElement, networkStateElement, pausedElement, eventsElement, maxEvents = 18, } = options;
+        const events = [];
+        const log = (name) => {
+            if (!enabled)
+                return;
+            const line = `${new Date().toLocaleTimeString()} ${name} ct=${this.getCurrentTime().toFixed(2)} d=${this.getDuration().toFixed(2)}`;
+            events.unshift(line);
+            if (events.length > maxEvents)
+                events.pop();
+            eventsElement.textContent = events.join("\n");
+        };
+        const update = () => {
+            if (!enabled)
+                return;
+            sourceElement.textContent = this.audio.currentSrc || this.audio.src || "-";
+            currentTimeElement.textContent = Number.isFinite(this.getCurrentTime()) ? this.getCurrentTime().toFixed(3) : "NaN";
+            durationElement.textContent = Number.isFinite(this.getDuration()) ? this.getDuration().toFixed(3) : "NaN";
+            readyStateElement.textContent = String(this.audio.readyState);
+            networkStateElement.textContent = String(this.audio.networkState);
+            pausedElement.textContent = String(this.audio.paused);
+        };
+        panel.hidden = !enabled;
+        const offPlaylist = this.on("playlistchange", () => {
+            update();
+            log("player:playlistchange");
+        });
+        const offTrack = this.on("trackchange", () => {
+            update();
+            log("player:trackchange");
+        });
+        const offPlay = this.on("play", () => {
+            update();
+            log("player:play");
+        });
+        const offPause = this.on("pause", () => {
+            update();
+            log("player:pause");
+        });
+        const offTime = this.on("timeupdate", update);
+        const offDuration = this.on("durationchange", () => {
+            update();
+            log("player:durationchange");
+        });
+        update();
+        log("init");
+        return () => {
+            offPlaylist();
+            offTrack();
+            offPlay();
+            offPause();
+            offTime();
+            offDuration();
+        };
+    }
+    mountProgress(options) {
+        const { range, currentTimeElement = null, durationElement = null, progressRoot = null, ringElement = null, } = options;
+        let isScrubbing = false;
+        let isRingScrubbing = false;
+        const update = () => {
+            const duration = this.getDuration();
+            const currentTime = this.getCurrentTime();
+            const hasDuration = Number.isFinite(duration) && duration > 0;
+            const safeDuration = hasDuration ? duration : 0;
+            const safeCurrentTime = hasDuration
+                ? Math.max(0, Math.min(currentTime, safeDuration))
+                : Math.max(0, currentTime || 0);
+            const progressPercent = hasDuration ? (safeCurrentTime / safeDuration) * 100 : 0;
+            range.max = String(safeDuration);
+            range.value = String(safeCurrentTime);
+            range.style.setProperty("--smooth-player-progress", `${progressPercent}%`);
+            if (progressRoot) {
+                progressRoot.style.setProperty("--smooth-player-progress", `${progressPercent}%`);
+                progressRoot.style.setProperty("--smooth-player-progress-angle", `${progressPercent * 3.6}deg`);
+            }
+            if (currentTimeElement) {
+                currentTimeElement.textContent = this.formatTime(safeCurrentTime);
+            }
+            if (durationElement) {
+                durationElement.textContent = hasDuration ? this.formatTime(safeDuration) : "--:--";
+            }
+        };
+        const seekTo = (valueInSeconds) => {
+            const duration = this.getDuration();
+            if (!Number.isFinite(duration) || duration <= 0) {
+                update();
+                return;
+            }
+            const targetTime = Math.max(0, Math.min(valueInSeconds, duration));
+            this.seek(targetTime);
+            update();
+        };
+        const seekFromRingPointer = (clientX, clientY) => {
+            if (!ringElement)
+                return;
+            const duration = this.getDuration();
+            if (!Number.isFinite(duration) || duration <= 0)
+                return;
+            const rect = ringElement.getBoundingClientRect();
+            const centerX = rect.left + rect.width / 2;
+            const centerY = rect.top + rect.height / 2;
+            const dx = clientX - centerX;
+            const dy = clientY - centerY;
+            let angle = (Math.atan2(dy, dx) * 180) / Math.PI + 90;
+            if (angle < 0)
+                angle += 360;
+            seekTo((angle / 360) * duration);
+        };
+        const onRangePointerDown = () => {
+            isScrubbing = true;
+        };
+        const onRangeInput = (event) => {
+            isScrubbing = true;
+            const target = event.target;
+            if (!(target instanceof HTMLInputElement))
+                return;
+            seekTo(Number(target.value));
+        };
+        const onRangeChange = (event) => {
+            const target = event.target;
+            if (!(target instanceof HTMLInputElement))
+                return;
+            seekTo(Number(target.value));
+            isScrubbing = false;
+        };
+        const onRingPointerDown = (event) => {
+            isRingScrubbing = true;
+            seekFromRingPointer(event.clientX, event.clientY);
+        };
+        const onPointerMove = (event) => {
+            if (!isRingScrubbing)
+                return;
+            seekFromRingPointer(event.clientX, event.clientY);
+        };
+        const onPointerUp = () => {
+            isScrubbing = false;
+            isRingScrubbing = false;
+        };
+        range.addEventListener("pointerdown", onRangePointerDown);
+        range.addEventListener("input", onRangeInput);
+        range.addEventListener("change", onRangeChange);
+        if (ringElement) {
+            ringElement.addEventListener("pointerdown", onRingPointerDown);
+        }
+        window.addEventListener("pointermove", onPointerMove);
+        window.addEventListener("pointerup", onPointerUp);
+        const offTimeUpdate = this.on("timeupdate", () => {
+            if (!isScrubbing)
+                update();
+        });
+        const offDurationChange = this.on("durationchange", () => {
+            if (!isScrubbing)
+                update();
+        });
+        update();
+        return () => {
+            range.removeEventListener("pointerdown", onRangePointerDown);
+            range.removeEventListener("input", onRangeInput);
+            range.removeEventListener("change", onRangeChange);
+            if (ringElement) {
+                ringElement.removeEventListener("pointerdown", onRingPointerDown);
+            }
+            window.removeEventListener("pointermove", onPointerMove);
+            window.removeEventListener("pointerup", onPointerUp);
+            offTimeUpdate();
+            offDurationChange();
+        };
+    }
+    async play(index) {
+        if (typeof index === "number") {
+            this.loadTrackByIndex(index);
+        }
+        if (!this.audio.src) {
+            throw new Error("No track loaded. Use playlist option, setPlaylist(), or loadTrack().");
+        }
+        if (this.context.state === "suspended") {
+            await this.context.resume();
+        }
+        await this.audio.play();
+    }
+    pause() {
+        this.audio.pause();
+    }
+    toggle() {
+        if (this.audio.paused) {
+            return this.play();
+        }
+        this.pause();
+        return Promise.resolve();
+    }
+    next() {
+        const tracks = this.getActiveTracks();
+        if (!tracks.length)
+            return;
+        if (this.shuffleEnabled && tracks.length > 1) {
+            const randomIndex = this.pickRandomTrackIndex(tracks.length);
+            this.loadTrackByIndex(randomIndex);
+            void this.play();
+            return;
+        }
+        const nextIndex = this.currentTrackIndex + 1;
+        if (nextIndex >= tracks.length) {
+            this.events.emit("ended", undefined);
+            return;
+        }
+        this.loadTrackByIndex(nextIndex);
+        void this.play();
+    }
+    previous() {
+        const tracks = this.getActiveTracks();
+        if (!tracks.length)
+            return;
+        const prevIndex = Math.max(this.currentTrackIndex - 1, 0);
+        this.loadTrackByIndex(prevIndex);
+        void this.play();
+    }
+    setLoop(loop) {
+        this.audio.loop = loop;
+    }
+    setVolume(volume) {
+        const safeVolume = this.clamp(volume);
+        this.audio.volume = safeVolume;
+        this.events.emit("volumechange", { volume: safeVolume });
+    }
+    seek(seconds) {
+        const duration = this.getDuration();
+        const safeSeconds = Number.isFinite(duration) && duration > 0
+            ? Math.max(0, Math.min(seconds, duration))
+            : Math.max(0, seconds);
+        this.audio.currentTime = safeSeconds;
+        this.emitTimeUpdate();
+    }
+    loadTrack(track) {
+        const playlist = this.getActivePlaylist();
+        if (!playlist) {
+            this.setPlaylist([track], 0);
+            return;
+        }
+        const existingIndex = playlist.tracks.findIndex((item) => item.id === track.id);
+        if (existingIndex >= 0) {
+            this.loadTrackByIndex(existingIndex);
+            return;
+        }
+        playlist.tracks.push(track);
+        this.loadTrackByIndex(playlist.tracks.length - 1);
+        this.emitPlaylistChange();
+    }
+    getState() {
+        const playlist = this.getActivePlaylist();
+        return {
+            currentTrackIndex: this.currentTrackIndex,
+            isPlaying: !this.audio.paused,
+            duration: this.getDuration(),
+            currentTime: this.audio.currentTime,
+            volume: this.audio.volume,
+            loop: this.audio.loop,
+            playlistId: playlist?.id ?? null,
+            playlistTitle: playlist?.title ?? DEFAULT_PLAYLIST_TITLE,
+            playlistCount: this.playlists.length,
+            visualizer: this.visualizerMode,
+            accentColor: this.accentColor,
+            shuffle: this.shuffleEnabled,
+        };
+    }
+    getAudioElement() {
+        return this.audio;
+    }
+    getCurrentTime() {
+        return this.audio.currentTime;
+    }
+    getDuration() {
+        const nativeDuration = this.audio.duration;
+        if (Number.isFinite(nativeDuration) && nativeDuration > 0) {
+            return nativeDuration;
+        }
+        if (Number.isFinite(this.resolvedDuration) && this.resolvedDuration > 0) {
+            return this.resolvedDuration;
+        }
+        return 0;
+    }
+    getSpectrumData() {
+        const data = new Uint8Array(this.analyser.frequencyBinCount);
+        if (this.visualizerMode !== "spectrum") {
+            return data;
+        }
+        this.analyser.getByteFrequencyData(data);
+        return data;
+    }
+    getWaveformData() {
+        const data = new Uint8Array(this.analyser.fftSize);
+        if (this.visualizerMode !== "waveform") {
+            return data;
+        }
+        this.analyser.getByteTimeDomainData(data);
+        return data;
+    }
+    setVisualizer(mode) {
+        this.visualizerMode = mode;
+    }
+    getVisualizer() {
+        return this.visualizerMode;
+    }
+    configureAnalyzer(options = {}) {
+        const config = { ...DEFAULT_ANALYZER, ...options };
+        this.analyser.fftSize = config.fftSize;
+        this.analyser.smoothingTimeConstant = config.smoothingTimeConstant;
+        this.analyser.minDecibels = config.minDecibels;
+        this.analyser.maxDecibels = config.maxDecibels;
+    }
+    getActivePlaylist() {
+        if (!this.activePlaylistId)
+            return null;
+        return this.playlists.find((playlist) => playlist.id === this.activePlaylistId) ?? null;
+    }
+    getActiveTracks() {
+        return this.getActivePlaylist()?.tracks ?? [];
+    }
+    loadTrackByIndex(index) {
+        const tracks = this.getActiveTracks();
+        const track = tracks[index];
+        if (!track) {
+            throw new Error(`Track index ${index} out of bounds.`);
+        }
+        this.currentTrackIndex = index;
+        this.audio.src = track.src;
+        this.audio.load();
+        this.resolvedDuration = Number.NaN;
+        this.resolvingDurationSrc = null;
+        this.events.emit("trackchange", { index, track });
+        this.emitDurationChange();
+        this.emitTimeUpdate();
+        this.syncDurationFromAudio();
+    }
+    emitPlaylistChange() {
+        const playlist = this.getActivePlaylist();
+        this.events.emit("playlistchange", {
+            id: playlist?.id ?? null,
+            title: playlist?.title ?? DEFAULT_PLAYLIST_TITLE,
+            index: this.currentTrackIndex,
+        });
+    }
+    bindAudioEvents() {
+        this.audio.addEventListener("play", () => this.events.emit("play", undefined));
+        this.audio.addEventListener("pause", () => this.events.emit("pause", undefined));
+        this.audio.addEventListener("loadedmetadata", () => this.syncDurationFromAudio());
+        this.audio.addEventListener("durationchange", () => this.syncDurationFromAudio());
+        this.audio.addEventListener("canplay", () => this.syncDurationFromAudio());
+        this.audio.addEventListener("loadeddata", () => this.syncDurationFromAudio());
+        this.audio.addEventListener("seeked", () => this.emitTimeUpdate());
+        this.audio.addEventListener("timeupdate", () => this.emitTimeUpdate());
+        this.audio.addEventListener("ended", () => {
+            if (this.getActiveTracks().length > 1 && !this.audio.loop) {
+                this.next();
+                return;
+            }
+            this.events.emit("ended", undefined);
+        });
+        this.audio.addEventListener("error", () => {
+            this.events.emit("error", {
+                error: new Error("Audio playback failed."),
+            });
+        });
+    }
+    clamp(value) {
+        return Math.min(1, Math.max(0, value));
+    }
+    pickRandomTrackIndex(length) {
+        if (length <= 1)
+            return 0;
+        let randomIndex = this.currentTrackIndex;
+        while (randomIndex === this.currentTrackIndex) {
+            randomIndex = Math.floor(Math.random() * length);
+        }
+        return randomIndex;
+    }
+    emitTimeUpdate() {
+        this.events.emit("timeupdate", {
+            currentTime: this.audio.currentTime,
+            duration: this.getDuration(),
+        });
+    }
+    emitDurationChange() {
+        this.events.emit("durationchange", { duration: this.getDuration() });
+    }
+    syncDurationFromAudio() {
+        const nativeDuration = this.audio.duration;
+        if (Number.isFinite(nativeDuration) && nativeDuration > 0) {
+            this.resolvedDuration = nativeDuration;
+            this.emitDurationChange();
+            this.emitTimeUpdate();
+            return;
+        }
+        if (!this.durationFallbackEnabled) {
+            this.emitDurationChange();
+            this.emitTimeUpdate();
+            return;
+        }
+        void this.resolveDurationFallback();
+    }
+    async resolveDurationFallback() {
+        const track = this.getCurrentTrack();
+        const src = track?.src ?? this.audio.currentSrc ?? this.audio.src;
+        if (!src)
+            return;
+        if (this.durationFallbackCache.has(src)) {
+            this.resolvedDuration = this.durationFallbackCache.get(src) ?? Number.NaN;
+            this.emitDurationChange();
+            this.emitTimeUpdate();
+            return;
+        }
+        if (this.resolvingDurationSrc === src) {
+            return;
+        }
+        this.resolvingDurationSrc = src;
+        try {
+            const response = await fetch(src);
+            if (!response.ok) {
+                return;
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            const decoded = await this.context.decodeAudioData(arrayBuffer.slice(0));
+            const duration = decoded.duration;
+            if (!Number.isFinite(duration) || duration <= 0) {
+                return;
+            }
+            if (src !== (this.getCurrentTrack()?.src ?? this.audio.currentSrc ?? this.audio.src)) {
+                return;
+            }
+            this.durationFallbackCache.set(src, duration);
+            this.resolvedDuration = duration;
+            this.emitDurationChange();
+            this.emitTimeUpdate();
+        }
+        catch {
+            // ignore: keep unresolved duration when decode fails
+        }
+        finally {
+            if (this.resolvingDurationSrc === src) {
+                this.resolvingDurationSrc = null;
+            }
+        }
+    }
+    resolvePlaylists(entries) {
+        if (!entries.length)
+            return [];
+        const namedPlaylists = [];
+        const directRootTracks = this.collectDirectTracks(entries);
+        if (directRootTracks.length) {
+            namedPlaylists.push({
+                id: DEFAULT_PLAYLIST_ID,
+                title: DEFAULT_PLAYLIST_TITLE,
+                tracks: directRootTracks,
+            });
+        }
+        this.collectNestedPlaylists(entries, namedPlaylists);
+        if (!namedPlaylists.length) {
+            const fallbackTracks = this.flattenTracks(entries);
+            if (!fallbackTracks.length)
+                return [];
+            namedPlaylists.push({
+                id: DEFAULT_PLAYLIST_ID,
+                title: DEFAULT_PLAYLIST_TITLE,
+                tracks: fallbackTracks,
+            });
+        }
+        return this.dedupePlaylistIds(namedPlaylists);
+    }
+    collectDirectTracks(entries) {
+        const tracks = [];
+        for (const entry of entries) {
+            if (!this.isAudioPlaylist(entry)) {
+                tracks.push(entry);
+            }
+        }
+        return tracks;
+    }
+    flattenTracks(entries) {
+        const tracks = [];
+        for (const entry of entries) {
+            if (this.isAudioPlaylist(entry)) {
+                tracks.push(...this.flattenTracks(entry.tracks));
+            }
+            else {
+                tracks.push(entry);
+            }
+        }
+        return tracks;
+    }
+    collectNestedPlaylists(entries, target) {
+        for (const entry of entries) {
+            if (!this.isAudioPlaylist(entry))
+                continue;
+            const tracks = this.flattenTracks(entry.tracks);
+            if (tracks.length) {
+                target.push({ id: entry.id, title: entry.title, tracks });
+            }
+            this.collectNestedPlaylists(entry.tracks, target);
+        }
+    }
+    dedupePlaylistIds(playlists) {
+        const seen = new Set();
+        const deduped = [];
+        for (const playlist of playlists) {
+            let id = playlist.id || DEFAULT_PLAYLIST_ID;
+            if (seen.has(id)) {
+                let suffix = 2;
+                while (seen.has(`${id}-${suffix}`))
+                    suffix += 1;
+                id = `${id}-${suffix}`;
+            }
+            seen.add(id);
+            deduped.push({ ...playlist, id });
+        }
+        return deduped;
+    }
+    isAudioPlaylist(entry) {
+        return "tracks" in entry && Array.isArray(entry.tracks);
+    }
+}