Compare commits
3
Commits
No files matched your search
+143
-792
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,728 @@
|
||||
import { dolbyAtmosSupported } from "@/lib/playback-capabilities"
|
||||
import {
|
||||
createAudioPlaylist,
|
||||
setAudioModeAsync,
|
||||
setIsAudioActiveAsync,
|
||||
type AudioMetadata,
|
||||
type AudioPlaylist,
|
||||
type AudioPlaylistStatus,
|
||||
type AudioSource,
|
||||
} from "expo-audio"
|
||||
import { useConvex } from "convex/react"
|
||||
import { useCallback, useEffect, useMemo, useRef, useState } from "react"
|
||||
|
||||
import { useCacheScope } from "@/contexts/persistent-cache"
|
||||
import { useServerConfig } from "@/contexts/server-config"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
import { playbackStreamPlan } from "@otunes/convex/playback-stream"
|
||||
import * as playbackQueue from "@otunes/convex/client/playback-queue"
|
||||
import type { RepeatMode } from "@otunes/convex/client/playback-queue"
|
||||
import type { PlaybackStore } from "@otunes/convex/client/playback-store"
|
||||
import { getAuthCookieHeader } from "@/lib/auth-cookies"
|
||||
import { loadPlaybackSongs } from "@/lib/playback-files"
|
||||
import { showError } from "@/lib/toast"
|
||||
import { albumCoverUrl, songAudioSource } from "@/lib/urls"
|
||||
import {
|
||||
activatePlaylistLockScreen,
|
||||
releaseAudioPlaylist,
|
||||
updatePlaylistLockScreenMetadata,
|
||||
} from "@/lib/audio-playlist-lock-screen"
|
||||
import {
|
||||
nativePlaylistEdits,
|
||||
nativePlaylistNeedsRebuild,
|
||||
nativePlaylistSongIds,
|
||||
repeatToPlaylistLoop,
|
||||
} from "@/lib/native-playlist-window"
|
||||
|
||||
const PLAYBACK_READY_TIMEOUT_MS = 20_000
|
||||
|
||||
function lockScreenMetadata(
|
||||
song: BrowseSong,
|
||||
serverUrl: string
|
||||
): AudioMetadata {
|
||||
return {
|
||||
title: song.title,
|
||||
artist: song.artist.name,
|
||||
albumTitle: song.album.title,
|
||||
artworkUrl: albumCoverUrl(serverUrl, song.album.id, 512),
|
||||
}
|
||||
}
|
||||
|
||||
type PlaybackWaiter = { playing?: boolean; resolve: () => void }
|
||||
|
||||
/** Where the last sync left the native player, and the queue it reflects. */
|
||||
type SyncedPosition = {
|
||||
index: number
|
||||
songId: Id<"songs"> | undefined
|
||||
historyLength: number
|
||||
}
|
||||
|
||||
/**
|
||||
* Keeps the native `AudioPlaylist` in step with the playback queue, and
|
||||
* feeds its status (position, playing, track changes) back into the queue.
|
||||
*/
|
||||
export function useNativePlaylistSync({
|
||||
store,
|
||||
queueSongIds,
|
||||
queueHistorySongIds,
|
||||
repeatEnabled,
|
||||
currentSong,
|
||||
queueStartVersion,
|
||||
}: {
|
||||
store: PlaybackStore
|
||||
queueSongIds: Id<"songs">[]
|
||||
queueHistorySongIds: Id<"songs">[]
|
||||
repeatEnabled: RepeatMode
|
||||
currentSong: BrowseSong | null
|
||||
queueStartVersion: number
|
||||
}) {
|
||||
const convex = useConvex()
|
||||
const { config } = useServerConfig()
|
||||
const cacheScope = useCacheScope()
|
||||
const user = useCachedQuery(api.auth.currentUser)
|
||||
const storeRef = useRef(store)
|
||||
storeRef.current = store
|
||||
|
||||
const playlistRef = useRef<AudioPlaylist | null>(null)
|
||||
const statusSubscriptionRef = useRef<{ remove: () => void } | null>(null)
|
||||
const trackChangedSubscriptionRef = useRef<{ remove: () => void } | null>(
|
||||
null
|
||||
)
|
||||
const loadedSongIdsRef = useRef<Id<"songs">[]>([])
|
||||
const loadedLoadKeyRef = useRef<string | null>(null)
|
||||
const syncedPositionRef = useRef<SyncedPosition | null>(null)
|
||||
const waitersRef = useRef(new Map<Id<"songs">, Set<PlaybackWaiter>>())
|
||||
const autoPlayNextRef = useRef(false)
|
||||
const isPlayingRef = useRef(false)
|
||||
const currentTimeRef = useRef(0)
|
||||
const pendingSeekRef = useRef<number | null>(null)
|
||||
const seekInFlightRef = useRef(false)
|
||||
// Set while `play()` waits for a pending seek to land.
|
||||
const deferredPlayRef = useRef(false)
|
||||
const loadRequestIdRef = useRef(0)
|
||||
|
||||
const [isPlaying, setIsPlayingState] = useState(false)
|
||||
const [currentTime, setCurrentTime] = useState(0)
|
||||
const [measuredDuration, setDuration] = useState(0)
|
||||
|
||||
const currentSongId = queueSongIds[0] ?? null
|
||||
const duration =
|
||||
measuredDuration > 0
|
||||
? measuredDuration
|
||||
: (currentSong?.durationSeconds ?? 0)
|
||||
const queueSyncKey = useMemo(
|
||||
() => JSON.stringify(queueSongIds),
|
||||
[queueSongIds]
|
||||
)
|
||||
const historySyncKey = useMemo(
|
||||
() => JSON.stringify(queueHistorySongIds),
|
||||
[queueHistorySongIds]
|
||||
)
|
||||
const currentSongSyncKey = currentSong
|
||||
? JSON.stringify([
|
||||
currentSong.id,
|
||||
currentSong.title,
|
||||
currentSong.artist.name,
|
||||
currentSong.album.id,
|
||||
currentSong.album.title,
|
||||
currentSong.album.cover ?? "",
|
||||
])
|
||||
: ""
|
||||
const userPlaybackKey = user
|
||||
? JSON.stringify([
|
||||
user._id,
|
||||
user.playbackQuality,
|
||||
dolbyAtmosSupported && (user.preferAtmos ?? false),
|
||||
])
|
||||
: ""
|
||||
|
||||
const settleWaiters = useCallback(() => {
|
||||
const player = playlistRef.current
|
||||
if (waitersRef.current.size === 0 || !player) return
|
||||
const songId = loadedSongIdsRef.current[player.currentIndex]
|
||||
const waiters = songId && waitersRef.current.get(songId)
|
||||
if (!waiters || !player.isLoaded) return
|
||||
for (const waiter of waiters) {
|
||||
if (waiter.playing === undefined || player.playing === waiter.playing) {
|
||||
waiter.resolve()
|
||||
}
|
||||
}
|
||||
}, [])
|
||||
|
||||
const markSynced = useCallback(
|
||||
(playlist: AudioPlaylist, songId: Id<"songs">, historyLength: number) => {
|
||||
syncedPositionRef.current = {
|
||||
index: playlist.currentIndex,
|
||||
songId,
|
||||
historyLength,
|
||||
}
|
||||
settleWaiters()
|
||||
},
|
||||
[settleWaiters]
|
||||
)
|
||||
|
||||
const destroyPlaylist = useCallback(() => {
|
||||
statusSubscriptionRef.current?.remove()
|
||||
statusSubscriptionRef.current = null
|
||||
trackChangedSubscriptionRef.current?.remove()
|
||||
trackChangedSubscriptionRef.current = null
|
||||
const playlist = playlistRef.current
|
||||
if (playlist) {
|
||||
playlist.pause()
|
||||
releaseAudioPlaylist(playlist)
|
||||
}
|
||||
playlistRef.current = null
|
||||
loadedSongIdsRef.current = []
|
||||
loadedLoadKeyRef.current = null
|
||||
syncedPositionRef.current = null
|
||||
}, [])
|
||||
|
||||
const resetPosition = useCallback(() => {
|
||||
pendingSeekRef.current = null
|
||||
deferredPlayRef.current = false
|
||||
currentTimeRef.current = 0
|
||||
setCurrentTime(0)
|
||||
setDuration(0)
|
||||
}, [])
|
||||
|
||||
// A new queue must not inherit the native player's position or a pending seek.
|
||||
const resetForNewQueue = useCallback(() => {
|
||||
loadRequestIdRef.current += 1
|
||||
destroyPlaylist()
|
||||
seekInFlightRef.current = false
|
||||
resetPosition()
|
||||
}, [destroyPlaylist, resetPosition])
|
||||
|
||||
/**
|
||||
* Starts the player, unless a seek (a restored position) is still pending.
|
||||
* Then the status handler starts it once the seek lands, so playback never
|
||||
* starts at 0:00 and jumps.
|
||||
*/
|
||||
const startPlayer = useCallback((playlist: AudioPlaylist) => {
|
||||
if (pendingSeekRef.current !== null && pendingSeekRef.current > 0) {
|
||||
deferredPlayRef.current = true
|
||||
return
|
||||
}
|
||||
playlist.play()
|
||||
}, [])
|
||||
|
||||
const handlePlaylistStatusUpdate = useCallback(
|
||||
(status: AudioPlaylistStatus) => {
|
||||
settleWaiters()
|
||||
// iOS may remove the finished item before delivering its final status.
|
||||
if (!status.isLoaded && !status.didJustFinish) return
|
||||
const state = storeRef.current.getState()
|
||||
if (loadedSongIdsRef.current[status.currentIndex] !== state.queue[0]) {
|
||||
return
|
||||
}
|
||||
|
||||
if (status.duration > 0) {
|
||||
setDuration(status.duration)
|
||||
}
|
||||
|
||||
if (pendingSeekRef.current !== null && pendingSeekRef.current > 0) {
|
||||
const seekSeconds =
|
||||
status.duration > 0
|
||||
? Math.min(pendingSeekRef.current, status.duration)
|
||||
: pendingSeekRef.current
|
||||
pendingSeekRef.current = null
|
||||
const playlist = playlistRef.current
|
||||
if (playlist) {
|
||||
// Statuses report the old position until the seek lands.
|
||||
seekInFlightRef.current = true
|
||||
void playlist.seekTo(seekSeconds).finally(() => {
|
||||
seekInFlightRef.current = false
|
||||
if (deferredPlayRef.current && playlistRef.current === playlist) {
|
||||
deferredPlayRef.current = false
|
||||
playlist.play()
|
||||
}
|
||||
})
|
||||
}
|
||||
currentTimeRef.current = seekSeconds
|
||||
setCurrentTime(seekSeconds)
|
||||
} else if (!seekInFlightRef.current) {
|
||||
currentTimeRef.current = status.currentTime
|
||||
setCurrentTime(status.currentTime)
|
||||
}
|
||||
|
||||
if (status.playing) {
|
||||
autoPlayNextRef.current = false
|
||||
if (!isPlayingRef.current) {
|
||||
isPlayingRef.current = true
|
||||
setIsPlayingState(true)
|
||||
}
|
||||
} else if (
|
||||
isPlayingRef.current &&
|
||||
!status.didJustFinish &&
|
||||
!deferredPlayRef.current
|
||||
) {
|
||||
autoPlayNextRef.current = false
|
||||
isPlayingRef.current = false
|
||||
setIsPlayingState(false)
|
||||
}
|
||||
|
||||
if (!status.didJustFinish) return
|
||||
if (state.repeatEnabled === "once") return
|
||||
if (status.currentIndex < status.trackCount - 1) return
|
||||
|
||||
const shouldContinue =
|
||||
state.repeatEnabled !== "none" || state.queue.length > 1
|
||||
if (!shouldContinue) {
|
||||
autoPlayNextRef.current = false
|
||||
isPlayingRef.current = false
|
||||
setIsPlayingState(false)
|
||||
storeRef.current.update(playbackQueue.skipNext)
|
||||
const playlist = playlistRef.current
|
||||
if (playlist) {
|
||||
playlist.pause()
|
||||
// Reload the final item, which iOS removes when playback ends. The
|
||||
// index doesn't move, so handleTrackChanged treats it as ours.
|
||||
playlist.skipTo(status.currentIndex)
|
||||
}
|
||||
currentTimeRef.current = 0
|
||||
setCurrentTime(0)
|
||||
return
|
||||
}
|
||||
|
||||
autoPlayNextRef.current = true
|
||||
isPlayingRef.current = true
|
||||
setIsPlayingState(true)
|
||||
storeRef.current.update(playbackQueue.skipNext)
|
||||
if (storeRef.current.getState().queue[0] === state.queue[0]) {
|
||||
const playlist = playlistRef.current
|
||||
void playlist?.seekTo(0)
|
||||
playlist?.play()
|
||||
}
|
||||
},
|
||||
[settleWaiters]
|
||||
)
|
||||
|
||||
const handleTrackChanged = useCallback(() => {
|
||||
const playlist = playlistRef.current
|
||||
const synced = syncedPositionRef.current
|
||||
if (!playlist || !synced) return
|
||||
// Queue edits run synchronously, so an event can describe an index from
|
||||
// before them (Android's `previousIndex` also goes stale). The player's
|
||||
// live index is the one that matters; if it is where the last sync left
|
||||
// it, this change was ours.
|
||||
const index = playlist.currentIndex
|
||||
if (index === synced.index) return
|
||||
const state = storeRef.current.getState()
|
||||
// A queue change is still being applied and will move the player itself.
|
||||
if (
|
||||
state.queue[0] !== synced.songId ||
|
||||
state.history.length !== synced.historyLength
|
||||
) {
|
||||
return
|
||||
}
|
||||
// The window is history then queue, so the current track sits at
|
||||
// `history.length`.
|
||||
const steps = index - state.history.length
|
||||
if (steps === 0) return
|
||||
|
||||
autoPlayNextRef.current = true
|
||||
isPlayingRef.current = true
|
||||
setIsPlayingState(true)
|
||||
|
||||
storeRef.current.update((state) => {
|
||||
if (steps === 1) return playbackQueue.skipNext(state)
|
||||
if (steps > 1) return playbackQueue.skipToQueueIndex(state, steps)
|
||||
let next = state
|
||||
for (let i = 0; i < -steps; i++) {
|
||||
next = playbackQueue.skipPrevious(next)
|
||||
}
|
||||
return next
|
||||
})
|
||||
const next = storeRef.current.getState()
|
||||
syncedPositionRef.current = {
|
||||
index,
|
||||
songId: next.queue[0],
|
||||
historyLength: next.history.length,
|
||||
}
|
||||
settleWaiters()
|
||||
}, [settleWaiters])
|
||||
|
||||
const ensurePlaylist = useCallback(
|
||||
(sources: AudioSource[]) => {
|
||||
if (playlistRef.current) {
|
||||
return playlistRef.current
|
||||
}
|
||||
|
||||
const playlist = createAudioPlaylist({
|
||||
sources,
|
||||
updateInterval: 500,
|
||||
loop: repeatToPlaylistLoop(storeRef.current.getState().repeatEnabled),
|
||||
})
|
||||
// System volume controls loudness; keep the player gain at full scale.
|
||||
playlist.volume = 1
|
||||
statusSubscriptionRef.current = playlist.addListener(
|
||||
"playlistStatusUpdate",
|
||||
handlePlaylistStatusUpdate
|
||||
)
|
||||
trackChangedSubscriptionRef.current = playlist.addListener(
|
||||
"trackChanged",
|
||||
handleTrackChanged
|
||||
)
|
||||
playlistRef.current = playlist
|
||||
return playlist
|
||||
},
|
||||
[handlePlaylistStatusUpdate, handleTrackChanged]
|
||||
)
|
||||
|
||||
useEffect(() => {
|
||||
let cancelled = false
|
||||
void setAudioModeAsync({
|
||||
playsInSilentMode: true,
|
||||
shouldPlayInBackground: true,
|
||||
interruptionMode: "doNotMix",
|
||||
}).catch(() => {
|
||||
if (!cancelled) {
|
||||
showError("Audio playback could not be initialized.")
|
||||
}
|
||||
})
|
||||
|
||||
return () => {
|
||||
cancelled = true
|
||||
destroyPlaylist()
|
||||
}
|
||||
}, [destroyPlaylist])
|
||||
|
||||
useEffect(() => {
|
||||
const playlist = playlistRef.current
|
||||
if (playlist) {
|
||||
playlist.loop = repeatToPlaylistLoop(repeatEnabled)
|
||||
}
|
||||
}, [repeatEnabled])
|
||||
|
||||
const setIsPlaying = useCallback(
|
||||
(playing: boolean) => {
|
||||
isPlayingRef.current = playing
|
||||
setIsPlayingState(playing)
|
||||
const playlist = playlistRef.current
|
||||
if (!playlist) return
|
||||
if (playing) {
|
||||
startPlayer(playlist)
|
||||
} else {
|
||||
deferredPlayRef.current = false
|
||||
playlist.pause()
|
||||
}
|
||||
},
|
||||
[startPlayer]
|
||||
)
|
||||
|
||||
const seekTo = useCallback(
|
||||
async (seconds: number) => {
|
||||
const playlist = playlistRef.current
|
||||
if (!playlist) return
|
||||
const maxDuration = playlist.duration || duration || 0
|
||||
const clamped = Math.max(0, Math.min(seconds, maxDuration))
|
||||
await playlist.seekTo(clamped)
|
||||
currentTimeRef.current = clamped
|
||||
setCurrentTime(clamped)
|
||||
},
|
||||
[duration]
|
||||
)
|
||||
|
||||
const handlePlaybackLoadFailure = useCallback(() => {
|
||||
autoPlayNextRef.current = false
|
||||
isPlayingRef.current = false
|
||||
destroyPlaylist()
|
||||
setIsPlayingState(false)
|
||||
showError("Could not play this track. The queue has been cleared.")
|
||||
storeRef.current.update(playbackQueue.clearQueue)
|
||||
}, [destroyPlaylist])
|
||||
|
||||
useEffect(() => {
|
||||
const loadRequestId = ++loadRequestIdRef.current
|
||||
const isCurrentLoad = () => loadRequestIdRef.current === loadRequestId
|
||||
|
||||
async function syncPlaylist() {
|
||||
if (!config || !currentSongId || !user) {
|
||||
if (!currentSongId) {
|
||||
destroyPlaylist()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const windowSongIds = nativePlaylistSongIds(
|
||||
queueHistorySongIds,
|
||||
queueSongIds
|
||||
)
|
||||
const currentIndex = queueHistorySongIds.length
|
||||
const cookieHeader = await getAuthCookieHeader(
|
||||
config.serverUrl,
|
||||
config.convexUrl
|
||||
)
|
||||
if (!cookieHeader) {
|
||||
showError("Your session has expired. Please sign in again.")
|
||||
return
|
||||
}
|
||||
if (!isCurrentLoad()) return
|
||||
|
||||
const loadKey = `${user.playbackQuality}:${dolbyAtmosSupported && (user.preferAtmos ?? false)}:${cookieHeader}`
|
||||
const needsRebuild =
|
||||
loadedLoadKeyRef.current !== loadKey ||
|
||||
nativePlaylistNeedsRebuild(
|
||||
loadedSongIdsRef.current,
|
||||
queueHistorySongIds,
|
||||
queueSongIds
|
||||
)
|
||||
|
||||
const metadata = currentSong
|
||||
? lockScreenMetadata(currentSong, config.serverUrl)
|
||||
: null
|
||||
const shouldPlay = isPlayingRef.current || autoPlayNextRef.current
|
||||
|
||||
if (!needsRebuild) {
|
||||
const playlist = playlistRef.current
|
||||
if (!playlist) return
|
||||
if (playlist.currentIndex !== currentIndex) {
|
||||
playlist.skipTo(currentIndex)
|
||||
}
|
||||
playlist.loop = repeatToPlaylistLoop(repeatEnabled)
|
||||
if (metadata) {
|
||||
updatePlaylistLockScreenMetadata(playlist, metadata)
|
||||
}
|
||||
markSynced(playlist, currentSongId, currentIndex)
|
||||
if (shouldPlay) {
|
||||
isPlayingRef.current = true
|
||||
setIsPlayingState(true)
|
||||
startPlayer(playlist)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const buildSources = async (songIds: Id<"songs">[]) => {
|
||||
const songs = await loadPlaybackSongs(convex, cacheScope, songIds)
|
||||
const sources = new Map<Id<"songs">, AudioSource>()
|
||||
for (const song of songs) {
|
||||
if (!song) return null
|
||||
const plan = playbackStreamPlan(
|
||||
song.files,
|
||||
user.playbackQuality,
|
||||
dolbyAtmosSupported && (user.preferAtmos ?? false)
|
||||
)
|
||||
sources.set(
|
||||
song.id,
|
||||
songAudioSource(
|
||||
config.serverUrl,
|
||||
song.id,
|
||||
plan.playbackQuality,
|
||||
plan.preferAtmos,
|
||||
plan.useHls,
|
||||
{ cookieHeader, songTitle: song.title }
|
||||
)
|
||||
)
|
||||
}
|
||||
return sources
|
||||
}
|
||||
|
||||
// Queue and history edits around the playing track are applied in place
|
||||
// so playback isn't interrupted.
|
||||
const loadedPlaylist = playlistRef.current
|
||||
const edits =
|
||||
loadedPlaylist && loadedLoadKeyRef.current === loadKey
|
||||
? nativePlaylistEdits(
|
||||
loadedSongIdsRef.current,
|
||||
loadedPlaylist.currentIndex,
|
||||
windowSongIds,
|
||||
currentIndex
|
||||
)
|
||||
: null
|
||||
if (loadedPlaylist && edits) {
|
||||
const addedSongIds = edits.flatMap((edit) =>
|
||||
edit.type === "remove" ? [] : [edit.songId]
|
||||
)
|
||||
const sources = await buildSources([...new Set(addedSongIds)])
|
||||
if (!isCurrentLoad()) return
|
||||
if (!sources) {
|
||||
handlePlaybackLoadFailure()
|
||||
return
|
||||
}
|
||||
for (const edit of edits) {
|
||||
if (edit.type === "remove") {
|
||||
loadedPlaylist.remove(edit.index)
|
||||
} else if (edit.type === "insert") {
|
||||
loadedPlaylist.insert(sources.get(edit.songId)!, edit.index)
|
||||
} else {
|
||||
loadedPlaylist.add(sources.get(edit.songId)!)
|
||||
}
|
||||
}
|
||||
loadedSongIdsRef.current = windowSongIds
|
||||
loadedPlaylist.loop = repeatToPlaylistLoop(repeatEnabled)
|
||||
markSynced(loadedPlaylist, currentSongId, currentIndex)
|
||||
if (shouldPlay && !loadedPlaylist.playing) {
|
||||
isPlayingRef.current = true
|
||||
setIsPlayingState(true)
|
||||
startPlayer(loadedPlaylist)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const sourcesById = await buildSources(windowSongIds)
|
||||
if (!isCurrentLoad()) return
|
||||
if (!sourcesById) {
|
||||
handlePlaybackLoadFailure()
|
||||
return
|
||||
}
|
||||
const sources = windowSongIds.map((songId) => sourcesById.get(songId)!)
|
||||
|
||||
// Keep the position when only the stream settings changed.
|
||||
const resumeSeconds =
|
||||
loadedPlaylist &&
|
||||
loadedSongIdsRef.current[loadedPlaylist.currentIndex] === currentSongId
|
||||
? currentTimeRef.current
|
||||
: null
|
||||
|
||||
destroyPlaylist()
|
||||
|
||||
if (resumeSeconds !== null && resumeSeconds > 0) {
|
||||
pendingSeekRef.current = resumeSeconds
|
||||
}
|
||||
// Start at the current track and put history in front of it, so an
|
||||
// earlier song is never loaded first.
|
||||
const playlist = ensurePlaylist(sources.slice(currentIndex))
|
||||
for (let index = 0; index < currentIndex; index++) {
|
||||
playlist.insert(sources[index], index)
|
||||
}
|
||||
loadedSongIdsRef.current = windowSongIds
|
||||
loadedLoadKeyRef.current = loadKey
|
||||
playlist.loop = repeatToPlaylistLoop(repeatEnabled)
|
||||
activatePlaylistLockScreen(
|
||||
playlist,
|
||||
metadata ?? { title: currentSong?.title }
|
||||
)
|
||||
markSynced(playlist, currentSongId, currentIndex)
|
||||
|
||||
if (shouldPlay) {
|
||||
isPlayingRef.current = true
|
||||
setIsPlayingState(true)
|
||||
startPlayer(playlist)
|
||||
} else {
|
||||
playlist.pause()
|
||||
// Enable audio for the restored queue without starting playback.
|
||||
try {
|
||||
await setIsAudioActiveAsync(true)
|
||||
} catch {
|
||||
if (isCurrentLoad()) {
|
||||
showError("Audio playback could not be initialized.")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void syncPlaylist().catch(() => {
|
||||
if (!isCurrentLoad()) return
|
||||
handlePlaybackLoadFailure()
|
||||
})
|
||||
|
||||
return () => {
|
||||
if (loadRequestIdRef.current === loadRequestId) {
|
||||
loadRequestIdRef.current += 1
|
||||
}
|
||||
}
|
||||
}, [
|
||||
cacheScope,
|
||||
config,
|
||||
convex,
|
||||
currentSongId,
|
||||
currentSongSyncKey,
|
||||
destroyPlaylist,
|
||||
ensurePlaylist,
|
||||
handlePlaybackLoadFailure,
|
||||
historySyncKey,
|
||||
markSynced,
|
||||
queueSyncKey,
|
||||
queueStartVersion,
|
||||
repeatEnabled,
|
||||
startPlayer,
|
||||
userPlaybackKey,
|
||||
])
|
||||
|
||||
/**
|
||||
* Resolves once the native player has `songId` loaded (and playing or
|
||||
* paused, if given). Rejects if the queue moves to another song first.
|
||||
*/
|
||||
const waitForSong = useCallback(
|
||||
(songId: Id<"songs">, playing?: boolean) =>
|
||||
new Promise<void>((resolve, reject) => {
|
||||
const store = storeRef.current
|
||||
const waiters = waitersRef.current
|
||||
let songWaiters = waiters.get(songId)
|
||||
if (!songWaiters) {
|
||||
songWaiters = new Set()
|
||||
waiters.set(songId, songWaiters)
|
||||
}
|
||||
const finish = (error?: Error) => {
|
||||
clearTimeout(timeout)
|
||||
unsubscribe()
|
||||
songWaiters.delete(waiter)
|
||||
if (songWaiters.size === 0 && waiters.get(songId) === songWaiters) {
|
||||
waiters.delete(songId)
|
||||
}
|
||||
if (error) reject(error)
|
||||
else resolve()
|
||||
}
|
||||
const waiter: PlaybackWaiter = { playing, resolve: () => finish() }
|
||||
const timeout = setTimeout(
|
||||
() =>
|
||||
finish(
|
||||
new Error(
|
||||
"The audio did not become ready. Check your connection and try again."
|
||||
)
|
||||
),
|
||||
PLAYBACK_READY_TIMEOUT_MS
|
||||
)
|
||||
// Starting a queue clears it and fills it in one go; only the
|
||||
// settled queue counts.
|
||||
const unsubscribe = store.subscribe(() => {
|
||||
queueMicrotask(() => {
|
||||
if (store.getState().queue[0] !== songId) {
|
||||
finish(
|
||||
new Error(
|
||||
"The playback queue changed before the request finished."
|
||||
)
|
||||
)
|
||||
}
|
||||
})
|
||||
})
|
||||
songWaiters.add(waiter)
|
||||
settleWaiters()
|
||||
}),
|
||||
[settleWaiters]
|
||||
)
|
||||
|
||||
/**
|
||||
* Starts the current song at `seconds` once it loads, and shows that
|
||||
* position right away. Playback waits for the seek (see `startPlayer`).
|
||||
*/
|
||||
const queueSeek = useCallback((seconds: number) => {
|
||||
pendingSeekRef.current = seconds
|
||||
currentTimeRef.current = seconds
|
||||
setCurrentTime(seconds)
|
||||
}, [])
|
||||
|
||||
const hasPlayer = useCallback(() => playlistRef.current !== null, [])
|
||||
|
||||
const requestAutoPlay = useCallback(() => {
|
||||
autoPlayNextRef.current = true
|
||||
}, [])
|
||||
|
||||
return {
|
||||
isPlaying,
|
||||
setIsPlaying,
|
||||
currentTime,
|
||||
currentTimeRef,
|
||||
duration,
|
||||
seekTo,
|
||||
queueSeek,
|
||||
hasPlayer,
|
||||
requestAutoPlay,
|
||||
resetPosition,
|
||||
resetForNewQueue,
|
||||
waitForSong,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
import { useMutation } from "convex/react"
|
||||
import { useCallback, useEffect, useRef, type RefObject } from "react"
|
||||
import { AppState } from "react-native"
|
||||
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { PlaybackStore } from "@otunes/convex/client/playback-store"
|
||||
import { flushPersistentCache } from "@/lib/persistent-cache"
|
||||
|
||||
const PROGRESS_SAVE_INTERVAL_MS = 5000
|
||||
|
||||
/**
|
||||
* Restores the saved position when a song becomes current, and saves the
|
||||
* position while it plays, on pause, and when the app leaves the foreground.
|
||||
*/
|
||||
export function useProgressPersistence({
|
||||
store,
|
||||
currentSongId,
|
||||
isPlaying,
|
||||
queueStartVersion,
|
||||
currentTimeRef,
|
||||
hasPlayer,
|
||||
queueSeek,
|
||||
resetPosition,
|
||||
}: {
|
||||
store: PlaybackStore
|
||||
currentSongId: Id<"songs"> | null
|
||||
isPlaying: boolean
|
||||
queueStartVersion: number
|
||||
currentTimeRef: RefObject<number>
|
||||
hasPlayer: () => boolean
|
||||
queueSeek: (seconds: number) => void
|
||||
resetPosition: () => void
|
||||
}) {
|
||||
const updateSongProgressMutation = useMutation(
|
||||
api.playback.updateSongProgress
|
||||
)
|
||||
const storeRef = useRef(store)
|
||||
storeRef.current = store
|
||||
|
||||
const progressRestoredForSongRef = useRef<Id<"songs"> | null>(null)
|
||||
const lastSavedProgressRef = useRef(-1)
|
||||
const prevIsPlayingRef = useRef(false)
|
||||
|
||||
const saveProgress = useCallback(
|
||||
(seconds: number) => {
|
||||
const songId = storeRef.current.getState().queue[0]
|
||||
if (!songId) return
|
||||
const progressSeconds = Math.max(0, Math.floor(seconds))
|
||||
if (progressSeconds === lastSavedProgressRef.current) return
|
||||
lastSavedProgressRef.current = progressSeconds
|
||||
storeRef.current.setProgress(songId, progressSeconds)
|
||||
void updateSongProgressMutation({
|
||||
songId,
|
||||
progressSeconds,
|
||||
}).catch(() => {})
|
||||
},
|
||||
[updateSongProgressMutation]
|
||||
)
|
||||
|
||||
const resetProgress = useCallback(() => {
|
||||
progressRestoredForSongRef.current = null
|
||||
lastSavedProgressRef.current = -1
|
||||
}, [])
|
||||
|
||||
useEffect(() => {
|
||||
if (!currentSongId) {
|
||||
progressRestoredForSongRef.current = null
|
||||
return
|
||||
}
|
||||
|
||||
if (progressRestoredForSongRef.current === currentSongId) return
|
||||
progressRestoredForSongRef.current = currentSongId
|
||||
lastSavedProgressRef.current = -1
|
||||
resetPosition()
|
||||
// Queue the seek before the song loads, so playback starts there.
|
||||
const progressSeconds = store.getState().progressSeconds
|
||||
if (progressSeconds > 0) {
|
||||
queueSeek(progressSeconds)
|
||||
}
|
||||
}, [currentSongId, queueStartVersion, queueSeek, resetPosition, store])
|
||||
|
||||
useEffect(() => {
|
||||
if (!currentSongId) return
|
||||
if (prevIsPlayingRef.current === isPlaying) return
|
||||
prevIsPlayingRef.current = isPlaying
|
||||
saveProgress(currentTimeRef.current)
|
||||
}, [isPlaying, currentSongId, currentTimeRef, saveProgress])
|
||||
|
||||
useEffect(() => {
|
||||
const subscription = AppState.addEventListener("change", (state) => {
|
||||
if (state === "active") return
|
||||
if (currentSongId && hasPlayer()) {
|
||||
saveProgress(currentTimeRef.current)
|
||||
}
|
||||
flushPersistentCache()
|
||||
})
|
||||
return () => subscription.remove()
|
||||
}, [currentSongId, currentTimeRef, hasPlayer, saveProgress])
|
||||
|
||||
useEffect(() => {
|
||||
if (!isPlaying || !currentSongId) return
|
||||
const interval = setInterval(() => {
|
||||
saveProgress(currentTimeRef.current)
|
||||
}, PROGRESS_SAVE_INTERVAL_MS)
|
||||
return () => clearInterval(interval)
|
||||
}, [isPlaying, currentSongId, currentTimeRef, saveProgress])
|
||||
|
||||
return { resetProgress }
|
||||
}
|
||||
@@ -4,13 +4,11 @@ import { PageHeader } from "@/components/library-skeletons"
|
||||
import * as React from "react"
|
||||
import Image from "next/image"
|
||||
import Link from "next/link"
|
||||
import { Play, Share2, Shuffle, Star } from "lucide-react"
|
||||
import { Play, Share2, Shuffle } from "lucide-react"
|
||||
|
||||
import { AudioFormatBadge } from "@/components/audio-format-badge"
|
||||
import { MediaCollectionFooter } from "@/components/media-collection-footer"
|
||||
import { TrackNumberPlayButton } from "@/components/track-number-play-button"
|
||||
|
||||
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
|
||||
import { FavoriteMediaButton } from "@/components/favorite-media-button"
|
||||
import { useFavorites } from "@/components/favorites-provider"
|
||||
import { usePlayback } from "@/components/playback-provider"
|
||||
@@ -20,31 +18,30 @@ import {
|
||||
MediaContextMenu,
|
||||
type MediaContextAction,
|
||||
} from "@/components/media-context-menu"
|
||||
import { TrackRow } from "@/components/track-row"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import { ScrollArea } from "@/components/ui/scroll-area"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
|
||||
import {
|
||||
useMediaActions,
|
||||
useTrackListMediaAction,
|
||||
} from "@/hooks/use-media-actions"
|
||||
import { useTrackSelection } from "@/hooks/use-track-selection"
|
||||
import { cn } from "@/lib/utils"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseAlbumDetail, BrowseAlbumTrack } from "@otunes/convex/types"
|
||||
import type {
|
||||
BrowseAlbumDetail,
|
||||
BrowseAlbumTrack,
|
||||
BrowseSong,
|
||||
} from "@otunes/convex/types"
|
||||
import {
|
||||
getSelectionRangePositions,
|
||||
isInSelectionRange,
|
||||
ALBUM_TRACK_ROW,
|
||||
ALBUM_TRACK_TITLE,
|
||||
SelectionRangeHighlight,
|
||||
TRACK_LIST_CONTAINER,
|
||||
TrackRowActiveHighlight,
|
||||
TrackRowHoverHighlight,
|
||||
TRACK_ROW_PADDING,
|
||||
type SelectionRangePosition,
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
import { sumDurationSeconds } from "@/lib/media-summary"
|
||||
import { albumDetailSongs, rememberSongs } from "@/lib/song-cache"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
|
||||
function formatMetadata(genre: string | null, year: number | null): string | null {
|
||||
const parts: string[] = []
|
||||
@@ -95,159 +92,6 @@ function groupAlbumTracksByDisk(tracks: BrowseAlbumTrack[]): AlbumTrackSection[]
|
||||
return sections
|
||||
}
|
||||
|
||||
function TrackRow({
|
||||
track,
|
||||
sectionIndex,
|
||||
artist,
|
||||
isActive,
|
||||
isSelected,
|
||||
selectionPosition,
|
||||
isFavorite,
|
||||
selectedCount,
|
||||
onSelect,
|
||||
onPointerDown,
|
||||
onToggleFavorite,
|
||||
onPrepareContextMenu,
|
||||
onMediaAction,
|
||||
isNowPlaying,
|
||||
onPlay,
|
||||
albumId,
|
||||
}: {
|
||||
track: BrowseAlbumTrack
|
||||
sectionIndex: number
|
||||
artist: BrowseAlbumDetail["artist"]
|
||||
albumId: string
|
||||
isActive: boolean
|
||||
isSelected: boolean
|
||||
selectionPosition: SelectionRangePosition
|
||||
isFavorite: boolean
|
||||
selectedCount: number
|
||||
onSelect: (event: React.MouseEvent) => void
|
||||
onPointerDown: (event: React.MouseEvent) => void
|
||||
onToggleFavorite: () => void
|
||||
onPrepareContextMenu: () => void
|
||||
onMediaAction: (action: MediaContextAction, trackId: string) => void
|
||||
isNowPlaying: boolean
|
||||
onPlay: () => void
|
||||
}) {
|
||||
const displayTrack =
|
||||
track.track > 0 ? track.track : sectionIndex + 1
|
||||
const inRange = isInSelectionRange(selectionPosition)
|
||||
|
||||
return (
|
||||
<div
|
||||
role="button"
|
||||
tabIndex={0}
|
||||
onMouseDown={onPointerDown}
|
||||
onClick={onSelect}
|
||||
onDoubleClick={(event) => {
|
||||
event.preventDefault()
|
||||
onPlay()
|
||||
}}
|
||||
onKeyDown={(event) => {
|
||||
if (event.key === "Enter" || event.key === " ") {
|
||||
event.preventDefault()
|
||||
onSelect(event as unknown as React.MouseEvent)
|
||||
}
|
||||
}}
|
||||
className={cn(
|
||||
"group relative w-full cursor-pointer select-none py-2.5 text-left text-sm transition-colors",
|
||||
inRange && "text-primary-foreground"
|
||||
)}
|
||||
>
|
||||
<SelectionRangeHighlight position={selectionPosition} />
|
||||
{!inRange && isActive ? <TrackRowActiveHighlight /> : null}
|
||||
{!inRange && !isActive ? <TrackRowHoverHighlight /> : null}
|
||||
<div
|
||||
className={cn("relative z-10", ALBUM_TRACK_ROW, TRACK_ROW_PADDING)}
|
||||
>
|
||||
<div className="flex shrink-0 items-center justify-center">
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="icon-sm"
|
||||
className={cn(
|
||||
"size-8 opacity-0 transition-opacity group-hover:opacity-100",
|
||||
inRange
|
||||
? "text-primary-foreground hover:bg-white/15 hover:text-primary-foreground"
|
||||
: "text-primary hover:text-primary",
|
||||
(isFavorite || isActive || isSelected) && "opacity-100"
|
||||
)}
|
||||
aria-label={
|
||||
isFavorite
|
||||
? `Remove ${track.title} from favorites`
|
||||
: `Favorite ${track.title}`
|
||||
}
|
||||
onClick={(event) => {
|
||||
event.stopPropagation()
|
||||
onToggleFavorite()
|
||||
}}
|
||||
>
|
||||
<Star
|
||||
className={cn(
|
||||
"size-4",
|
||||
isFavorite && (inRange ? "fill-current" : "fill-primary")
|
||||
)}
|
||||
/>
|
||||
</Button>
|
||||
</div>
|
||||
|
||||
<TrackNumberPlayButton
|
||||
displayTrack={displayTrack}
|
||||
title={track.title}
|
||||
isActive={isActive}
|
||||
isNowPlaying={isNowPlaying}
|
||||
inRange={inRange}
|
||||
onPlay={onPlay}
|
||||
/>
|
||||
|
||||
<div className="min-w-0 flex-1">
|
||||
<div className={ALBUM_TRACK_TITLE}>{track.title}</div>
|
||||
{track.artists ? (
|
||||
<p
|
||||
className={cn(
|
||||
"truncate text-xs",
|
||||
inRange
|
||||
? "text-primary-foreground/80"
|
||||
: "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{track.artists.join(", ")}
|
||||
</p>
|
||||
) : null}
|
||||
</div>
|
||||
|
||||
<span
|
||||
className={cn(
|
||||
"shrink-0 text-right tabular-nums",
|
||||
inRange ? "text-primary-foreground" : "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{formatDuration(track.durationSeconds)}
|
||||
</span>
|
||||
|
||||
<MediaContextMenu
|
||||
label={`More options for ${track.title}`}
|
||||
stationArtistId={artist.id}
|
||||
selectedCount={selectedCount}
|
||||
inSelectionRange={inRange}
|
||||
onOpenMenu={onPrepareContextMenu}
|
||||
onAction={(action) => onMediaAction(action, track.id)}
|
||||
favorited={isFavorite}
|
||||
navigation={{
|
||||
artist: { id: artist.id },
|
||||
album: { id: albumId },
|
||||
}}
|
||||
share={{
|
||||
type: "song",
|
||||
albumId,
|
||||
songId: track.id,
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
export function AlbumView({
|
||||
album,
|
||||
highlightedSongId,
|
||||
@@ -255,17 +99,15 @@ export function AlbumView({
|
||||
album: BrowseAlbumDetail
|
||||
highlightedSongId?: string
|
||||
}) {
|
||||
const { openAddToPlaylist } = useAddToPlaylist()
|
||||
const {
|
||||
isSongFavorite,
|
||||
isAlbumFavorite,
|
||||
toggleSongFavorite,
|
||||
toggleAlbumFavorite,
|
||||
favoriteSongs,
|
||||
} = useFavorites()
|
||||
const { currentSong, playFromSong, playAlbum, playAlbumShuffled } =
|
||||
usePlayback()
|
||||
const { runQueueAction, createStation } = useQueueMediaActions()
|
||||
const { runSongsAction } = useMediaActions()
|
||||
const albumSongIds = React.useMemo(
|
||||
() => album.tracks.map((track) => track.id as Id<"songs">),
|
||||
[album.tracks]
|
||||
@@ -303,7 +145,6 @@ export function AlbumView({
|
||||
const {
|
||||
selectedIds,
|
||||
selectedCount,
|
||||
isSelected,
|
||||
handleSelect,
|
||||
handlePointerDown,
|
||||
prepareContextMenu,
|
||||
@@ -331,55 +172,55 @@ export function AlbumView({
|
||||
return indexById
|
||||
}, [album.tracks])
|
||||
|
||||
function handleMediaAction(
|
||||
action: MediaContextAction,
|
||||
fallbackTrackId?: string
|
||||
) {
|
||||
const targetIds =
|
||||
selectedIds.size > 0
|
||||
? Array.from(selectedIds)
|
||||
: fallbackTrackId
|
||||
? [fallbackTrackId]
|
||||
: activeTrackId
|
||||
? [activeTrackId]
|
||||
: []
|
||||
switch (action) {
|
||||
case "create-station":
|
||||
void createStation(album.artist.id)
|
||||
break
|
||||
case "favorite":
|
||||
void favoriteSongs(targetIds as Id<"songs">[])
|
||||
break
|
||||
case "playlist":
|
||||
openAddToPlaylist(targetIds as Id<"songs">[])
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle":
|
||||
void runQueueAction(action, targetIds as Id<"songs">[])
|
||||
break
|
||||
}
|
||||
}
|
||||
const trackSongs = React.useMemo(
|
||||
() =>
|
||||
new Map<string, BrowseSong>(
|
||||
album.tracks.map((track) => [
|
||||
track.id,
|
||||
{
|
||||
id: track.id,
|
||||
title: track.title,
|
||||
durationSeconds: track.durationSeconds,
|
||||
artist: album.artist,
|
||||
album: { id: album.id, title: album.title, cover: album.cover },
|
||||
},
|
||||
])
|
||||
),
|
||||
[album.tracks, album.artist, album.id, album.title, album.cover]
|
||||
)
|
||||
|
||||
const handleMediaAction = useTrackListMediaAction({
|
||||
selectedIds,
|
||||
artistId: album.artist.id,
|
||||
})
|
||||
|
||||
const handleRowSelect = React.useCallback(
|
||||
(index: number, event: React.MouseEvent) => {
|
||||
const trackId = album.tracks[index].id
|
||||
handleSelect(trackId, index, event)
|
||||
setActiveTrackId(trackId)
|
||||
},
|
||||
[album.tracks, handleSelect]
|
||||
)
|
||||
|
||||
const handleRowPlay = React.useCallback(
|
||||
(index: number) => {
|
||||
void playFromSong(album.tracks[index].id, albumSongIds, `album:${album.id}`)
|
||||
},
|
||||
[album.tracks, album.id, albumSongIds, playFromSong]
|
||||
)
|
||||
|
||||
const handleToggleFavorite = React.useCallback(
|
||||
(songId: string) => void toggleSongFavorite(songId as Id<"songs">),
|
||||
[toggleSongFavorite]
|
||||
)
|
||||
|
||||
function handleAlbumMediaAction(action: MediaContextAction) {
|
||||
const targetIds = album.tracks.map((track) => track.id as Id<"songs">)
|
||||
|
||||
switch (action) {
|
||||
case "create-station":
|
||||
void createStation(album.artist.id)
|
||||
break
|
||||
case "favorite":
|
||||
void toggleAlbumFavorite(album.id as Id<"albums">)
|
||||
break
|
||||
case "playlist":
|
||||
openAddToPlaylist(targetIds)
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle":
|
||||
void runQueueAction(action, targetIds)
|
||||
break
|
||||
if (action === "favorite") {
|
||||
void toggleAlbumFavorite(album.id as Id<"albums">)
|
||||
return
|
||||
}
|
||||
runSongsAction(action, albumSongIds, album.artist.id)
|
||||
}
|
||||
|
||||
return (
|
||||
@@ -513,39 +354,25 @@ export function AlbumView({
|
||||
return (
|
||||
<TrackRow
|
||||
key={track.id}
|
||||
track={track}
|
||||
sectionIndex={sectionTrackIndex}
|
||||
artist={album.artist}
|
||||
albumId={album.id}
|
||||
variant="album"
|
||||
song={trackSongs.get(track.id)!}
|
||||
index={listIndex}
|
||||
trackNumber={
|
||||
track.track > 0 ? track.track : sectionTrackIndex + 1
|
||||
}
|
||||
subtitle={track.artists?.join(", ")}
|
||||
isActive={track.id === activeTrackId}
|
||||
isSelected={isSelected(track.id)}
|
||||
selectionPosition={selectionPositions[listIndex]}
|
||||
isFavorite={isSongFavorite(track.id)}
|
||||
selectedCount={
|
||||
isSelected(track.id) && selectedCount > 0
|
||||
? selectedCount
|
||||
: 1
|
||||
}
|
||||
onPointerDown={handlePointerDown}
|
||||
onSelect={(event) => {
|
||||
handleSelect(track.id, listIndex, event)
|
||||
setActiveTrackId(track.id)
|
||||
}}
|
||||
onToggleFavorite={() =>
|
||||
void toggleSongFavorite(track.id as Id<"songs">)
|
||||
}
|
||||
onPrepareContextMenu={() =>
|
||||
prepareContextMenu(track.id)
|
||||
}
|
||||
onMediaAction={handleMediaAction}
|
||||
selectedCount={selectedCount}
|
||||
selectionStationArtistId={album.artist.id}
|
||||
isNowPlaying={currentSong?.id === track.id}
|
||||
onPlay={() =>
|
||||
void playFromSong(
|
||||
track.id as Id<"songs">,
|
||||
albumSongIds,
|
||||
`album:${album.id}`
|
||||
)
|
||||
}
|
||||
onPointerDown={handlePointerDown}
|
||||
onSelect={handleRowSelect}
|
||||
onPlay={handleRowPlay}
|
||||
onToggleFavorite={handleToggleFavorite}
|
||||
onPrepareContextMenu={prepareContextMenu}
|
||||
onMediaAction={handleMediaAction}
|
||||
/>
|
||||
)
|
||||
})}
|
||||
|
||||
@@ -4,27 +4,19 @@ import { PageHeader } from "@/components/library-skeletons"
|
||||
import * as React from "react"
|
||||
import Image from "next/image"
|
||||
import { Play, Shuffle } from "lucide-react"
|
||||
import { useConvex } from "convex/react"
|
||||
|
||||
import { useCacheScope } from "@/components/persistent-cache-provider"
|
||||
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
|
||||
import { useFavorites } from "@/components/favorites-provider"
|
||||
import { usePlayback } from "@/components/playback-provider"
|
||||
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
|
||||
import { useMediaActions } from "@/hooks/use-media-actions"
|
||||
import { AlbumCard } from "@/components/album-card"
|
||||
import { FavoriteMediaButton } from "@/components/favorite-media-button"
|
||||
import {
|
||||
MediaContextMenu,
|
||||
type MediaContextAction,
|
||||
} from "@/components/media-context-menu"
|
||||
import { MediaContextMenu } from "@/components/media-context-menu"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import { ScrollArea } from "@/components/ui/scroll-area"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseAlbum, BrowseArtist } from "@otunes/convex/types"
|
||||
import { albumGridClassName } from "@/lib/album-grid-classes"
|
||||
import { artistCoverUrl } from "@/lib/cover-urls"
|
||||
import { fetchCachedQuery } from "@otunes/convex/client/cached-query"
|
||||
|
||||
export function ArtistView({
|
||||
artist,
|
||||
@@ -34,34 +26,8 @@ export function ArtistView({
|
||||
albums: BrowseAlbum[]
|
||||
}) {
|
||||
const { isArtistFavorite, toggleArtistFavorite } = useFavorites()
|
||||
const { openAddArtistToPlaylist } = useAddToPlaylist()
|
||||
const { playArtist, playArtistShuffled } = usePlayback()
|
||||
const { runQueueAction } = useQueueMediaActions()
|
||||
const convex = useConvex()
|
||||
const cacheScope = useCacheScope()
|
||||
|
||||
async function handleMediaAction(action: MediaContextAction) {
|
||||
switch (action) {
|
||||
case "favorite":
|
||||
void toggleArtistFavorite(artist.id as Id<"artists">)
|
||||
break
|
||||
case "playlist":
|
||||
void openAddArtistToPlaylist(artist.id as Id<"artists">)
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle": {
|
||||
const songIds = await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId: artist.id as Id<"artists"> }
|
||||
)
|
||||
void runQueueAction(action, songIds)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
const { runArtistAction } = useMediaActions()
|
||||
|
||||
return (
|
||||
<div className="flex h-svh flex-col">
|
||||
@@ -118,7 +84,7 @@ export function ArtistView({
|
||||
label={`More options for ${artist.name}`}
|
||||
selectedCount={albums.length}
|
||||
onOpenMenu={() => {}}
|
||||
onAction={handleMediaAction}
|
||||
onAction={(action) => void runArtistAction(action, artist.id)}
|
||||
favorited={isArtistFavorite(artist.id)}
|
||||
trackRowTrigger={false}
|
||||
triggerVariant="secondary"
|
||||
|
||||
@@ -4,11 +4,8 @@ import * as React from "react"
|
||||
import Image from "next/image"
|
||||
import Link from "next/link"
|
||||
import { ChevronRightIcon, Play, Shuffle } from "lucide-react"
|
||||
import { useConvex } from "convex/react"
|
||||
|
||||
import { useCacheScope } from "@/components/persistent-cache-provider"
|
||||
import { AlbumCard } from "@/components/album-card"
|
||||
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
|
||||
import { FavoriteMediaButton } from "@/components/favorite-media-button"
|
||||
import { useFavorites } from "@/components/favorites-provider"
|
||||
import {
|
||||
@@ -16,15 +13,13 @@ import {
|
||||
type MediaContextAction,
|
||||
} from "@/components/media-context-menu"
|
||||
import { usePlayback } from "@/components/playback-provider"
|
||||
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
|
||||
import { useMediaActions } from "@/hooks/use-media-actions"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import { ScrollArea } from "@/components/ui/scroll-area"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import { cn } from "@/lib/utils"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseAlbum, BrowseArtist } from "@otunes/convex/types"
|
||||
import { artistCoverUrl } from "@/lib/cover-urls"
|
||||
import { fetchCachedQuery } from "@otunes/convex/client/cached-query"
|
||||
|
||||
function ArtistAvatar({ artist }: { artist: BrowseArtist }) {
|
||||
return (
|
||||
@@ -110,12 +105,9 @@ export function ArtistsView({
|
||||
}
|
||||
return sortedArtists[0]?.id ?? ""
|
||||
}, [artistId, sortedArtists])
|
||||
const convex = useConvex()
|
||||
const cacheScope = useCacheScope()
|
||||
const { openAddArtistToPlaylist } = useAddToPlaylist()
|
||||
const { isArtistFavorite, toggleArtistFavorite } = useFavorites()
|
||||
const { playArtist, playArtistShuffled } = usePlayback()
|
||||
const { runQueueAction } = useQueueMediaActions()
|
||||
const { runArtistAction } = useMediaActions()
|
||||
|
||||
const selectedArtist = sortedArtists.find(
|
||||
(artist) => artist.id === selectedId
|
||||
@@ -130,32 +122,6 @@ export function ArtistsView({
|
||||
return counts
|
||||
}, [albums])
|
||||
|
||||
async function handleMediaAction(
|
||||
artistId: string,
|
||||
action: MediaContextAction
|
||||
) {
|
||||
switch (action) {
|
||||
case "favorite":
|
||||
void toggleArtistFavorite(artistId as Id<"artists">)
|
||||
break
|
||||
case "playlist":
|
||||
void openAddArtistToPlaylist(artistId as Id<"artists">)
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle": {
|
||||
const songIds = await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId: artistId as Id<"artists"> }
|
||||
)
|
||||
void runQueueAction(action, songIds)
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="flex min-h-0 flex-1">
|
||||
<ScrollArea className="w-72 shrink-0 border-r">
|
||||
@@ -169,7 +135,7 @@ export function ArtistsView({
|
||||
isFavorite={isArtistFavorite(artist.id)}
|
||||
onSelect={() => onSelectArtist(artist.id)}
|
||||
onMediaAction={(action) =>
|
||||
void handleMediaAction(artist.id, action)
|
||||
void runArtistAction(action, artist.id)
|
||||
}
|
||||
/>
|
||||
))}
|
||||
@@ -225,7 +191,7 @@ export function ArtistsView({
|
||||
selectedCount={artistAlbums.length}
|
||||
onOpenMenu={() => {}}
|
||||
onAction={(action) =>
|
||||
void handleMediaAction(selectedArtist.id, action)
|
||||
void runArtistAction(action, selectedArtist.id)
|
||||
}
|
||||
favorited={isArtistFavorite(selectedArtist.id)}
|
||||
trackRowTrigger={false}
|
||||
|
||||
@@ -9,15 +9,14 @@ import { useMutation } from "convex/react"
|
||||
import { Play, SearchIcon, Share2, Shuffle, Star, Trash2 } from "lucide-react"
|
||||
import { toast } from "sonner"
|
||||
|
||||
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
|
||||
import { useFavorites } from "@/components/favorites-provider"
|
||||
import { usePlayback } from "@/components/playback-provider"
|
||||
import { MediaCollectionFooter } from "@/components/media-collection-footer"
|
||||
import { TrackNumberPlayButton } from "@/components/track-number-play-button"
|
||||
import {
|
||||
MediaContextMenu,
|
||||
type MediaContextAction,
|
||||
} from "@/components/media-context-menu"
|
||||
import { TrackRow } from "@/components/track-row"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import {
|
||||
DropdownMenuItem,
|
||||
@@ -25,243 +24,22 @@ import {
|
||||
} from "@/components/ui/dropdown-menu"
|
||||
import { ScrollArea } from "@/components/ui/scroll-area"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
|
||||
import {
|
||||
useMediaActions,
|
||||
useTrackListMediaAction,
|
||||
} from "@/hooks/use-media-actions"
|
||||
import { useTrackSelection } from "@/hooks/use-track-selection"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowsePlaylistDetail, BrowseSong } from "@otunes/convex/types"
|
||||
import { albumCoverUrl, playlistCoverUrl } from "@/lib/cover-urls"
|
||||
import { playlistCoverUrl } from "@/lib/cover-urls"
|
||||
import { copyPlaylistLink } from "@/lib/media-links"
|
||||
import { sumDurationSeconds } from "@/lib/media-summary"
|
||||
import { rememberSongs } from "@/lib/song-cache"
|
||||
import { cn } from "@/lib/utils"
|
||||
import {
|
||||
getSelectionRangePositions,
|
||||
isInSelectionRange,
|
||||
ALBUM_TRACK_ROW,
|
||||
ALBUM_TRACK_TITLE,
|
||||
SelectionRangeHighlight,
|
||||
TrackRowActiveHighlight,
|
||||
TrackRowHoverHighlight,
|
||||
TRACK_ROW_PADDING,
|
||||
type SelectionRangePosition,
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
import { getSelectionRangePositions } from "@/lib/selection-range-styles"
|
||||
|
||||
const ADD_TO_ANOTHER_PLAYLIST = "Add to Another Playlist"
|
||||
|
||||
function PlaylistSongCover({
|
||||
song,
|
||||
inRange,
|
||||
isFavorite,
|
||||
onToggleFavorite,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
inRange: boolean
|
||||
isFavorite: boolean
|
||||
onToggleFavorite: () => void
|
||||
}) {
|
||||
return (
|
||||
<div
|
||||
className={cn(
|
||||
"group/cover relative size-10 shrink-0 overflow-hidden rounded ring-1",
|
||||
inRange ? "ring-white/25" : "ring-foreground/10"
|
||||
)}
|
||||
>
|
||||
<Image
|
||||
src={albumCoverUrl(song.album.id)}
|
||||
alt={song.album.title}
|
||||
fill
|
||||
sizes="40px"
|
||||
className="object-cover"
|
||||
/>
|
||||
<div
|
||||
className={cn(
|
||||
"absolute inset-0 flex items-center justify-center bg-black/0 opacity-0 transition-opacity group-hover/cover:opacity-100",
|
||||
"group-hover/cover:bg-black/40"
|
||||
)}
|
||||
>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="icon-sm"
|
||||
className={cn(
|
||||
"size-8",
|
||||
inRange
|
||||
? "text-primary-foreground hover:bg-white/15 hover:text-primary-foreground"
|
||||
: "text-primary hover:text-primary"
|
||||
)}
|
||||
aria-label={
|
||||
isFavorite
|
||||
? `Remove ${song.title} from favorites`
|
||||
: `Favorite ${song.title}`
|
||||
}
|
||||
onClick={(event) => {
|
||||
event.stopPropagation()
|
||||
onToggleFavorite()
|
||||
}}
|
||||
>
|
||||
<Star
|
||||
className={cn(
|
||||
"size-4",
|
||||
isFavorite && (inRange ? "fill-current" : "fill-primary")
|
||||
)}
|
||||
/>
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function PlaylistSongRow({
|
||||
song,
|
||||
index,
|
||||
isOwner,
|
||||
canRemove,
|
||||
isActive,
|
||||
selectionPosition,
|
||||
isFavorite,
|
||||
selectedCount,
|
||||
stationArtist,
|
||||
isDragging,
|
||||
onSelect,
|
||||
onPointerDown,
|
||||
onToggleFavorite,
|
||||
onPrepareContextMenu,
|
||||
onMediaAction,
|
||||
onRemove,
|
||||
onDragStart,
|
||||
onDragOver,
|
||||
onDrop,
|
||||
showFavoriteInMenu = true,
|
||||
removeLabel = "Remove from Playlist",
|
||||
isNowPlaying,
|
||||
onPlay,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
index: number
|
||||
isOwner: boolean
|
||||
canRemove: boolean
|
||||
isActive: boolean
|
||||
selectionPosition: SelectionRangePosition
|
||||
isFavorite: boolean
|
||||
selectedCount: number
|
||||
stationArtist?: string
|
||||
isDragging: boolean
|
||||
onSelect: (event: React.MouseEvent) => void
|
||||
onPointerDown: (event: React.MouseEvent) => void
|
||||
onToggleFavorite: () => void
|
||||
onPrepareContextMenu: () => void
|
||||
onMediaAction: (action: MediaContextAction, songId: string) => void
|
||||
onRemove: () => void
|
||||
onDragStart: (event: React.DragEvent) => void
|
||||
onDragOver: (event: React.DragEvent) => void
|
||||
onDrop: (event: React.DragEvent) => void
|
||||
showFavoriteInMenu?: boolean
|
||||
removeLabel?: string
|
||||
isNowPlaying: boolean
|
||||
onPlay: () => void
|
||||
}) {
|
||||
const displayTrack = index + 1
|
||||
const inRange = isInSelectionRange(selectionPosition)
|
||||
|
||||
return (
|
||||
<div
|
||||
role="button"
|
||||
tabIndex={0}
|
||||
draggable={isOwner}
|
||||
onDragStart={onDragStart}
|
||||
onDragOver={onDragOver}
|
||||
onDrop={onDrop}
|
||||
onMouseDown={onPointerDown}
|
||||
onClick={onSelect}
|
||||
onDoubleClick={(event) => {
|
||||
event.preventDefault()
|
||||
onPlay()
|
||||
}}
|
||||
onKeyDown={(event) => {
|
||||
if (event.key === "Enter" || event.key === " ") {
|
||||
event.preventDefault()
|
||||
onSelect(event as unknown as React.MouseEvent)
|
||||
}
|
||||
}}
|
||||
className={cn(
|
||||
"group relative w-full cursor-pointer select-none py-2.5 text-left text-sm transition-colors",
|
||||
inRange && "text-primary-foreground",
|
||||
isDragging && "opacity-50"
|
||||
)}
|
||||
>
|
||||
<SelectionRangeHighlight position={selectionPosition} />
|
||||
{!inRange && isActive ? <TrackRowActiveHighlight /> : null}
|
||||
{!inRange && !isActive ? <TrackRowHoverHighlight /> : null}
|
||||
<div
|
||||
className={cn("relative z-10", ALBUM_TRACK_ROW, TRACK_ROW_PADDING)}
|
||||
>
|
||||
<PlaylistSongCover
|
||||
song={song}
|
||||
inRange={inRange}
|
||||
isFavorite={isFavorite}
|
||||
onToggleFavorite={onToggleFavorite}
|
||||
/>
|
||||
|
||||
<TrackNumberPlayButton
|
||||
displayTrack={displayTrack}
|
||||
title={song.title}
|
||||
isActive={isActive}
|
||||
isNowPlaying={isNowPlaying}
|
||||
inRange={inRange}
|
||||
onPlay={onPlay}
|
||||
/>
|
||||
|
||||
<span className={ALBUM_TRACK_TITLE}>{song.title}</span>
|
||||
|
||||
<span
|
||||
className={cn(
|
||||
"shrink-0 text-right tabular-nums",
|
||||
inRange ? "text-primary-foreground" : "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{formatDuration(song.durationSeconds)}
|
||||
</span>
|
||||
|
||||
<MediaContextMenu
|
||||
label={`More options for ${song.title}`}
|
||||
stationArtistId={stationArtist}
|
||||
selectedCount={selectedCount}
|
||||
inSelectionRange={inRange}
|
||||
onOpenMenu={onPrepareContextMenu}
|
||||
onAction={(action) => onMediaAction(action, song.id)}
|
||||
playlistLabel={ADD_TO_ANOTHER_PLAYLIST}
|
||||
showFavorite={showFavoriteInMenu}
|
||||
favorited={isFavorite}
|
||||
navigation={{
|
||||
artist: { id: song.artist.id },
|
||||
album: { id: song.album.id },
|
||||
}}
|
||||
share={{
|
||||
type: "song",
|
||||
albumId: song.album.id,
|
||||
songId: song.id,
|
||||
}}
|
||||
>
|
||||
{canRemove ? (
|
||||
<>
|
||||
<DropdownMenuSeparator />
|
||||
<DropdownMenuItem
|
||||
variant="destructive"
|
||||
className="justify-between"
|
||||
onClick={onRemove}
|
||||
>
|
||||
{removeLabel}
|
||||
<Trash2 />
|
||||
</DropdownMenuItem>
|
||||
</>
|
||||
) : null}
|
||||
</MediaContextMenu>
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
const router = useRouter()
|
||||
const isFavorites = playlist.isFavorites === true
|
||||
@@ -270,13 +48,8 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
currentUser === undefined
|
||||
? playlist.isOwner
|
||||
: currentUser?._id === playlist.owner.id
|
||||
const { openAddToPlaylist } = useAddToPlaylist()
|
||||
const {
|
||||
isSongFavorite,
|
||||
toggleSongFavorite,
|
||||
toggleSongsFavorite,
|
||||
favoriteSongs: addFavoriteSongs,
|
||||
} = useFavorites()
|
||||
const { isSongFavorite, toggleSongFavorite, toggleSongsFavorite } =
|
||||
useFavorites()
|
||||
const {
|
||||
currentSong,
|
||||
playInOrder,
|
||||
@@ -285,7 +58,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
playPlaylistShuffled,
|
||||
playFromSong,
|
||||
} = usePlayback()
|
||||
const { runQueueAction, createStation } = useQueueMediaActions()
|
||||
const { runSongsAction } = useMediaActions()
|
||||
const removeSongs = useMutation(api.playlists.removeSongsFromPlaylist)
|
||||
const reorderSongs = useMutation(api.playlists.reorderPlaylistSongs)
|
||||
const deletePlaylist = useMutation(api.playlists.deletePlaylist)
|
||||
@@ -317,6 +90,10 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
() => songs.map((song) => song.id as Id<"songs">),
|
||||
[songs]
|
||||
)
|
||||
const playlistPositionById = React.useMemo(
|
||||
() => new Map(songs.map((song, index) => [song.id, index + 1])),
|
||||
[songs]
|
||||
)
|
||||
const [activeTrackId, setActiveTrackId] = React.useState("")
|
||||
const [dragIndex, setDragIndex] = React.useState<number | null>(null)
|
||||
const [isSubscribed, setIsSubscribed] = React.useState(playlist.isSubscribed)
|
||||
@@ -331,7 +108,6 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
const {
|
||||
selectedIds,
|
||||
selectedCount,
|
||||
isSelected,
|
||||
handleSelect,
|
||||
handlePointerDown,
|
||||
prepareContextMenu,
|
||||
@@ -369,57 +145,37 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
}
|
||||
}
|
||||
|
||||
function resolveTargetIds(fallbackSongId?: string) {
|
||||
return selectedIds.size > 0
|
||||
? Array.from(selectedIds)
|
||||
: fallbackSongId
|
||||
? [fallbackSongId]
|
||||
: activeTrackId
|
||||
? [activeTrackId]
|
||||
: []
|
||||
}
|
||||
|
||||
function handleMediaAction(
|
||||
action: MediaContextAction,
|
||||
fallbackSongId?: string
|
||||
) {
|
||||
const targetIds = resolveTargetIds(fallbackSongId)
|
||||
|
||||
switch (action) {
|
||||
case "create-station": {
|
||||
const artistId = stationArtistId(songs, new Set(targetIds))
|
||||
if (artistId) void createStation(artistId)
|
||||
break
|
||||
}
|
||||
case "favorite":
|
||||
void addFavoriteSongs(targetIds as Id<"songs">[])
|
||||
break
|
||||
case "playlist":
|
||||
openAddToPlaylist(targetIds as Id<"songs">[])
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle":
|
||||
void runQueueAction(action, targetIds as Id<"songs">[])
|
||||
break
|
||||
}
|
||||
}
|
||||
const handleMediaAction = useTrackListMediaAction({ selectedIds, songs })
|
||||
|
||||
function handlePlaylistMediaAction(action: MediaContextAction) {
|
||||
const targetIds = songs.map((song) => song.id as Id<"songs">)
|
||||
runSongsAction(action, playlistSongIds)
|
||||
}
|
||||
|
||||
switch (action) {
|
||||
case "favorite":
|
||||
void addFavoriteSongs(targetIds)
|
||||
break
|
||||
case "playlist":
|
||||
openAddToPlaylist(targetIds)
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle":
|
||||
void runQueueAction(action, targetIds)
|
||||
break
|
||||
const canReorder = isOwner && !isFavorites && !normalizedQuery
|
||||
|
||||
function handleRowSelect(index: number, event: React.MouseEvent) {
|
||||
const songId = filteredSongs[index].id
|
||||
handleSelect(songId, index, event)
|
||||
setActiveTrackId(songId)
|
||||
}
|
||||
|
||||
function handleRowPlay(index: number) {
|
||||
void playFromSong(
|
||||
filteredSongs[index].id,
|
||||
playlistSongIds,
|
||||
`playlist:${playlist.id}`
|
||||
)
|
||||
}
|
||||
|
||||
function handleToggleFavorite(songId: string) {
|
||||
const wasFavorite = isSongFavorite(songId)
|
||||
void toggleSongFavorite(songId as Id<"songs">)
|
||||
if (isFavorites && wasFavorite) {
|
||||
setHiddenFavoriteIds((current) => {
|
||||
const next = new Set(current)
|
||||
next.add(songId)
|
||||
return next
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -474,13 +230,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
}
|
||||
|
||||
function handleDrop(targetIndex: number) {
|
||||
if (
|
||||
normalizedQuery ||
|
||||
isFavorites ||
|
||||
!isOwner ||
|
||||
dragIndex === null ||
|
||||
dragIndex === targetIndex
|
||||
) {
|
||||
if (!canReorder || dragIndex === null || dragIndex === targetIndex) {
|
||||
setDragIndex(null)
|
||||
return
|
||||
}
|
||||
@@ -672,74 +422,37 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
|
||||
</div>
|
||||
{filteredSongs.length > 0 ? (
|
||||
filteredSongs.map((song, index) => (
|
||||
<PlaylistSongRow
|
||||
<TrackRow
|
||||
key={song.id}
|
||||
variant="playlist"
|
||||
song={song}
|
||||
index={index}
|
||||
isOwner={isOwner && !isFavorites && !normalizedQuery}
|
||||
canRemove={isFavorites || isOwner}
|
||||
trackNumber={playlistPositionById.get(song.id)}
|
||||
isActive={song.id === activeTrackId}
|
||||
isNowPlaying={currentSong?.id === song.id}
|
||||
isFavorite={isSongFavorite(song.id)}
|
||||
isDragging={dragIndex === index}
|
||||
selectionPosition={selectionPositions[index]}
|
||||
selectedCount={selectedCount}
|
||||
selectionStationArtistId={selectedStationArtistId}
|
||||
playlistLabel={ADD_TO_ANOTHER_PLAYLIST}
|
||||
showFavoriteInMenu={!isFavorites}
|
||||
removeLabel={
|
||||
isFavorites ? "Unfavorite" : "Remove from Playlist"
|
||||
isFavorites
|
||||
? "Unfavorite"
|
||||
: isOwner
|
||||
? "Remove from Playlist"
|
||||
: undefined
|
||||
}
|
||||
isActive={song.id === activeTrackId}
|
||||
selectionPosition={selectionPositions[index]}
|
||||
isFavorite={isSongFavorite(song.id)}
|
||||
selectedCount={
|
||||
isSelected(song.id) && selectedCount > 0
|
||||
? selectedCount
|
||||
: 1
|
||||
}
|
||||
stationArtist={
|
||||
isSelected(song.id)
|
||||
? selectedStationArtistId
|
||||
: song.artist.id
|
||||
}
|
||||
isDragging={dragIndex === index}
|
||||
onPointerDown={handlePointerDown}
|
||||
onSelect={(event) => {
|
||||
handleSelect(song.id, index, event)
|
||||
setActiveTrackId(song.id)
|
||||
}}
|
||||
onToggleFavorite={() => {
|
||||
const wasFavorite = isSongFavorite(song.id)
|
||||
void toggleSongFavorite(song.id as Id<"songs">)
|
||||
if (isFavorites && wasFavorite) {
|
||||
setHiddenFavoriteIds((current) => {
|
||||
const next = new Set(current)
|
||||
next.add(song.id)
|
||||
return next
|
||||
})
|
||||
}
|
||||
}}
|
||||
onPrepareContextMenu={() => prepareContextMenu(song.id)}
|
||||
onSelect={handleRowSelect}
|
||||
onPlay={handleRowPlay}
|
||||
onToggleFavorite={handleToggleFavorite}
|
||||
onPrepareContextMenu={prepareContextMenu}
|
||||
onMediaAction={handleMediaAction}
|
||||
onRemove={() => handleRemoveSong(song.id)}
|
||||
onDragStart={(event) => {
|
||||
if (normalizedQuery || isFavorites || !isOwner) {
|
||||
return
|
||||
}
|
||||
setDragIndex(index)
|
||||
event.dataTransfer.effectAllowed = "move"
|
||||
}}
|
||||
onDragOver={(event) => {
|
||||
if (normalizedQuery || isFavorites || !isOwner) {
|
||||
return
|
||||
}
|
||||
event.preventDefault()
|
||||
}}
|
||||
onDrop={(event) => {
|
||||
event.preventDefault()
|
||||
handleDrop(index)
|
||||
}}
|
||||
isNowPlaying={currentSong?.id === song.id}
|
||||
onPlay={() =>
|
||||
void playFromSong(
|
||||
song.id as Id<"songs">,
|
||||
playlistSongIds,
|
||||
`playlist:${playlist.id}`
|
||||
)
|
||||
}
|
||||
onRemove={handleRemoveSong}
|
||||
onDragStart={canReorder ? setDragIndex : undefined}
|
||||
onDrop={canReorder ? handleDrop : undefined}
|
||||
/>
|
||||
))
|
||||
) : (
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
"use client"
|
||||
|
||||
import * as React from "react"
|
||||
import Image from "next/image"
|
||||
import { Music2 } from "lucide-react"
|
||||
|
||||
import { PlaybackSongMeta } from "@/components/playback-song-meta"
|
||||
import { usePlayback } from "@/components/playback-provider"
|
||||
import { TrackCover, TrackRow } from "@/components/track-row"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import { ScrollArea } from "@/components/ui/scroll-area"
|
||||
import { Skeleton } from "@/components/ui/skeleton"
|
||||
@@ -13,19 +12,11 @@ import { Spinner } from "@/components/ui/spinner"
|
||||
import { useTrackSelection } from "@/hooks/use-track-selection"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseSong, HistorySong, QueueSong } from "@otunes/convex/types"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
import {
|
||||
getContiguousSelectedIndices,
|
||||
moveQueueBlock,
|
||||
} from "@/lib/move-queue-block"
|
||||
import {
|
||||
getSelectionRangePositions,
|
||||
isInSelectionRange,
|
||||
QueueSelectionRangeHighlight,
|
||||
QueueTrackRowActiveHighlight,
|
||||
QueueTrackRowHoverHighlight,
|
||||
type SelectionRangePosition,
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { getSelectionRangePositions } from "@/lib/selection-range-styles"
|
||||
import { useSongs } from "@/lib/song-cache"
|
||||
import { cn } from "@/lib/utils"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
@@ -56,48 +47,16 @@ function toSelectableQueue(
|
||||
})
|
||||
}
|
||||
|
||||
function QueueSongCover({
|
||||
albumId,
|
||||
title,
|
||||
inRange,
|
||||
}: {
|
||||
albumId: string
|
||||
title: string
|
||||
inRange: boolean
|
||||
}) {
|
||||
return (
|
||||
<div
|
||||
className={cn(
|
||||
"relative size-10 shrink-0 overflow-hidden ring-1",
|
||||
inRange ? "ring-white/25" : "ring-foreground/10"
|
||||
)}
|
||||
>
|
||||
<Image
|
||||
src={albumCoverUrl(albumId)}
|
||||
alt={title}
|
||||
fill
|
||||
sizes="40px"
|
||||
className="object-cover"
|
||||
/>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function HistorySongRow({ song }: { song: HistorySong }) {
|
||||
return (
|
||||
<li className="relative w-full py-2 text-left text-sm opacity-60">
|
||||
<div className="relative z-10 flex items-center gap-3 px-2">
|
||||
{song.album.id ? (
|
||||
<QueueSongCover
|
||||
albumId={song.album.id}
|
||||
title={song.album.title}
|
||||
inRange={false}
|
||||
/>
|
||||
) : (
|
||||
<div className="flex size-10 shrink-0 items-center justify-center bg-muted ring-1 ring-foreground/10">
|
||||
<Music2 className="size-4 text-muted-foreground" />
|
||||
</div>
|
||||
)}
|
||||
<TrackCover
|
||||
albumId={song.album.id}
|
||||
alt={song.album.title}
|
||||
inRange={false}
|
||||
square
|
||||
/>
|
||||
|
||||
<PlaybackSongMeta
|
||||
song={song}
|
||||
@@ -115,106 +74,6 @@ function HistorySongRow({ song }: { song: HistorySong }) {
|
||||
)
|
||||
}
|
||||
|
||||
const QueueSongRow = React.forwardRef<
|
||||
HTMLLIElement,
|
||||
{
|
||||
song: QueueSelectable
|
||||
isNowPlaying: boolean
|
||||
selectionPosition: SelectionRangePosition
|
||||
isDragging: boolean
|
||||
onSelect: (event: React.MouseEvent) => void
|
||||
onPointerDown: (event: React.MouseEvent) => void
|
||||
onSkipTo: () => void
|
||||
onDragStart: (event: React.DragEvent) => void
|
||||
onDragOver: (event: React.DragEvent) => void
|
||||
onDrop: (event: React.DragEvent) => void
|
||||
}
|
||||
>(function QueueSongRow(
|
||||
{
|
||||
song,
|
||||
isNowPlaying,
|
||||
selectionPosition,
|
||||
isDragging,
|
||||
onSelect,
|
||||
onPointerDown,
|
||||
onSkipTo,
|
||||
onDragStart,
|
||||
onDragOver,
|
||||
onDrop,
|
||||
},
|
||||
ref
|
||||
) {
|
||||
const inRange = isInSelectionRange(selectionPosition)
|
||||
|
||||
return (
|
||||
<li
|
||||
ref={ref}
|
||||
role="button"
|
||||
tabIndex={0}
|
||||
draggable
|
||||
onDragStart={onDragStart}
|
||||
onDragOver={onDragOver}
|
||||
onDrop={onDrop}
|
||||
onMouseDown={onPointerDown}
|
||||
onClick={onSelect}
|
||||
onDoubleClick={(event) => {
|
||||
event.preventDefault()
|
||||
onSkipTo()
|
||||
}}
|
||||
onKeyDown={(event) => {
|
||||
if (event.key === "Enter" || event.key === " ") {
|
||||
event.preventDefault()
|
||||
onSelect(event as unknown as React.MouseEvent)
|
||||
}
|
||||
}}
|
||||
className={cn(
|
||||
"group relative w-full cursor-pointer select-none py-2 text-left text-sm transition-colors",
|
||||
inRange && "text-primary-foreground",
|
||||
isDragging && "opacity-50"
|
||||
)}
|
||||
>
|
||||
<QueueSelectionRangeHighlight position={selectionPosition} />
|
||||
{!inRange && isNowPlaying ? <QueueTrackRowActiveHighlight /> : null}
|
||||
{!inRange && !isNowPlaying ? <QueueTrackRowHoverHighlight /> : null}
|
||||
<div className="relative z-10 flex items-center gap-3 px-2">
|
||||
{song.album.id ? (
|
||||
<QueueSongCover
|
||||
albumId={song.album.id}
|
||||
title={song.album.title}
|
||||
inRange={inRange}
|
||||
/>
|
||||
) : (
|
||||
<div
|
||||
className={cn(
|
||||
"flex size-10 shrink-0 items-center justify-center bg-muted ring-1",
|
||||
inRange ? "ring-white/25" : "ring-foreground/10"
|
||||
)}
|
||||
>
|
||||
<Music2 className="size-4 text-muted-foreground" />
|
||||
</div>
|
||||
)}
|
||||
|
||||
<PlaybackSongMeta
|
||||
song={song}
|
||||
isCurrent={isNowPlaying}
|
||||
inRange={inRange}
|
||||
align="start"
|
||||
showAlbum={false}
|
||||
/>
|
||||
|
||||
<span
|
||||
className={cn(
|
||||
"shrink-0 text-xs tabular-nums",
|
||||
inRange ? "text-primary-foreground" : "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{formatDuration(song.durationSeconds)}
|
||||
</span>
|
||||
</div>
|
||||
</li>
|
||||
)
|
||||
})
|
||||
|
||||
function QueueSongRowSkeleton() {
|
||||
return (
|
||||
<li className="flex items-center gap-3 px-2 py-2" aria-hidden>
|
||||
@@ -238,7 +97,7 @@ export function QueuePanel() {
|
||||
skipToQueueIndex,
|
||||
} = usePlayback()
|
||||
const loadMoreRef = React.useRef<HTMLDivElement>(null)
|
||||
const nowPlayingRef = React.useRef<HTMLLIElement>(null)
|
||||
const nowPlayingRef = React.useRef<HTMLElement>(null)
|
||||
const [visibleCount, setVisibleCount] = React.useState(
|
||||
QUEUE_INITIAL_VISIBLE_COUNT
|
||||
)
|
||||
@@ -306,12 +165,25 @@ export function QueuePanel() {
|
||||
return () => observer.disconnect()
|
||||
}, [hasMore])
|
||||
|
||||
const {
|
||||
selectedIds,
|
||||
handleSelect,
|
||||
handlePointerDown,
|
||||
} = useTrackSelection(
|
||||
selectableQueue.map((item) => ({ id: item.selectionId }))
|
||||
const selectionItems = React.useMemo(
|
||||
() => selectableQueue.map((item) => ({ id: item.selectionId })),
|
||||
[selectableQueue]
|
||||
)
|
||||
const { selectedIds, handleSelect, handlePointerDown } =
|
||||
useTrackSelection(selectionItems)
|
||||
|
||||
const handleRowSelect = React.useCallback(
|
||||
(index: number, event: React.MouseEvent) => {
|
||||
handleSelect(selectableQueue[index].selectionId, index, event)
|
||||
},
|
||||
[selectableQueue, handleSelect]
|
||||
)
|
||||
|
||||
const handleRowPlay = React.useCallback(
|
||||
(index: number) => {
|
||||
void skipToQueueIndex(selectableQueue[index].queueIndex)
|
||||
},
|
||||
[selectableQueue, skipToQueueIndex]
|
||||
)
|
||||
|
||||
const selectionPositions = React.useMemo(
|
||||
@@ -398,27 +270,21 @@ export function QueuePanel() {
|
||||
<ul className="flex flex-col py-1">
|
||||
{selectableQueue.map((item, index) =>
|
||||
item.song ? (
|
||||
<QueueSongRow
|
||||
<TrackRow
|
||||
key={item.selectionId}
|
||||
ref={item.queueIndex === 0 ? nowPlayingRef : undefined}
|
||||
variant="queue"
|
||||
song={item.song}
|
||||
index={index}
|
||||
isActive={item.queueIndex === 0}
|
||||
isNowPlaying={item.queueIndex === 0}
|
||||
selectionPosition={selectionPositions[index]}
|
||||
isDragging={draggingIndices.has(index)}
|
||||
onPointerDown={handlePointerDown}
|
||||
onSelect={(event) => {
|
||||
handleSelect(item.selectionId, index, event)
|
||||
}}
|
||||
onSkipTo={() => void skipToQueueIndex(item.queueIndex)}
|
||||
onDragStart={(event) => {
|
||||
setDragIndex(index)
|
||||
event.dataTransfer.effectAllowed = "move"
|
||||
}}
|
||||
onDragOver={(event) => event.preventDefault()}
|
||||
onDrop={(event) => {
|
||||
event.preventDefault()
|
||||
handleDrop(index)
|
||||
}}
|
||||
onSelect={handleRowSelect}
|
||||
onPlay={handleRowPlay}
|
||||
onDragStart={setDragIndex}
|
||||
onDrop={handleDrop}
|
||||
/>
|
||||
) : (
|
||||
<QueueSongRowSkeleton key={item.selectionId} />
|
||||
|
||||
@@ -2,18 +2,19 @@
|
||||
|
||||
import { MobileSidebarTrigger } from "@/components/mobile-sidebar-trigger"
|
||||
import { stationArtistId } from "@/lib/station-artist"
|
||||
import { useEffect, useMemo, useState, useRef, MouseEvent } from "react"
|
||||
import Image from "next/image"
|
||||
import Link from "next/link"
|
||||
import { ArrowUpDown, Play, Star } from "lucide-react"
|
||||
import {
|
||||
useCallback,
|
||||
useEffect,
|
||||
useMemo,
|
||||
useState,
|
||||
useRef,
|
||||
type MouseEvent,
|
||||
} from "react"
|
||||
import { ArrowUpDown } from "lucide-react"
|
||||
|
||||
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
|
||||
import { useFavorites } from "@/components/favorites-provider"
|
||||
import { usePlayback } from "@/components/playback-provider"
|
||||
import {
|
||||
MediaContextMenu,
|
||||
type MediaContextAction,
|
||||
} from "@/components/media-context-menu"
|
||||
import { LibraryTrackListHeader, TrackRow } from "@/components/track-row"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import {
|
||||
DropdownMenu,
|
||||
@@ -25,247 +26,27 @@ import {
|
||||
DropdownMenuTrigger,
|
||||
} from "@/components/ui/dropdown-menu"
|
||||
import { useCachedPaginatedQuery } from "@/hooks/use-cached-query"
|
||||
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
|
||||
import { useTrackListMediaAction } from "@/hooks/use-media-actions"
|
||||
import { useTrackSelection } from "@/hooks/use-track-selection"
|
||||
import { SongListSkeleton } from "@/components/library-skeletons"
|
||||
import { ScrollArea } from "@/components/ui/scroll-area"
|
||||
import { Spinner } from "@/components/ui/spinner"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import {
|
||||
Table,
|
||||
TableBody,
|
||||
TableCell,
|
||||
TableHead,
|
||||
TableHeader,
|
||||
TableRow,
|
||||
} from "@/components/ui/table"
|
||||
import { cn } from "@/lib/utils"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
import {
|
||||
getSelectionRangePositions,
|
||||
isInSelectionRange,
|
||||
ALBUM_TRACK_TITLE,
|
||||
SongsSelectionRangeHighlight,
|
||||
SongsTrackRowHoverHighlight,
|
||||
TRACK_ROW_PADDING,
|
||||
type SelectionRangePosition,
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
|
||||
type SortKey = "title" | "artist" | "album"
|
||||
type SortDirection = "asc" | "desc"
|
||||
|
||||
const SONGS_PAGE_SIZE = 50
|
||||
|
||||
const songRowLayout =
|
||||
"flex w-full items-center gap-x-4"
|
||||
const nameColumnLayout =
|
||||
"grid grid-cols-[2rem_2.5rem_minmax(0,10rem)] items-center gap-x-2"
|
||||
const songColumnClass = "w-36 shrink-0 truncate"
|
||||
|
||||
function SongCover({
|
||||
song,
|
||||
inRange,
|
||||
onPlay,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
inRange: boolean
|
||||
onPlay: () => void
|
||||
}) {
|
||||
return (
|
||||
<div
|
||||
className={cn(
|
||||
"relative size-10 shrink-0 overflow-hidden rounded ring-1",
|
||||
inRange ? "ring-white/25" : "ring-foreground/10"
|
||||
)}
|
||||
>
|
||||
<Image
|
||||
src={albumCoverUrl(song.album.id)}
|
||||
alt={song.album.title}
|
||||
fill
|
||||
sizes="40px"
|
||||
className="object-cover"
|
||||
/>
|
||||
<div className="absolute inset-0 flex items-center justify-center bg-black/0 transition-colors group-hover:bg-black/40">
|
||||
<Button
|
||||
size="icon-sm"
|
||||
className="size-7 rounded-full opacity-0 transition-opacity group-hover:opacity-100"
|
||||
aria-label={`Play ${song.title}`}
|
||||
onClick={(event) => {
|
||||
event.preventDefault()
|
||||
event.stopPropagation()
|
||||
onPlay()
|
||||
}}
|
||||
>
|
||||
<Play className="size-3 fill-current" />
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function SongRow({
|
||||
song,
|
||||
isSelected,
|
||||
selectionPosition,
|
||||
isFavorite,
|
||||
selectedCount,
|
||||
stationArtist,
|
||||
onSelect,
|
||||
onPointerDown,
|
||||
onToggleFavorite,
|
||||
onPrepareContextMenu,
|
||||
onMediaAction,
|
||||
onPlay,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
isSelected: boolean
|
||||
selectionPosition: SelectionRangePosition
|
||||
isFavorite: boolean
|
||||
selectedCount: number
|
||||
stationArtist?: string
|
||||
onSelect: (event: MouseEvent) => void
|
||||
onPointerDown: (event: MouseEvent) => void
|
||||
onToggleFavorite: () => void
|
||||
onPrepareContextMenu: () => void
|
||||
onMediaAction: (action: MediaContextAction, songId: string) => void
|
||||
onPlay: () => void
|
||||
}) {
|
||||
const inRange = isInSelectionRange(selectionPosition)
|
||||
const linkClass = inRange
|
||||
? "text-primary-foreground hover:text-primary-foreground/80 hover:underline"
|
||||
: "text-muted-foreground hover:text-foreground hover:underline"
|
||||
|
||||
return (
|
||||
<TableRow
|
||||
onMouseDown={onPointerDown}
|
||||
onClick={onSelect}
|
||||
onDoubleClick={(event) => {
|
||||
event.preventDefault()
|
||||
onPlay()
|
||||
}}
|
||||
className="group cursor-pointer select-none border-none hover:bg-transparent"
|
||||
>
|
||||
<TableCell colSpan={4} className="p-0">
|
||||
<div
|
||||
className={cn(
|
||||
"relative py-2",
|
||||
inRange && "text-primary-foreground"
|
||||
)}
|
||||
>
|
||||
<SongsSelectionRangeHighlight position={selectionPosition} />
|
||||
{!inRange ? <SongsTrackRowHoverHighlight /> : null}
|
||||
<div
|
||||
className={cn("relative z-10", songRowLayout, TRACK_ROW_PADDING)}
|
||||
>
|
||||
<div className={nameColumnLayout}>
|
||||
<div className="flex items-center justify-center">
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="icon-sm"
|
||||
className={cn(
|
||||
"size-8 opacity-0 transition-opacity group-hover:opacity-100",
|
||||
inRange
|
||||
? "text-primary-foreground hover:bg-white/15 hover:text-primary-foreground"
|
||||
: "text-primary hover:text-primary",
|
||||
(isFavorite || isSelected) && "opacity-100"
|
||||
)}
|
||||
aria-label={
|
||||
isFavorite
|
||||
? `Remove ${song.title} from favorites`
|
||||
: `Favorite ${song.title}`
|
||||
}
|
||||
onClick={(event) => {
|
||||
event.stopPropagation()
|
||||
onToggleFavorite()
|
||||
}}
|
||||
>
|
||||
<Star
|
||||
className={cn(
|
||||
"size-4",
|
||||
isFavorite && (inRange ? "fill-current" : "fill-primary")
|
||||
)}
|
||||
/>
|
||||
</Button>
|
||||
</div>
|
||||
<SongCover song={song} inRange={inRange} onPlay={onPlay} />
|
||||
<span className={ALBUM_TRACK_TITLE}>
|
||||
{song.title}
|
||||
{song.explicit ? (
|
||||
<span
|
||||
className={cn(
|
||||
"ml-1.5 inline-flex size-3.5 shrink-0 items-center justify-center rounded-sm text-[9px] font-semibold leading-none",
|
||||
inRange
|
||||
? "bg-white/20 text-primary-foreground"
|
||||
: "bg-muted-foreground/20 text-muted-foreground"
|
||||
)}
|
||||
aria-label="Explicit"
|
||||
>
|
||||
E
|
||||
</span>
|
||||
) : null}
|
||||
</span>
|
||||
</div>
|
||||
<div className={songColumnClass}>
|
||||
<Link
|
||||
href={"/artist/" + song.artist.id}
|
||||
className={linkClass}
|
||||
onClick={(event) => event.stopPropagation()}
|
||||
>
|
||||
{song.artist.name}
|
||||
</Link>
|
||||
</div>
|
||||
<div className={songColumnClass}>
|
||||
<Link
|
||||
href={"/album/" + song.album.id}
|
||||
className={linkClass}
|
||||
onClick={(event) => event.stopPropagation()}
|
||||
>
|
||||
{song.album.title}
|
||||
</Link>
|
||||
</div>
|
||||
<div className="min-w-4 flex-1" />
|
||||
<span
|
||||
className={cn(
|
||||
"shrink-0 text-right tabular-nums",
|
||||
inRange ? "text-primary-foreground" : "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{formatDuration(song.durationSeconds)}
|
||||
</span>
|
||||
<MediaContextMenu
|
||||
label={`More options for ${song.title}`}
|
||||
stationArtistId={stationArtist}
|
||||
selectedCount={selectedCount}
|
||||
align="end"
|
||||
inSelectionRange={inRange}
|
||||
onOpenMenu={onPrepareContextMenu}
|
||||
onAction={(action) => onMediaAction(action, song.id)}
|
||||
favorited={isFavorite}
|
||||
navigation={{
|
||||
artist: { id: song.artist.id },
|
||||
album: { id: song.album.id },
|
||||
}}
|
||||
share={{
|
||||
type: "song",
|
||||
albumId: song.album.id,
|
||||
songId: song.id,
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
</TableCell>
|
||||
</TableRow>
|
||||
)
|
||||
}
|
||||
|
||||
export function SongsView() {
|
||||
const { openAddToPlaylist } = useAddToPlaylist()
|
||||
const { isSongFavorite, toggleSongFavorite, favoriteSongs } = useFavorites()
|
||||
const { isSongFavorite, toggleSongFavorite } = useFavorites()
|
||||
const { playFromLibrarySong } = usePlayback()
|
||||
const { runQueueAction, createStation } = useQueueMediaActions()
|
||||
const [sortKey, setSortKey] = useState<SortKey>("title")
|
||||
const [sortDirection, setSortDirection] =
|
||||
useState<SortDirection>("asc")
|
||||
@@ -306,7 +87,6 @@ export function SongsView() {
|
||||
const {
|
||||
selectedIds,
|
||||
selectedCount,
|
||||
isSelected,
|
||||
handleSelect,
|
||||
handlePointerDown,
|
||||
prepareContextMenu,
|
||||
@@ -327,32 +107,26 @@ export function SongsView() {
|
||||
[songs, selectedIds]
|
||||
)
|
||||
|
||||
function handleMediaAction(action: MediaContextAction, fallbackSongId?: string) {
|
||||
const targetIds =
|
||||
selectedIds.size > 0
|
||||
? Array.from(selectedIds)
|
||||
: fallbackSongId
|
||||
? [fallbackSongId]
|
||||
: []
|
||||
switch (action) {
|
||||
case "create-station": {
|
||||
const artistId = stationArtistId(songs, new Set(targetIds))
|
||||
if (artistId) void createStation(artistId)
|
||||
break
|
||||
}
|
||||
case "favorite":
|
||||
void favoriteSongs(targetIds as Id<"songs">[])
|
||||
break
|
||||
case "playlist":
|
||||
openAddToPlaylist(targetIds as Id<"songs">[])
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle":
|
||||
void runQueueAction(action, targetIds as Id<"songs">[])
|
||||
break
|
||||
}
|
||||
}
|
||||
const handleMediaAction = useTrackListMediaAction({ selectedIds, songs })
|
||||
|
||||
const handleRowSelect = useCallback(
|
||||
(index: number, event: MouseEvent) => {
|
||||
handleSelect(songs[index].id, index, event)
|
||||
},
|
||||
[songs, handleSelect]
|
||||
)
|
||||
|
||||
const handleRowPlay = useCallback(
|
||||
(index: number) => {
|
||||
void playFromLibrarySong(songs[index].id, { sortKey, sortDirection })
|
||||
},
|
||||
[songs, sortKey, sortDirection, playFromLibrarySong]
|
||||
)
|
||||
|
||||
const handleToggleFavorite = useCallback(
|
||||
(songId: string) => void toggleSongFavorite(songId as Id<"songs">),
|
||||
[toggleSongFavorite]
|
||||
)
|
||||
|
||||
if (status === "LoadingFirstPage" && !isCached) {
|
||||
return (
|
||||
@@ -432,68 +206,25 @@ export function SongsView() {
|
||||
}
|
||||
}}
|
||||
>
|
||||
<Table>
|
||||
<TableHeader>
|
||||
<TableRow className="border-none hover:bg-transparent">
|
||||
<TableHead colSpan={4} className="h-9 p-0 font-normal">
|
||||
<div className={cn(songRowLayout, TRACK_ROW_PADDING)}>
|
||||
<div className={nameColumnLayout}>
|
||||
<span aria-hidden />
|
||||
<span aria-hidden />
|
||||
<span className="text-xs text-muted-foreground">Name</span>
|
||||
</div>
|
||||
<span className={cn(songColumnClass, "text-xs text-muted-foreground")}>
|
||||
Artist
|
||||
</span>
|
||||
<span className={cn(songColumnClass, "text-xs text-muted-foreground")}>
|
||||
Album
|
||||
</span>
|
||||
<div className="min-w-4 flex-1" />
|
||||
<span className="shrink-0 text-right text-xs text-muted-foreground">
|
||||
Time
|
||||
</span>
|
||||
<span className="size-8 shrink-0" aria-hidden />
|
||||
</div>
|
||||
</TableHead>
|
||||
</TableRow>
|
||||
</TableHeader>
|
||||
<TableBody>
|
||||
{songs.map((song, index) => (
|
||||
<SongRow
|
||||
key={song.id}
|
||||
song={song}
|
||||
isSelected={isSelected(song.id)}
|
||||
selectionPosition={selectionPositions[index]}
|
||||
isFavorite={isSongFavorite(song.id)}
|
||||
stationArtist={
|
||||
isSelected(song.id)
|
||||
? selectedStationArtistId
|
||||
: song.artist.id
|
||||
}
|
||||
selectedCount={
|
||||
isSelected(song.id) && selectedCount > 0
|
||||
? selectedCount
|
||||
: 1
|
||||
}
|
||||
onPointerDown={handlePointerDown}
|
||||
onSelect={(event) => {
|
||||
handleSelect(song.id, index, event)
|
||||
}}
|
||||
onToggleFavorite={() =>
|
||||
void toggleSongFavorite(song.id as Id<"songs">)
|
||||
}
|
||||
onPrepareContextMenu={() => prepareContextMenu(song.id)}
|
||||
onMediaAction={handleMediaAction}
|
||||
onPlay={() =>
|
||||
void playFromLibrarySong(song.id as Id<"songs">, {
|
||||
sortKey,
|
||||
sortDirection,
|
||||
})
|
||||
}
|
||||
/>
|
||||
))}
|
||||
</TableBody>
|
||||
</Table>
|
||||
<LibraryTrackListHeader />
|
||||
{songs.map((song, index) => (
|
||||
<TrackRow
|
||||
key={song.id}
|
||||
variant="library"
|
||||
song={song}
|
||||
index={index}
|
||||
selectionPosition={selectionPositions[index]}
|
||||
isFavorite={isSongFavorite(song.id)}
|
||||
selectedCount={selectedCount}
|
||||
selectionStationArtistId={selectedStationArtistId}
|
||||
onPointerDown={handlePointerDown}
|
||||
onSelect={handleRowSelect}
|
||||
onPlay={handleRowPlay}
|
||||
onToggleFavorite={handleToggleFavorite}
|
||||
onPrepareContextMenu={prepareContextMenu}
|
||||
onMediaAction={handleMediaAction}
|
||||
/>
|
||||
))}
|
||||
<div
|
||||
ref={loadMoreRef}
|
||||
className="flex items-center justify-center py-4"
|
||||
|
||||
@@ -0,0 +1,509 @@
|
||||
"use client"
|
||||
|
||||
import * as React from "react"
|
||||
import Image from "next/image"
|
||||
import Link from "next/link"
|
||||
import { Music2, Play, Star, Trash2 } from "lucide-react"
|
||||
|
||||
import {
|
||||
MediaContextMenu,
|
||||
type MediaContextAction,
|
||||
} from "@/components/media-context-menu"
|
||||
import { PlaybackSongMeta } from "@/components/playback-song-meta"
|
||||
import { TrackNumberPlayButton } from "@/components/track-number-play-button"
|
||||
import { Button } from "@/components/ui/button"
|
||||
import {
|
||||
DropdownMenuItem,
|
||||
DropdownMenuSeparator,
|
||||
} from "@/components/ui/dropdown-menu"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
import {
|
||||
ALBUM_TRACK_ROW,
|
||||
ALBUM_TRACK_TITLE,
|
||||
isInSelectionRange,
|
||||
SelectionRangeHighlight,
|
||||
TrackRowActiveHighlight,
|
||||
TrackRowHoverHighlight,
|
||||
TRACK_ROW_PADDING,
|
||||
type SelectionRangePosition,
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
import { cn } from "@/lib/utils"
|
||||
import type { BrowseSong } from "@otunes/convex/types"
|
||||
|
||||
/**
|
||||
* - `library`: favorite star, cover with play overlay, title, artist and album
|
||||
* columns (use with `LibraryTrackListHeader`).
|
||||
* - `album`: favorite star, track number, title with optional credits.
|
||||
* - `playlist`: cover with favorite overlay, track number, title.
|
||||
* - `queue`: square cover, title and artist, no menu.
|
||||
*/
|
||||
export type TrackRowVariant = "library" | "album" | "playlist" | "queue"
|
||||
|
||||
export type TrackRowProps = {
|
||||
variant: TrackRowVariant
|
||||
song: BrowseSong
|
||||
/** Position in the list the selection hook was given. */
|
||||
index: number
|
||||
/** Number shown in the track number column (`album` and `playlist`). */
|
||||
trackNumber?: number
|
||||
/** Secondary line under the title, e.g. album track credits. */
|
||||
subtitle?: string
|
||||
selectionPosition: SelectionRangePosition
|
||||
isActive?: boolean
|
||||
isNowPlaying?: boolean
|
||||
isFavorite?: boolean
|
||||
isDragging?: boolean
|
||||
/** Total selected songs; the menu acts on these when this row is selected. */
|
||||
selectedCount?: number
|
||||
/** Station artist for the selection when this row is selected. */
|
||||
selectionStationArtistId?: string
|
||||
playlistLabel?: string
|
||||
showFavoriteInMenu?: boolean
|
||||
/** Adds a destructive menu item calling `onRemove`. */
|
||||
removeLabel?: string
|
||||
ref?: React.Ref<HTMLElement>
|
||||
onSelect: (index: number, event: React.MouseEvent) => void
|
||||
onPointerDown: (event: React.MouseEvent) => void
|
||||
onPlay: (index: number) => void
|
||||
onToggleFavorite?: (songId: string) => void
|
||||
onPrepareContextMenu?: (songId: string) => void
|
||||
/** Renders the "more options" menu when provided. */
|
||||
onMediaAction?: (action: MediaContextAction, songId: string) => void
|
||||
onRemove?: (songId: string) => void
|
||||
/** Makes the row draggable when provided. */
|
||||
onDragStart?: (index: number) => void
|
||||
onDrop?: (index: number) => void
|
||||
}
|
||||
|
||||
const LIBRARY_ROW_LAYOUT = "flex w-full items-center gap-x-4"
|
||||
const LIBRARY_NAME_COLUMNS =
|
||||
"grid grid-cols-[2rem_2.5rem_minmax(0,10rem)] items-center gap-x-2"
|
||||
const LIBRARY_COLUMN = "w-36 shrink-0 truncate"
|
||||
|
||||
export function TrackCover({
|
||||
albumId,
|
||||
alt,
|
||||
inRange,
|
||||
square = false,
|
||||
children,
|
||||
}: {
|
||||
albumId: string | undefined
|
||||
alt: string
|
||||
inRange: boolean
|
||||
square?: boolean
|
||||
/** Overlay shown above the cover image. */
|
||||
children?: React.ReactNode
|
||||
}) {
|
||||
const ringClass = inRange ? "ring-white/25" : "ring-foreground/10"
|
||||
|
||||
if (!albumId) {
|
||||
return (
|
||||
<div
|
||||
className={cn(
|
||||
"flex size-10 shrink-0 items-center justify-center bg-muted ring-1",
|
||||
!square && "rounded",
|
||||
ringClass
|
||||
)}
|
||||
>
|
||||
<Music2 className="size-4 text-muted-foreground" />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
return (
|
||||
<div
|
||||
className={cn(
|
||||
"group/cover relative size-10 shrink-0 overflow-hidden ring-1",
|
||||
!square && "rounded",
|
||||
ringClass
|
||||
)}
|
||||
>
|
||||
<Image
|
||||
src={albumCoverUrl(albumId)}
|
||||
alt={alt}
|
||||
fill
|
||||
sizes="40px"
|
||||
className="object-cover"
|
||||
/>
|
||||
{children}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function FavoriteStarButton({
|
||||
title,
|
||||
isFavorite,
|
||||
inRange,
|
||||
className,
|
||||
onToggle,
|
||||
}: {
|
||||
title: string
|
||||
isFavorite: boolean
|
||||
inRange: boolean
|
||||
className?: string
|
||||
onToggle: () => void
|
||||
}) {
|
||||
return (
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="icon-sm"
|
||||
className={cn(
|
||||
"size-8",
|
||||
inRange
|
||||
? "text-primary-foreground hover:bg-white/15 hover:text-primary-foreground"
|
||||
: "text-primary hover:text-primary",
|
||||
className
|
||||
)}
|
||||
aria-label={isFavorite ? `Remove ${title} from favorites` : `Favorite ${title}`}
|
||||
onClick={(event) => {
|
||||
event.stopPropagation()
|
||||
onToggle()
|
||||
}}
|
||||
>
|
||||
<Star
|
||||
className={cn(
|
||||
"size-4",
|
||||
isFavorite && (inRange ? "fill-current" : "fill-primary")
|
||||
)}
|
||||
/>
|
||||
</Button>
|
||||
)
|
||||
}
|
||||
|
||||
function ExplicitBadge({ inRange }: { inRange: boolean }) {
|
||||
return (
|
||||
<span
|
||||
className={cn(
|
||||
"ml-1.5 inline-flex size-3.5 shrink-0 items-center justify-center rounded-sm text-[9px] font-semibold leading-none",
|
||||
inRange
|
||||
? "bg-white/20 text-primary-foreground"
|
||||
: "bg-muted-foreground/20 text-muted-foreground"
|
||||
)}
|
||||
aria-label="Explicit"
|
||||
>
|
||||
E
|
||||
</span>
|
||||
)
|
||||
}
|
||||
|
||||
function TrackTitle({
|
||||
song,
|
||||
subtitle,
|
||||
inRange,
|
||||
}: {
|
||||
song: BrowseSong
|
||||
subtitle?: string
|
||||
inRange: boolean
|
||||
}) {
|
||||
return (
|
||||
<div className="min-w-0 flex-1">
|
||||
<div className={ALBUM_TRACK_TITLE}>
|
||||
{song.title}
|
||||
{song.explicit ? <ExplicitBadge inRange={inRange} /> : null}
|
||||
</div>
|
||||
{subtitle ? (
|
||||
<p
|
||||
className={cn(
|
||||
"truncate text-xs",
|
||||
inRange ? "text-primary-foreground/80" : "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{subtitle}
|
||||
</p>
|
||||
) : null}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
export function LibraryTrackListHeader() {
|
||||
const labelClass = "text-xs text-muted-foreground"
|
||||
return (
|
||||
<div className={cn("flex h-9 items-center", LIBRARY_ROW_LAYOUT, TRACK_ROW_PADDING)}>
|
||||
<div className={LIBRARY_NAME_COLUMNS}>
|
||||
<span aria-hidden />
|
||||
<span aria-hidden />
|
||||
<span className={labelClass}>Name</span>
|
||||
</div>
|
||||
<span className={cn(LIBRARY_COLUMN, labelClass)}>Artist</span>
|
||||
<span className={cn(LIBRARY_COLUMN, labelClass)}>Album</span>
|
||||
<div className="min-w-4 flex-1" />
|
||||
<span className={cn("shrink-0 text-right", labelClass)}>Time</span>
|
||||
<span className="size-8 shrink-0" aria-hidden />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
function TrackRowComponent({
|
||||
variant,
|
||||
song,
|
||||
index,
|
||||
trackNumber,
|
||||
subtitle,
|
||||
selectionPosition,
|
||||
isActive = false,
|
||||
isNowPlaying = false,
|
||||
isFavorite = false,
|
||||
isDragging = false,
|
||||
selectedCount = 0,
|
||||
selectionStationArtistId,
|
||||
playlistLabel,
|
||||
showFavoriteInMenu = true,
|
||||
removeLabel,
|
||||
ref,
|
||||
onSelect,
|
||||
onPointerDown,
|
||||
onPlay,
|
||||
onToggleFavorite,
|
||||
onPrepareContextMenu,
|
||||
onMediaAction,
|
||||
onRemove,
|
||||
onDragStart,
|
||||
onDrop,
|
||||
}: TrackRowProps) {
|
||||
const inRange = isInSelectionRange(selectionPosition)
|
||||
const flush = variant === "library" || variant === "queue"
|
||||
const play = () => onPlay(index)
|
||||
const toggleFavorite = () => onToggleFavorite?.(song.id)
|
||||
|
||||
const favoriteStar = (
|
||||
<div className="flex shrink-0 items-center justify-center">
|
||||
<FavoriteStarButton
|
||||
title={song.title}
|
||||
isFavorite={isFavorite}
|
||||
inRange={inRange}
|
||||
className={cn(
|
||||
"opacity-0 transition-opacity group-hover:opacity-100",
|
||||
(isFavorite || isActive || inRange) && "opacity-100"
|
||||
)}
|
||||
onToggle={toggleFavorite}
|
||||
/>
|
||||
</div>
|
||||
)
|
||||
|
||||
const trackNumberButton = (
|
||||
<TrackNumberPlayButton
|
||||
displayTrack={trackNumber ?? index + 1}
|
||||
title={song.title}
|
||||
isActive={isActive}
|
||||
isNowPlaying={isNowPlaying}
|
||||
inRange={inRange}
|
||||
onPlay={play}
|
||||
/>
|
||||
)
|
||||
|
||||
const duration = (
|
||||
<span
|
||||
className={cn(
|
||||
"shrink-0 text-right tabular-nums",
|
||||
variant === "queue" && "text-xs",
|
||||
inRange ? "text-primary-foreground" : "text-muted-foreground"
|
||||
)}
|
||||
>
|
||||
{formatDuration(song.durationSeconds)}
|
||||
</span>
|
||||
)
|
||||
|
||||
const menu = onMediaAction ? (
|
||||
<MediaContextMenu
|
||||
label={`More options for ${song.title}`}
|
||||
stationArtistId={inRange ? selectionStationArtistId : song.artist.id}
|
||||
selectedCount={inRange && selectedCount > 0 ? selectedCount : 1}
|
||||
inSelectionRange={inRange}
|
||||
onOpenMenu={() => onPrepareContextMenu?.(song.id)}
|
||||
onAction={(action) => onMediaAction(action, song.id)}
|
||||
playlistLabel={playlistLabel}
|
||||
showFavorite={showFavoriteInMenu}
|
||||
favorited={isFavorite}
|
||||
navigation={{
|
||||
artist: { id: song.artist.id },
|
||||
album: { id: song.album.id },
|
||||
}}
|
||||
share={{ type: "song", albumId: song.album.id, songId: song.id }}
|
||||
>
|
||||
{removeLabel && onRemove ? (
|
||||
<>
|
||||
<DropdownMenuSeparator />
|
||||
<DropdownMenuItem
|
||||
variant="destructive"
|
||||
className="justify-between"
|
||||
onClick={() => onRemove(song.id)}
|
||||
>
|
||||
{removeLabel}
|
||||
<Trash2 />
|
||||
</DropdownMenuItem>
|
||||
</>
|
||||
) : null}
|
||||
</MediaContextMenu>
|
||||
) : null
|
||||
|
||||
let content: React.ReactNode
|
||||
switch (variant) {
|
||||
case "library": {
|
||||
const linkClass = inRange
|
||||
? "text-primary-foreground hover:text-primary-foreground/80 hover:underline"
|
||||
: "text-muted-foreground hover:text-foreground hover:underline"
|
||||
content = (
|
||||
<div className={cn("relative z-10", LIBRARY_ROW_LAYOUT, TRACK_ROW_PADDING)}>
|
||||
<div className={LIBRARY_NAME_COLUMNS}>
|
||||
{favoriteStar}
|
||||
<TrackCover albumId={song.album.id} alt={song.album.title} inRange={inRange}>
|
||||
<div className="absolute inset-0 flex items-center justify-center bg-black/0 transition-colors group-hover:bg-black/40">
|
||||
<Button
|
||||
size="icon-sm"
|
||||
className="size-7 rounded-full opacity-0 transition-opacity group-hover:opacity-100"
|
||||
aria-label={`Play ${song.title}`}
|
||||
onClick={(event) => {
|
||||
event.preventDefault()
|
||||
event.stopPropagation()
|
||||
play()
|
||||
}}
|
||||
>
|
||||
<Play className="size-3 fill-current" />
|
||||
</Button>
|
||||
</div>
|
||||
</TrackCover>
|
||||
<TrackTitle song={song} inRange={inRange} />
|
||||
</div>
|
||||
<div className={LIBRARY_COLUMN}>
|
||||
<Link
|
||||
href={"/artist/" + song.artist.id}
|
||||
className={linkClass}
|
||||
onClick={(event) => event.stopPropagation()}
|
||||
>
|
||||
{song.artist.name}
|
||||
</Link>
|
||||
</div>
|
||||
<div className={LIBRARY_COLUMN}>
|
||||
<Link
|
||||
href={"/album/" + song.album.id}
|
||||
className={linkClass}
|
||||
onClick={(event) => event.stopPropagation()}
|
||||
>
|
||||
{song.album.title}
|
||||
</Link>
|
||||
</div>
|
||||
<div className="min-w-4 flex-1" />
|
||||
{duration}
|
||||
{menu}
|
||||
</div>
|
||||
)
|
||||
break
|
||||
}
|
||||
case "album":
|
||||
content = (
|
||||
<div className={cn("relative z-10", ALBUM_TRACK_ROW, TRACK_ROW_PADDING)}>
|
||||
{favoriteStar}
|
||||
{trackNumberButton}
|
||||
<TrackTitle song={song} subtitle={subtitle} inRange={inRange} />
|
||||
{duration}
|
||||
{menu}
|
||||
</div>
|
||||
)
|
||||
break
|
||||
case "playlist":
|
||||
content = (
|
||||
<div className={cn("relative z-10", ALBUM_TRACK_ROW, TRACK_ROW_PADDING)}>
|
||||
<TrackCover albumId={song.album.id} alt={song.album.title} inRange={inRange}>
|
||||
<div className="absolute inset-0 flex items-center justify-center bg-black/0 opacity-0 transition-opacity group-hover/cover:bg-black/40 group-hover/cover:opacity-100">
|
||||
<FavoriteStarButton
|
||||
title={song.title}
|
||||
isFavorite={isFavorite}
|
||||
inRange={inRange}
|
||||
onToggle={toggleFavorite}
|
||||
/>
|
||||
</div>
|
||||
</TrackCover>
|
||||
{trackNumberButton}
|
||||
<TrackTitle song={song} subtitle={subtitle} inRange={inRange} />
|
||||
{duration}
|
||||
{menu}
|
||||
</div>
|
||||
)
|
||||
break
|
||||
case "queue":
|
||||
content = (
|
||||
<div className="relative z-10 flex items-center gap-3 px-2">
|
||||
<TrackCover
|
||||
albumId={song.album.id}
|
||||
alt={song.album.title}
|
||||
inRange={inRange}
|
||||
square
|
||||
/>
|
||||
<PlaybackSongMeta
|
||||
song={song}
|
||||
isCurrent={isNowPlaying}
|
||||
inRange={inRange}
|
||||
align="start"
|
||||
showAlbum={false}
|
||||
/>
|
||||
{duration}
|
||||
</div>
|
||||
)
|
||||
break
|
||||
}
|
||||
|
||||
const shellProps = {
|
||||
role: "button",
|
||||
tabIndex: 0,
|
||||
draggable: onDragStart ? true : undefined,
|
||||
onDragStart: onDragStart
|
||||
? (event: React.DragEvent) => {
|
||||
event.dataTransfer.effectAllowed = "move"
|
||||
onDragStart(index)
|
||||
}
|
||||
: undefined,
|
||||
onDragOver: onDragStart
|
||||
? (event: React.DragEvent) => event.preventDefault()
|
||||
: undefined,
|
||||
onDrop: onDrop
|
||||
? (event: React.DragEvent) => {
|
||||
event.preventDefault()
|
||||
onDrop(index)
|
||||
}
|
||||
: undefined,
|
||||
onMouseDown: onPointerDown,
|
||||
onClick: (event: React.MouseEvent) => onSelect(index, event),
|
||||
onDoubleClick: (event: React.MouseEvent) => {
|
||||
event.preventDefault()
|
||||
play()
|
||||
},
|
||||
onKeyDown: (event: React.KeyboardEvent) => {
|
||||
if (event.key === "Enter" || event.key === " ") {
|
||||
event.preventDefault()
|
||||
onSelect(index, event as unknown as React.MouseEvent)
|
||||
}
|
||||
},
|
||||
className: cn(
|
||||
"group relative w-full cursor-pointer select-none text-left text-sm transition-colors",
|
||||
flush ? "py-2" : "py-2.5",
|
||||
inRange && "text-primary-foreground",
|
||||
isDragging && "opacity-50"
|
||||
),
|
||||
}
|
||||
|
||||
const children = (
|
||||
<>
|
||||
<SelectionRangeHighlight position={selectionPosition} flush={flush} />
|
||||
{!inRange && isActive ? <TrackRowActiveHighlight flush={flush} /> : null}
|
||||
{!inRange && !isActive ? <TrackRowHoverHighlight flush={flush} /> : null}
|
||||
{content}
|
||||
</>
|
||||
)
|
||||
|
||||
return variant === "queue" ? (
|
||||
<li ref={ref as React.Ref<HTMLLIElement>} {...shellProps}>
|
||||
{children}
|
||||
</li>
|
||||
) : (
|
||||
<div ref={ref as React.Ref<HTMLDivElement>} {...shellProps}>
|
||||
{children}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Pass stable callbacks: they receive the row's `index` or song id, so one
|
||||
* handler can serve every row.
|
||||
*/
|
||||
export const TrackRow = React.memo(TrackRowComponent)
|
||||
@@ -0,0 +1,104 @@
|
||||
"use client"
|
||||
|
||||
import * as React from "react"
|
||||
import { useConvex } from "convex/react"
|
||||
|
||||
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
|
||||
import { useFavorites } from "@/components/favorites-provider"
|
||||
import type { MediaContextAction } from "@/components/media-context-menu"
|
||||
import { useCacheScope } from "@/components/persistent-cache-provider"
|
||||
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
|
||||
import { stationArtistId } from "@/lib/station-artist"
|
||||
import { api } from "@otunes/convex/_generated/api"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import { fetchCachedQuery } from "@otunes/convex/client/cached-query"
|
||||
|
||||
export function useMediaActions() {
|
||||
const { openAddToPlaylist, openAddArtistToPlaylist } = useAddToPlaylist()
|
||||
const { favoriteSongs, toggleArtistFavorite } = useFavorites()
|
||||
const { runQueueAction, createStation } = useQueueMediaActions()
|
||||
const convex = useConvex()
|
||||
const cacheScope = useCacheScope()
|
||||
|
||||
const runSongsAction = React.useCallback(
|
||||
(
|
||||
action: MediaContextAction,
|
||||
songIds: Id<"songs">[],
|
||||
stationArtist?: string
|
||||
) => {
|
||||
switch (action) {
|
||||
case "create-station":
|
||||
if (stationArtist) void createStation(stationArtist)
|
||||
break
|
||||
case "favorite":
|
||||
void favoriteSongs(songIds)
|
||||
break
|
||||
case "playlist":
|
||||
openAddToPlaylist(songIds)
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle":
|
||||
void runQueueAction(action, songIds)
|
||||
break
|
||||
}
|
||||
},
|
||||
[createStation, favoriteSongs, openAddToPlaylist, runQueueAction]
|
||||
)
|
||||
|
||||
const runArtistAction = React.useCallback(
|
||||
async (action: MediaContextAction, artistId: string) => {
|
||||
switch (action) {
|
||||
case "favorite":
|
||||
void toggleArtistFavorite(artistId as Id<"artists">)
|
||||
break
|
||||
case "playlist":
|
||||
void openAddArtistToPlaylist(artistId as Id<"artists">)
|
||||
break
|
||||
case "play-next":
|
||||
case "play-last":
|
||||
case "shuffle": {
|
||||
const songIds = await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId: artistId as Id<"artists"> }
|
||||
)
|
||||
void runQueueAction(action, songIds)
|
||||
break
|
||||
}
|
||||
}
|
||||
},
|
||||
[convex, cacheScope, toggleArtistFavorite, openAddArtistToPlaylist, runQueueAction]
|
||||
)
|
||||
|
||||
return { runSongsAction, runArtistAction }
|
||||
}
|
||||
|
||||
/**
|
||||
* Handles a track row menu action, targeting the current selection or else the
|
||||
* row's song. The station artist is `artistId` when given, otherwise the artist
|
||||
* every targeted song in `songs` shares.
|
||||
*/
|
||||
export function useTrackListMediaAction({
|
||||
selectedIds,
|
||||
songs,
|
||||
artistId,
|
||||
}: {
|
||||
selectedIds: ReadonlySet<string>
|
||||
songs?: { id: string; artist: { id: string } }[]
|
||||
artistId?: string
|
||||
}) {
|
||||
const { runSongsAction } = useMediaActions()
|
||||
|
||||
return React.useCallback(
|
||||
(action: MediaContextAction, songId: string) => {
|
||||
const targetIds = selectedIds.size > 0 ? Array.from(selectedIds) : [songId]
|
||||
const stationArtist =
|
||||
artistId ??
|
||||
(songs ? stationArtistId(songs, new Set(targetIds)) : undefined)
|
||||
runSongsAction(action, targetIds as Id<"songs">[], stationArtist)
|
||||
},
|
||||
[selectedIds, songs, artistId, runSongsAction]
|
||||
)
|
||||
}
|
||||
@@ -46,7 +46,7 @@ export function getSelectionRangePositions(
|
||||
return positions
|
||||
}
|
||||
|
||||
function selectionHighlightRadiusClass(
|
||||
export function selectionHighlightRadiusClass(
|
||||
position: SelectionRangePosition
|
||||
) {
|
||||
switch (position) {
|
||||
@@ -61,12 +61,21 @@ function selectionHighlightRadiusClass(
|
||||
}
|
||||
}
|
||||
|
||||
const TRACK_ROW_HIGHLIGHT_INSET = "absolute inset-y-0 left-2 right-2"
|
||||
export const TRACK_ROW_HIGHLIGHT_INSET = "absolute inset-y-0 left-2 right-2"
|
||||
|
||||
/** Full-width, square-corner highlight used by the library and queue lists. */
|
||||
export const FLUSH_ROW_HIGHLIGHT_INSET = "absolute inset-0"
|
||||
|
||||
/**
|
||||
* Track row highlights are inset rounded pills by default; `flush` makes them
|
||||
* full-width with square corners.
|
||||
*/
|
||||
export function SelectionRangeHighlight({
|
||||
position,
|
||||
flush = false,
|
||||
}: {
|
||||
position: SelectionRangePosition
|
||||
flush?: boolean
|
||||
}) {
|
||||
if (position === "none") {
|
||||
return null
|
||||
@@ -77,34 +86,34 @@ export function SelectionRangeHighlight({
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none bg-primary",
|
||||
TRACK_ROW_HIGHLIGHT_INSET,
|
||||
selectionHighlightRadiusClass(position)
|
||||
flush
|
||||
? FLUSH_ROW_HIGHLIGHT_INSET
|
||||
: [TRACK_ROW_HIGHLIGHT_INSET, selectionHighlightRadiusClass(position)]
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
|
||||
/** Inset rounded hover background matching the selection pill shape. */
|
||||
export function TrackRowHoverHighlight() {
|
||||
export function TrackRowHoverHighlight({ flush = false }: { flush?: boolean }) {
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none rounded-lg bg-muted/60 opacity-0 transition-opacity group-hover:opacity-100",
|
||||
TRACK_ROW_HIGHLIGHT_INSET
|
||||
"pointer-events-none bg-muted/60 opacity-0 transition-opacity group-hover:opacity-100",
|
||||
flush ? FLUSH_ROW_HIGHLIGHT_INSET : [TRACK_ROW_HIGHLIGHT_INSET, "rounded-lg"]
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
|
||||
/** Inset rounded background for the active (now playing) row. */
|
||||
export function TrackRowActiveHighlight() {
|
||||
/** Background for the active (focused or now playing) row. */
|
||||
export function TrackRowActiveHighlight({ flush = false }: { flush?: boolean }) {
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none rounded-lg bg-muted/60",
|
||||
TRACK_ROW_HIGHLIGHT_INSET
|
||||
"pointer-events-none bg-muted/60",
|
||||
flush ? FLUSH_ROW_HIGHLIGHT_INSET : [TRACK_ROW_HIGHLIGHT_INSET, "rounded-lg"]
|
||||
)}
|
||||
/>
|
||||
)
|
||||
@@ -116,42 +125,6 @@ export const TRACK_ROW_PADDING = "pl-8 pr-10"
|
||||
/** Centers the track list in the main content area. */
|
||||
export const TRACK_LIST_CONTAINER = "mx-auto w-full max-w-9/10"
|
||||
|
||||
/** Full-width highlight for library song rows (no horizontal inset). */
|
||||
const SONGS_ROW_HIGHLIGHT_INSET = "absolute inset-0"
|
||||
|
||||
export function SongsSelectionRangeHighlight({
|
||||
position,
|
||||
}: {
|
||||
position: SelectionRangePosition
|
||||
}) {
|
||||
if (position === "none") {
|
||||
return null
|
||||
}
|
||||
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none bg-primary",
|
||||
SONGS_ROW_HIGHLIGHT_INSET
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
|
||||
/** Full-width hover background for library song rows (not rounded). */
|
||||
export function SongsTrackRowHoverHighlight() {
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none bg-muted/60 opacity-0 transition-opacity group-hover:opacity-100",
|
||||
SONGS_ROW_HIGHLIGHT_INSET
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
|
||||
/** Album track row: star, track #, title (flex), duration, menu. */
|
||||
export const ALBUM_TRACK_ROW = "flex w-full min-w-0 items-center gap-x-3"
|
||||
|
||||
@@ -160,50 +133,3 @@ export const ALBUM_TRACK_TITLE = "min-w-0 flex-1 truncate font-normal"
|
||||
export function isInSelectionRange(position: SelectionRangePosition) {
|
||||
return position !== "none"
|
||||
}
|
||||
|
||||
/** Full-width, square-corner highlights for the queue sidebar. */
|
||||
const QUEUE_ROW_HIGHLIGHT_INSET = "absolute inset-0"
|
||||
|
||||
export function QueueSelectionRangeHighlight({
|
||||
position,
|
||||
}: {
|
||||
position: SelectionRangePosition
|
||||
}) {
|
||||
if (position === "none") {
|
||||
return null
|
||||
}
|
||||
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none bg-primary",
|
||||
QUEUE_ROW_HIGHLIGHT_INSET
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
|
||||
export function QueueTrackRowHoverHighlight() {
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none bg-muted/60 opacity-0 transition-opacity group-hover:opacity-100",
|
||||
QUEUE_ROW_HIGHLIGHT_INSET
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
|
||||
export function QueueTrackRowActiveHighlight() {
|
||||
return (
|
||||
<div
|
||||
aria-hidden
|
||||
className={cn(
|
||||
"pointer-events-none bg-muted/60",
|
||||
QUEUE_ROW_HIGHLIGHT_INSET
|
||||
)}
|
||||
/>
|
||||
)
|
||||
}
|
||||
Reference in new issue
Block a user