@will-ui/vue 1.0.0

package/dist/use/useAudioPlayer.js

@@ -0,0 +1,799 @@
+import { computed, onUnmounted, ref, toValue, watch } from "vue";
+//#region use/useAudioPlayer.ts
+var PLAY_MODES = [
+	"sequential",
+	"random",
+	"single-loop",
+	"list-loop"
+];
+var clamp = (value, min, max) => {
+	if (!Number.isFinite(value)) return min;
+	return Math.min(Math.max(value, min), max);
+};
+var normalizePercentInput = (value) => {
+	const safeValue = Number.isFinite(value) ? value : 0;
+	return clamp(safeValue <= 1 ? safeValue * 100 : safeValue, 0, 100);
+};
+var createId = (prefix) => {
+	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+};
+var formatAudioTime = (seconds) => {
+	if (!Number.isFinite(seconds) || seconds < 0) return "00:00";
+	const totalSeconds = Math.floor(seconds);
+	const hour = Math.floor(totalSeconds / 3600);
+	const minute = Math.floor(totalSeconds % 3600 / 60);
+	const second = totalSeconds % 60;
+	if (hour > 0) return [
+		hour,
+		minute,
+		second
+	].map((item) => String(item).padStart(2, "0")).join(":");
+	return [minute, second].map((item) => String(item).padStart(2, "0")).join(":");
+};
+var normalizeTrack = (track, fallbackId) => {
+	return {
+		...track,
+		id: track.id != null ? String(track.id) : fallbackId
+	};
+};
+var normalizePlaylist = (playlist, playlistIndex) => {
+	const playlistId = playlist.id != null ? String(playlist.id) : `playlist-${playlistIndex}`;
+	return {
+		...playlist,
+		id: playlistId,
+		tracks: (playlist.tracks || []).map((track, trackIndex) => normalizeTrack(track, `${playlistId}-track-${trackIndex}`))
+	};
+};
+var clonePlaylists = (playlists) => {
+	return playlists.map((playlist) => ({
+		...playlist,
+		tracks: playlist.tracks.map((track) => ({ ...track }))
+	}));
+};
+function useAudioPlayer(options = {}) {
+	const { defaultVolume = 100, defaultMuted = false, onPlay, onPause, onEnded, onTimeUpdate, onVolumeChange, onTrackChange, onPlaylistChange, onPlaylistsChange, onPlayModeChange, onLoaded, onError, onUpdateActivePlaylistId, onUpdateActiveTrackId, onUpdatePlayMode } = options;
+	const getPlaylists = () => toValue(options.playlists) ?? [];
+	const getSource = () => toValue(options.source) ?? null;
+	const getActivePlaylistId = () => toValue(options.activePlaylistId);
+	const getActiveTrackId = () => toValue(options.activeTrackId);
+	const getPlayMode = () => toValue(options.playMode) ?? "sequential";
+	const getAutoplay = () => toValue(options.autoplay) ?? false;
+	const getPreload = () => toValue(options.preload) ?? "metadata";
+	const audioElement = typeof Audio !== "undefined" ? new Audio() : null;
+	if (audioElement) {
+		audioElement.preload = getPreload();
+		audioElement.volume = clamp(defaultVolume, 0, 100) / 100;
+		audioElement.muted = defaultMuted;
+	}
+	const playlists = ref(getPlaylists().map((item, index) => normalizePlaylist(item, index)));
+	const directTrack = ref(null);
+	const playbackContext = ref(getSource() ? "direct" : "playlist");
+	const currentPlaylistId = ref(getActivePlaylistId() != null ? String(getActivePlaylistId()) : null);
+	const currentTrackId = ref(getActiveTrackId() != null ? String(getActiveTrackId()) : null);
+	const playMode = ref(PLAY_MODES.includes(getPlayMode()) ? getPlayMode() : "sequential");
+	const isReady = ref(false);
+	const isPlaying = ref(false);
+	const isLoading = ref(false);
+	const isMuted = ref(defaultMuted);
+	const isSeeking = ref(false);
+	const currentTime = ref(0);
+	const duration = ref(0);
+	const bufferedTime = ref(0);
+	const volumePercent = ref(clamp(defaultVolume, 0, 100));
+	const lastVolumeBeforeMute = ref(volumePercent.value || 100);
+	const seekPreviewPercent = ref(0);
+	const seekPreviewTime = ref(0);
+	const errorMessage = ref("");
+	const currentObjectUrl = ref(null);
+	/** 用于取消过期的 load/play，避免切歌时 play 被 pause 打断报错 */
+	let loadSession = 0;
+	const currentPlaylist = computed(() => {
+		if (playbackContext.value !== "playlist") return null;
+		return playlists.value.find((item) => item.id === currentPlaylistId.value) || null;
+	});
+	const currentTrackIndex = computed(() => {
+		if (playbackContext.value !== "playlist" || !currentPlaylist.value) return -1;
+		return currentPlaylist.value.tracks.findIndex((item) => item.id === currentTrackId.value);
+	});
+	const currentTrack = computed(() => {
+		if (playbackContext.value === "direct") return directTrack.value;
+		if (!currentPlaylist.value) return null;
+		return currentPlaylist.value.tracks.find((item) => item.id === currentTrackId.value) || null;
+	});
+	const hasTrack = computed(() => Boolean(currentTrack.value));
+	const progressPercent = computed(() => {
+		if (!duration.value) return 0;
+		return clamp(currentTime.value / duration.value * 100, 0, 100);
+	});
+	const displayProgressPercent = computed(() => {
+		return isSeeking.value ? seekPreviewPercent.value : progressPercent.value;
+	});
+	const displayCurrentTime = computed(() => {
+		return isSeeking.value ? seekPreviewTime.value : currentTime.value;
+	});
+	const bufferedPercent = computed(() => {
+		if (!duration.value) return 0;
+		return clamp(bufferedTime.value / duration.value * 100, 0, 100);
+	});
+	const formattedCurrentTime = computed(() => formatAudioTime(currentTime.value));
+	const formattedDuration = computed(() => formatAudioTime(duration.value));
+	const formattedDisplayCurrentTime = computed(() => formatAudioTime(displayCurrentTime.value));
+	const canPlayPrev = computed(() => {
+		if (playbackContext.value !== "playlist" || !currentPlaylist.value) return false;
+		if (playMode.value === "random" || playMode.value === "list-loop") return currentPlaylist.value.tracks.length > 1;
+		return currentTrackIndex.value > 0;
+	});
+	const canPlayNext = computed(() => {
+		if (playbackContext.value !== "playlist" || !currentPlaylist.value) return false;
+		if (playMode.value === "random" || playMode.value === "list-loop") return currentPlaylist.value.tracks.length > 1;
+		return currentTrackIndex.value > -1 && currentTrackIndex.value < currentPlaylist.value.tracks.length - 1;
+	});
+	const isPaused = computed(() => !isPlaying.value);
+	const revokeObjectUrl = () => {
+		if (currentObjectUrl.value) {
+			URL.revokeObjectURL(currentObjectUrl.value);
+			currentObjectUrl.value = null;
+		}
+	};
+	const clearAudioState = () => {
+		currentTime.value = 0;
+		duration.value = 0;
+		bufferedTime.value = 0;
+		isPlaying.value = false;
+		isLoading.value = false;
+		isReady.value = false;
+		isSeeking.value = false;
+		seekPreviewPercent.value = 0;
+		seekPreviewTime.value = 0;
+		errorMessage.value = "";
+	};
+	const detachMediaSource = () => {
+		if (!audioElement) return;
+		audioElement.removeAttribute("src");
+		try {
+			audioElement.srcObject = null;
+		} catch {}
+	};
+	const clearAudioSource = () => {
+		loadSession += 1;
+		if (!audioElement) {
+			revokeObjectUrl();
+			clearAudioState();
+			return;
+		}
+		audioElement.pause();
+		detachMediaSource();
+		revokeObjectUrl();
+		clearAudioState();
+	};
+	const hasMediaSource = () => {
+		if (!audioElement) return false;
+		return Boolean(audioElement.getAttribute("src") || audioElement.srcObject);
+	};
+	/** 媒体处于错误态或尚未挂源时需要重新加载 */
+	const needsMediaReload = () => {
+		if (!audioElement) return true;
+		if (!hasMediaSource()) return true;
+		return Boolean(audioElement.error);
+	};
+	/**
+	* 挂载媒体地址。同地址强制重载时先卸源再赋值；不要在空 src 时 load()。
+	* 赋值 src 本身会触发资源选择，再调 load() 容易与进行中的请求打架导致 Format error。
+	*/
+	const applyMediaSource = (source, forceReload = false) => {
+		if (!audioElement) return;
+		const current = audioElement.getAttribute("src");
+		if (!forceReload && current === source && !audioElement.error) return;
+		if (current) detachMediaSource();
+		audioElement.preload = getPreload();
+		audioElement.src = source;
+	};
+	const getTimeByPercent = (percent) => {
+		if (!duration.value) return 0;
+		return duration.value * (normalizePercentInput(percent) / 100);
+	};
+	const resolveTrackSource = (track) => {
+		if (!track) return "";
+		const source = track.src || track.url;
+		if (source) return source;
+		const binarySource = track.file || track.blob;
+		if (binarySource) {
+			revokeObjectUrl();
+			currentObjectUrl.value = URL.createObjectURL(binarySource);
+			return currentObjectUrl.value;
+		}
+		if (track.arrayBuffer) {
+			revokeObjectUrl();
+			const blob = new Blob([track.arrayBuffer], { type: track.mimeType || "audio/mpeg" });
+			currentObjectUrl.value = URL.createObjectURL(blob);
+			return currentObjectUrl.value;
+		}
+		return "";
+	};
+	const emitPlaylistChange = () => {
+		onPlaylistChange?.(currentPlaylist.value);
+		onPlaylistsChange?.(clonePlaylists(playlists.value));
+	};
+	const syncSelection = () => {
+		if (playbackContext.value === "direct") {
+			currentPlaylistId.value = null;
+			currentTrackId.value = directTrack.value?.id || null;
+			return;
+		}
+		if (!playlists.value.length) {
+			currentPlaylistId.value = null;
+			currentTrackId.value = null;
+			if (playbackContext.value === "playlist") clearAudioSource();
+			return;
+		}
+		const matchedPlaylist = playlists.value.find((item) => item.id === currentPlaylistId.value) || playlists.value[0];
+		currentPlaylistId.value = matchedPlaylist.id;
+		if (!matchedPlaylist.tracks.length) {
+			currentTrackId.value = null;
+			if (playbackContext.value === "playlist") clearAudioSource();
+			return;
+		}
+		const matchedTrack = matchedPlaylist.tracks.find((item) => item.id === currentTrackId.value) || matchedPlaylist.tracks[0];
+		currentTrackId.value = matchedTrack.id;
+	};
+	const isPlayInterruptedError = (error) => {
+		if (!(error instanceof DOMException) && !(error instanceof Error)) return false;
+		return error.name === "AbortError" || /interrupted by a call to pause/i.test(error.message);
+	};
+	const waitForCanPlay = (session) => {
+		return new Promise((resolve) => {
+			if (!audioElement) {
+				resolve(false);
+				return;
+			}
+			if (audioElement.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
+				resolve(session === loadSession);
+				return;
+			}
+			const onReady = () => {
+				cleanup();
+				resolve(session === loadSession);
+			};
+			const onError = () => {
+				cleanup();
+				resolve(false);
+			};
+			const cleanup = () => {
+				audioElement.removeEventListener("canplay", onReady);
+				audioElement.removeEventListener("loadeddata", onReady);
+				audioElement.removeEventListener("error", onError);
+			};
+			audioElement.addEventListener("canplay", onReady);
+			audioElement.addEventListener("loadeddata", onReady);
+			audioElement.addEventListener("error", onError);
+		});
+	};
+	const syncDurationFromElement = () => {
+		if (!audioElement) return 0;
+		const next = audioElement.duration;
+		if (Number.isFinite(next) && next > 0) {
+			duration.value = next;
+			return next;
+		}
+		return duration.value;
+	};
+	/** 确保当前曲目已挂上 src 且拿到 duration（初始化不预拉流时首次 seek 需要） */
+	const ensureMediaReady = async () => {
+		if (!audioElement || !currentTrack.value) return false;
+		if (!needsMediaReload() && syncDurationFromElement() > 0) return true;
+		if (needsMediaReload()) {
+			if (!await loadCurrentTrack({
+				autoplay: false,
+				forceReload: Boolean(audioElement.error)
+			})) return false;
+		}
+		const session = loadSession;
+		if (syncDurationFromElement() > 0) return session === loadSession;
+		return new Promise((resolve) => {
+			if (!audioElement) {
+				resolve(false);
+				return;
+			}
+			const onReady = () => {
+				syncDurationFromElement();
+				cleanup();
+				resolve(session === loadSession && duration.value > 0);
+			};
+			const onError = () => {
+				cleanup();
+				resolve(false);
+			};
+			const cleanup = () => {
+				audioElement.removeEventListener("loadedmetadata", onReady);
+				audioElement.removeEventListener("durationchange", onReady);
+				audioElement.removeEventListener("error", onError);
+			};
+			audioElement.addEventListener("loadedmetadata", onReady);
+			audioElement.addEventListener("durationchange", onReady);
+			audioElement.addEventListener("error", onError);
+		});
+	};
+	const play = async () => {
+		if (!audioElement || !currentTrack.value) return false;
+		if (needsMediaReload()) return loadCurrentTrack({
+			autoplay: true,
+			forceReload: Boolean(audioElement.error)
+		});
+		const session = loadSession;
+		try {
+			await audioElement.play();
+			return session === loadSession;
+		} catch (error) {
+			if (isPlayInterruptedError(error) || session !== loadSession) return false;
+			if (audioElement.error || /format error/i.test(String(error))) return loadCurrentTrack({
+				autoplay: true,
+				forceReload: true
+			});
+			const message = error instanceof Error ? error.message : "Audio playback failed.";
+			errorMessage.value = message;
+			onError?.(error);
+			return false;
+		}
+	};
+	const pause = () => {
+		audioElement?.pause();
+	};
+	const togglePlay = async () => {
+		if (isPlaying.value) {
+			pause();
+			return true;
+		}
+		return play();
+	};
+	const seek = (time) => {
+		if (!audioElement || !duration.value) return;
+		if (audioElement.readyState < HTMLMediaElement.HAVE_METADATA) return;
+		if (audioElement.error) return;
+		const targetTime = clamp(time, 0, duration.value);
+		try {
+			audioElement.currentTime = targetTime;
+			currentTime.value = targetTime;
+		} catch {}
+	};
+	const seekByPercent = (percent) => {
+		seek(getTimeByPercent(percent));
+	};
+	const beginSeeking = (percent) => {
+		isSeeking.value = true;
+		if (percent == null) {
+			seekPreviewPercent.value = progressPercent.value;
+			seekPreviewTime.value = currentTime.value;
+			return;
+		}
+		updateSeekingByPercent(percent);
+	};
+	const updateSeekingByPercent = (percent) => {
+		const nextPercent = normalizePercentInput(percent);
+		isSeeking.value = true;
+		seekPreviewPercent.value = nextPercent;
+		seekPreviewTime.value = getTimeByPercent(nextPercent);
+	};
+	const commitSeeking = async (percent) => {
+		if (percent != null) updateSeekingByPercent(percent);
+		const targetPercent = seekPreviewPercent.value;
+		isSeeking.value = false;
+		if (!await ensureMediaReady()) return;
+		seekByPercent(targetPercent);
+	};
+	const cancelSeeking = () => {
+		isSeeking.value = false;
+		seekPreviewPercent.value = progressPercent.value;
+		seekPreviewTime.value = currentTime.value;
+	};
+	const setVolume = (volume) => {
+		setVolumeByPercent(volume);
+	};
+	const setVolumeByPercent = (percent) => {
+		if (!audioElement) return;
+		const nextVolume = normalizePercentInput(percent);
+		volumePercent.value = nextVolume;
+		audioElement.volume = nextVolume / 100;
+		audioElement.muted = nextVolume === 0;
+		if (nextVolume > 0) lastVolumeBeforeMute.value = nextVolume;
+	};
+	const toggleMute = () => {
+		if (!audioElement) return;
+		if (audioElement.muted || volumePercent.value === 0) {
+			const restoredVolume = lastVolumeBeforeMute.value || 100;
+			audioElement.volume = clamp(restoredVolume, 0, 100) / 100;
+			audioElement.muted = false;
+			volumePercent.value = clamp(restoredVolume, 0, 100);
+			return;
+		}
+		lastVolumeBeforeMute.value = volumePercent.value || 100;
+		audioElement.muted = true;
+	};
+	const setPlayMode = (mode) => {
+		if (!PLAY_MODES.includes(mode)) return;
+		playMode.value = mode;
+		onUpdatePlayMode?.(mode);
+		onPlayModeChange?.(mode);
+	};
+	const loadCurrentTrack = async (loadOptions = {}) => {
+		if (!audioElement || !currentTrack.value) {
+			clearAudioSource();
+			return false;
+		}
+		const source = resolveTrackSource(currentTrack.value);
+		if (!source) {
+			const message = "Audio source is empty.";
+			errorMessage.value = message;
+			onError?.(/* @__PURE__ */ new Error(message));
+			clearAudioSource();
+			return false;
+		}
+		const session = ++loadSession;
+		errorMessage.value = "";
+		isLoading.value = true;
+		isReady.value = false;
+		currentTime.value = 0;
+		bufferedTime.value = 0;
+		seekPreviewPercent.value = 0;
+		seekPreviewTime.value = 0;
+		isSeeking.value = false;
+		try {
+			audioElement.pause();
+		} catch {}
+		const forceReload = Boolean(loadOptions.forceReload) || Boolean(audioElement.error);
+		if (forceReload || audioElement.getAttribute("src") !== source) applyMediaSource(source, forceReload);
+		onTrackChange?.(currentTrack.value);
+		if (!loadOptions.autoplay) return session === loadSession;
+		if (!await waitForCanPlay(session) || session !== loadSession) {
+			if (session === loadSession && !errorMessage.value) {
+				errorMessage.value = audioElement.error ? "音频格式不支持或资源无效。" : "音频加载失败。";
+				isLoading.value = false;
+			}
+			return false;
+		}
+		try {
+			audioElement.currentTime = 0;
+		} catch {}
+		currentTime.value = 0;
+		try {
+			await audioElement.play();
+			return session === loadSession;
+		} catch (error) {
+			if (isPlayInterruptedError(error) || session !== loadSession) return false;
+			const message = error instanceof Error ? error.message : "Audio playback failed.";
+			errorMessage.value = message;
+			onError?.(error);
+			return false;
+		}
+	};
+	const getRandomTrackIndex = (size, excludeIndex) => {
+		if (size <= 1) return excludeIndex;
+		let nextIndex = excludeIndex;
+		while (nextIndex === excludeIndex) nextIndex = Math.floor(Math.random() * size);
+		return nextIndex;
+	};
+	const moveTrack = async (direction, fromEnded = false) => {
+		if (playbackContext.value !== "playlist" || !currentPlaylist.value) return false;
+		const tracks = currentPlaylist.value.tracks;
+		if (!tracks.length || currentTrackIndex.value < 0) return false;
+		let nextIndex = currentTrackIndex.value;
+		if (playMode.value === "random") nextIndex = getRandomTrackIndex(tracks.length, currentTrackIndex.value);
+		else if (fromEnded && playMode.value === "single-loop") nextIndex = currentTrackIndex.value;
+		else if (direction === "prev") {
+			if (playMode.value === "list-loop") nextIndex = (currentTrackIndex.value - 1 + tracks.length) % tracks.length;
+			else nextIndex = currentTrackIndex.value - 1;
+		} else if (playMode.value === "list-loop") nextIndex = (currentTrackIndex.value + 1) % tracks.length;
+		else nextIndex = currentTrackIndex.value + 1;
+		if (nextIndex < 0 || nextIndex >= tracks.length) {
+			if (fromEnded) pause();
+			return false;
+		}
+		currentTrackId.value = tracks[nextIndex].id;
+		onUpdateActiveTrackId?.(currentTrackId.value);
+		return loadCurrentTrack({ autoplay: true });
+	};
+	const prev = async () => {
+		if (playbackContext.value === "playlist" && currentPlaylist.value && currentTime.value > 5) {
+			seek(0);
+			return true;
+		}
+		return moveTrack("prev");
+	};
+	const next = async () => {
+		return moveTrack("next");
+	};
+	const playTrack = async (trackIdOrIndex, playlistId) => {
+		const targetPlaylist = playlists.value.find((item) => item.id === String(playlistId != null ? playlistId : currentPlaylistId.value || "")) || currentPlaylist.value;
+		if (!targetPlaylist || !targetPlaylist.tracks.length) return false;
+		const targetTrack = typeof trackIdOrIndex === "number" ? targetPlaylist.tracks[trackIdOrIndex] : targetPlaylist.tracks.find((item) => item.id === String(trackIdOrIndex));
+		if (!targetTrack) return false;
+		playbackContext.value = "playlist";
+		directTrack.value = null;
+		currentPlaylistId.value = targetPlaylist.id;
+		currentTrackId.value = targetTrack.id;
+		onUpdateActivePlaylistId?.(targetPlaylist.id);
+		onUpdateActiveTrackId?.(targetTrack.id);
+		return loadCurrentTrack({
+			autoplay: true,
+			forceReload: true
+		});
+	};
+	const switchPlaylist = async (playlistId, switchOptions = {}) => {
+		const targetPlaylist = playlists.value.find((item) => item.id === String(playlistId)) || null;
+		if (!targetPlaylist) return false;
+		playbackContext.value = "playlist";
+		directTrack.value = null;
+		currentPlaylistId.value = targetPlaylist.id;
+		currentTrackId.value = switchOptions.trackId != null ? String(switchOptions.trackId) : targetPlaylist.tracks[0]?.id || null;
+		onUpdateActivePlaylistId?.(currentPlaylistId.value);
+		onUpdateActiveTrackId?.(currentTrackId.value);
+		emitPlaylistChange();
+		return loadCurrentTrack({ autoplay: switchOptions.autoplay });
+	};
+	const loadSource = async (source, loadOptions = {}) => {
+		playbackContext.value = "direct";
+		directTrack.value = normalizeTrack(source, "direct-track");
+		currentPlaylistId.value = null;
+		currentTrackId.value = directTrack.value.id;
+		onUpdateActivePlaylistId?.(null);
+		onUpdateActiveTrackId?.(directTrack.value.id);
+		return loadCurrentTrack({ autoplay: loadOptions.autoplay ?? getAutoplay() });
+	};
+	const clearSource = () => {
+		directTrack.value = null;
+		if (playbackContext.value === "direct") {
+			currentPlaylistId.value = null;
+			currentTrackId.value = null;
+			clearAudioSource();
+			onUpdateActivePlaylistId?.(null);
+			onUpdateActiveTrackId?.(null);
+		}
+	};
+	const createPlaylist = (name, tracks = []) => {
+		const playlist = normalizePlaylist({
+			id: createId("playlist"),
+			name,
+			tracks
+		}, playlists.value.length);
+		playlists.value = [...playlists.value, playlist];
+		if (!currentPlaylistId.value) currentPlaylistId.value = playlist.id;
+		emitPlaylistChange();
+		return playlist;
+	};
+	const renamePlaylist = (playlistId, name) => {
+		const target = playlists.value.find((item) => item.id === String(playlistId));
+		if (!target) return false;
+		target.name = name;
+		emitPlaylistChange();
+		return true;
+	};
+	const deletePlaylist = (playlistId) => {
+		const targetId = String(playlistId);
+		const nextPlaylists = playlists.value.filter((item) => item.id !== targetId);
+		if (nextPlaylists.length === playlists.value.length) return false;
+		const deletingCurrent = playbackContext.value === "playlist" && currentPlaylistId.value === targetId;
+		playlists.value = nextPlaylists;
+		syncSelection();
+		if (deletingCurrent && currentTrack.value) loadCurrentTrack({ autoplay: isPlaying.value });
+		emitPlaylistChange();
+		return true;
+	};
+	const addTracksToPlaylist = (playlistId, tracks) => {
+		const target = playlists.value.find((item) => item.id === String(playlistId));
+		if (!target || !tracks.length) return [];
+		const appendedTracks = tracks.map((track, index) => normalizeTrack(track, createId(`${target.id}-track-${target.tracks.length + index}`)));
+		target.tracks.push(...appendedTracks);
+		if (playbackContext.value === "playlist" && target.id === currentPlaylistId.value && !currentTrackId.value) currentTrackId.value = target.tracks[0]?.id || null;
+		emitPlaylistChange();
+		return appendedTracks;
+	};
+	const removeTracksFromPlaylist = (playlistId, trackIds) => {
+		const target = playlists.value.find((item) => item.id === String(playlistId));
+		if (!target || !trackIds.length) return false;
+		const removingIds = new Set(trackIds.map((item) => String(item)));
+		const existed = target.tracks.length;
+		target.tracks = target.tracks.filter((item) => !removingIds.has(item.id));
+		if (existed === target.tracks.length) return false;
+		if (playbackContext.value === "playlist" && target.id === currentPlaylistId.value && currentTrackId.value && removingIds.has(currentTrackId.value)) {
+			currentTrackId.value = target.tracks[0]?.id || null;
+			if (currentTrackId.value) loadCurrentTrack({ autoplay: isPlaying.value });
+			else clearAudioSource();
+		}
+		emitPlaylistChange();
+		return true;
+	};
+	const setPlaylists = (nextPlaylists) => {
+		playlists.value = nextPlaylists.map((item, index) => normalizePlaylist(item, index));
+		syncSelection();
+		if (playbackContext.value === "playlist" && currentTrack.value) loadCurrentTrack({ autoplay: isPlaying.value });
+		emitPlaylistChange();
+	};
+	const reset = () => {
+		pause();
+		seek(0);
+		isSeeking.value = false;
+		errorMessage.value = "";
+	};
+	if (audioElement) {
+		audioElement.addEventListener("play", () => {
+			isPlaying.value = true;
+			onPlay?.(currentTrack.value);
+		});
+		audioElement.addEventListener("pause", () => {
+			isPlaying.value = false;
+			onPause?.(currentTrack.value);
+		});
+		audioElement.addEventListener("waiting", () => {
+			isLoading.value = true;
+		});
+		audioElement.addEventListener("canplay", () => {
+			isLoading.value = false;
+			isReady.value = true;
+		});
+		audioElement.addEventListener("loadedmetadata", () => {
+			duration.value = Number.isFinite(audioElement.duration) ? audioElement.duration : currentTrack.value?.duration || 0;
+			isReady.value = true;
+			isLoading.value = false;
+			onLoaded?.(currentTrack.value);
+		});
+		audioElement.addEventListener("durationchange", () => {
+			duration.value = Number.isFinite(audioElement.duration) ? audioElement.duration : duration.value;
+		});
+		audioElement.addEventListener("timeupdate", () => {
+			currentTime.value = audioElement.currentTime || 0;
+			onTimeUpdate?.({
+				currentTime: currentTime.value,
+				duration: duration.value,
+				progressPercent: progressPercent.value,
+				track: currentTrack.value
+			});
+		});
+		audioElement.addEventListener("progress", () => {
+			if (!audioElement.buffered.length) return;
+			bufferedTime.value = audioElement.buffered.end(audioElement.buffered.length - 1);
+		});
+		audioElement.addEventListener("volumechange", () => {
+			isMuted.value = audioElement.muted;
+			volumePercent.value = Math.round(audioElement.volume * 100);
+			if (!audioElement.muted && volumePercent.value > 0) lastVolumeBeforeMute.value = volumePercent.value;
+			onVolumeChange?.({
+				muted: isMuted.value,
+				volumePercent: volumePercent.value
+			});
+		});
+		audioElement.addEventListener("ended", async () => {
+			onEnded?.(currentTrack.value);
+			await moveTrack("next", true);
+		});
+		audioElement.addEventListener("error", () => {
+			if (!hasMediaSource()) return;
+			const srcWhenError = audioElement.getAttribute("src");
+			const sessionWhenError = loadSession;
+			const mediaError = audioElement.error;
+			window.setTimeout(() => {
+				if (sessionWhenError !== loadSession) return;
+				if (!hasMediaSource()) return;
+				if (audioElement.getAttribute("src") !== srcWhenError) return;
+				if (audioElement.readyState >= HTMLMediaElement.HAVE_METADATA) return;
+				if (!audioElement.error) return;
+				if (audioElement.error.code === MediaError.MEDIA_ERR_ABORTED) return;
+				const code = audioElement.error.code;
+				const rawMessage = audioElement.error.message || mediaError?.message || "";
+				const isFormatError = code === MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED || /format error/i.test(rawMessage);
+				errorMessage.value = isFormatError ? "音频格式不支持或资源无效。" : rawMessage || "Audio load failed.";
+				isLoading.value = false;
+				onError?.(audioElement.error || new Error(errorMessage.value));
+			}, 80);
+		});
+	}
+	watch(() => getPlayMode(), (value) => {
+		if (PLAY_MODES.includes(value)) playMode.value = value;
+	});
+	watch(() => getPlaylists(), (value) => {
+		const prevTrackId = currentTrackId.value;
+		const prevSource = currentTrack.value ? currentTrack.value.src || currentTrack.value.url || "" : "";
+		const wasPlaying = isPlaying.value;
+		playlists.value = value.map((item, index) => normalizePlaylist(item, index));
+		syncSelection();
+		if (playbackContext.value !== "playlist" || !currentTrack.value) return;
+		const nextSource = currentTrack.value.src || currentTrack.value.url || "";
+		if (currentTrackId.value === prevTrackId && nextSource === prevSource) return;
+		loadCurrentTrack({ autoplay: wasPlaying });
+	}, { deep: true });
+	watch(() => getActivePlaylistId(), (value) => {
+		if (value == null) return;
+		const nextPlaylistId = String(value);
+		if (currentPlaylistId.value === nextPlaylistId) return;
+		playbackContext.value = "playlist";
+		directTrack.value = null;
+		currentPlaylistId.value = nextPlaylistId;
+		syncSelection();
+		if (currentTrack.value) {
+			onUpdateActiveTrackId?.(currentTrack.value.id);
+			loadCurrentTrack({ autoplay: false });
+		}
+	});
+	watch(() => getActiveTrackId(), (value) => {
+		if (value == null) return;
+		const nextTrackId = String(value);
+		if (currentTrackId.value === nextTrackId) return;
+		playbackContext.value = "playlist";
+		directTrack.value = null;
+		currentTrackId.value = nextTrackId;
+		if (currentTrack.value) loadCurrentTrack({ autoplay: false });
+	});
+	watch(() => getSource(), (value) => {
+		if (!value) return;
+		loadSource(value, { autoplay: getAutoplay() });
+	}, {
+		deep: true,
+		immediate: true
+	});
+	syncSelection();
+	onUnmounted(() => {
+		clearAudioSource();
+	});
+	return {
+		audioElement,
+		playlists,
+		currentPlaylist,
+		currentPlaylistId,
+		currentTrack,
+		currentTrackId,
+		currentTrackIndex,
+		playMode,
+		isPlaying,
+		isPaused,
+		isLoading,
+		isReady,
+		isMuted,
+		isSeeking,
+		hasTrack,
+		currentTime,
+		duration,
+		bufferedTime,
+		progressPercent,
+		displayProgressPercent,
+		bufferedPercent,
+		seekPreviewPercent,
+		volumePercent,
+		displayCurrentTime,
+		formattedCurrentTime,
+		formattedDuration,
+		formattedDisplayCurrentTime,
+		canPlayPrev,
+		canPlayNext,
+		errorMessage,
+		play,
+		pause,
+		togglePlay,
+		seek,
+		seekByPercent,
+		beginSeeking,
+		updateSeekingByPercent,
+		commitSeeking,
+		cancelSeeking,
+		getTimeByPercent,
+		setVolume,
+		setVolumeByPercent,
+		toggleMute,
+		setPlayMode,
+		prev,
+		next,
+		playTrack,
+		switchPlaylist,
+		loadSource,
+		clearSource,
+		createPlaylist,
+		renamePlaylist,
+		deletePlaylist,
+		addTracksToPlaylist,
+		removeTracksFromPlaylist,
+		setPlaylists,
+		reset,
+		formatTime: formatAudioTime
+	};
+}
+//#endregion
+export { useAudioPlayer as default, formatAudioTime };
+
+//# sourceMappingURL=useAudioPlayer.js.map