Compare commits
2
Commits
No files matched your search
+6
-5
@@ -54,11 +54,12 @@ playwright.config.*
|
||||
*~
|
||||
*.log
|
||||
|
||||
# Environment variables, in any workspace. Next.js inlines NEXT_PUBLIC_* values
|
||||
# into the bundle and the Convex CLI reads .env.local on deploy.
|
||||
**/.env
|
||||
**/.env.*
|
||||
!**/.env.example
|
||||
# Environment variables (only commit template files)
|
||||
.env
|
||||
.env*.local
|
||||
.env.development
|
||||
.env.test
|
||||
.env.production.local
|
||||
|
||||
# Docker configuration files (not needed inside build context)
|
||||
Dockerfile*
|
||||
|
||||
+1
-6
@@ -195,12 +195,7 @@ RUN node --version \
|
||||
&& ldd /convex/generate_key \
|
||||
&& ! ldd /convex/convex-local-backend /convex/generate_key | grep -q 'not found'
|
||||
|
||||
# The backend gets its own user so the web server cannot read the database or
|
||||
# instance secret. It joins the otunes group to clean up the web server's HLS
|
||||
# cache in /tmp/otunes.
|
||||
RUN useradd --system --user-group --home-dir /app --shell /usr/sbin/nologin otunes \
|
||||
&& useradd --system --user-group --groups otunes --create-home --home-dir /home/convex \
|
||||
--shell /usr/sbin/nologin convex
|
||||
RUN useradd --system --user-group --home-dir /app --shell /usr/sbin/nologin otunes
|
||||
|
||||
COPY --from=convex-functions /app /opt/otunes/convex
|
||||
COPY docker/generate-auth-keys.mjs /opt/otunes/generate-auth-keys.mjs
|
||||
|
||||
+1
@@ -0,0 +1 @@
|
||||
export { default } from "../library/queue"
|
||||
@@ -35,7 +35,7 @@ import {
|
||||
MediaActionMenu,
|
||||
MediaContextMenu,
|
||||
type MediaAction,
|
||||
} from "@/components/media-context-menu"
|
||||
} from "@/components/media-actions-sheet"
|
||||
import { CollectionDetailSkeleton } from "@/components/skeletons"
|
||||
import { Button } from "@/components/ui/primitives"
|
||||
import { contentBottomInset } from "@/components/player"
|
||||
@@ -488,7 +488,7 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
|
||||
action: MediaAction
|
||||
) => Promise<void>
|
||||
}) {
|
||||
const Row = Platform.OS !== "web" ? SongSwipeRow : Pressable
|
||||
const Row = Platform.OS === "ios" ? SongSwipeRow : Pressable
|
||||
const { config } = useServerConfig()
|
||||
return (
|
||||
<MediaContextMenu
|
||||
@@ -523,7 +523,6 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
|
||||
group={swipeGroup}
|
||||
backgroundColor={palette.background}
|
||||
onPlayNext={() => void onAction(track, album, "play-next")}
|
||||
onAddToQueue={() => void onAction(track, album, "play-last")}
|
||||
style={styles.trackRow}
|
||||
onPress={() => void onPlay(track.id as Id<"songs">, songIds)}
|
||||
>
|
||||
|
||||
@@ -6,7 +6,7 @@ import { Ionicons } from "@expo/vector-icons"
|
||||
import { CoverImage } from "@/components/cover-image"
|
||||
|
||||
import { MediaGridList } from "@/components/media-cards"
|
||||
import { MediaActionMenu } from "@/components/media-context-menu"
|
||||
import { MediaActionMenu } from "@/components/media-actions-sheet"
|
||||
import { CollectionDetailSkeleton } from "@/components/skeletons"
|
||||
import { Button } from "@/components/ui/primitives"
|
||||
import { contentBottomInset } from "@/components/player"
|
||||
|
||||
@@ -46,7 +46,7 @@ import {
|
||||
import {
|
||||
MediaActionMenu,
|
||||
type MediaAction,
|
||||
} from "@/components/media-context-menu"
|
||||
} from "@/components/media-actions-sheet"
|
||||
import { CollectionDetailSkeleton } from "@/components/skeletons"
|
||||
import { Button } from "@/components/ui/primitives"
|
||||
import { contentBottomInset, SongListRow } from "@/components/player"
|
||||
@@ -314,6 +314,7 @@ function PlaylistContent({
|
||||
deletePlaylist,
|
||||
handlePlaylistDetailAction,
|
||||
palette.foreground,
|
||||
palette.background,
|
||||
palette.isDark,
|
||||
playlistId,
|
||||
playlist?.title,
|
||||
@@ -433,18 +434,11 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
|
||||
palette={palette}
|
||||
inset
|
||||
swipe={
|
||||
Platform.OS !== "web"
|
||||
Platform.OS === "ios"
|
||||
? {
|
||||
group: swipeGroup,
|
||||
backgroundColor: palette.background,
|
||||
onPlayNext: () => onAction(song, "play-next"),
|
||||
onAddToQueue: () => onAction(song, "play-last"),
|
||||
onRemove:
|
||||
Platform.OS === "android" && removable
|
||||
? () => {
|
||||
void onRemove(song.id)
|
||||
}
|
||||
: undefined,
|
||||
}
|
||||
: undefined
|
||||
}
|
||||
@@ -453,7 +447,7 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
|
||||
/>
|
||||
)
|
||||
|
||||
if (Platform.OS !== "web" || !removable) {
|
||||
if (Platform.OS === "ios" || !removable) {
|
||||
return row
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,186 @@
|
||||
import { Stack, useRouter } from "expo-router"
|
||||
import { memo, useCallback, useMemo } from "react"
|
||||
import { FlatList, Pressable, StyleSheet, Text, View } from "react-native"
|
||||
|
||||
import { Button } from "@/components/ui/primitives"
|
||||
import { contentBottomInset, SongRow } from "@/components/player"
|
||||
import { SongRowSkeleton } from "@/components/skeletons"
|
||||
import { usePlaybackActions, usePlaybackQueue } from "@/contexts/playback"
|
||||
import type { Id } from "@otunes/convex/_generated/dataModel"
|
||||
import { longListProps } from "@/lib/list"
|
||||
import { useSong, useSongs } from "@/lib/song-cache"
|
||||
import { spacing, useThemeColors } from "@/lib/theme"
|
||||
|
||||
/** `key` stays stable when earlier songs leave the queue, so rows are not remounted on skip. */
|
||||
type QueueItem = { songId: Id<"songs">; queueIndex: number; key: string }
|
||||
|
||||
function queueItemKey(item: QueueItem) {
|
||||
return item.key
|
||||
}
|
||||
|
||||
const QueueRow = memo(function QueueRow({
|
||||
songId,
|
||||
queueIndex,
|
||||
isLast,
|
||||
isCurrent,
|
||||
onSkipTo,
|
||||
onMove,
|
||||
}: Omit<QueueItem, "key"> & {
|
||||
isLast: boolean
|
||||
isCurrent: boolean
|
||||
onSkipTo: (index: number) => void
|
||||
onMove: (index: number, direction: -1 | 1) => void
|
||||
}) {
|
||||
const colors = useThemeColors()
|
||||
const song = useSong(songId)
|
||||
|
||||
return (
|
||||
<View>
|
||||
{song ? (
|
||||
<SongRow song={song} onPress={() => onSkipTo(queueIndex)} />
|
||||
) : (
|
||||
<SongRowSkeleton />
|
||||
)}
|
||||
<View style={styles.queueActions}>
|
||||
<Pressable
|
||||
disabled={queueIndex === 0}
|
||||
onPress={() => onMove(queueIndex, -1)}
|
||||
>
|
||||
<Text style={{ color: colors.foreground }}>Move up</Text>
|
||||
</Pressable>
|
||||
<Pressable disabled={isLast} onPress={() => onMove(queueIndex, 1)}>
|
||||
<Text style={{ color: colors.foreground }}>Move down</Text>
|
||||
</Pressable>
|
||||
{isCurrent ? (
|
||||
<Text style={{ color: colors.primary, fontWeight: "700" }}>
|
||||
Now playing
|
||||
</Text>
|
||||
) : null}
|
||||
</View>
|
||||
</View>
|
||||
)
|
||||
})
|
||||
|
||||
export default function QueueScreen() {
|
||||
const router = useRouter()
|
||||
const colors = useThemeColors()
|
||||
const { queueSongIds, queueHistorySongIds } = usePlaybackQueue()
|
||||
const { skipToQueueIndex, clearQueue, reorderQueue } = usePlaybackActions()
|
||||
const historySongs = useSongs(queueHistorySongIds)
|
||||
|
||||
const items = useMemo<QueueItem[]>(() => {
|
||||
const occurrences = new Map<string, number>()
|
||||
return queueSongIds.map((songId, queueIndex) => {
|
||||
const occurrence = occurrences.get(songId) ?? 0
|
||||
occurrences.set(songId, occurrence + 1)
|
||||
return { songId, queueIndex, key: `${songId}:${occurrence}` }
|
||||
})
|
||||
}, [queueSongIds])
|
||||
|
||||
const moveSong = useCallback(
|
||||
(fromIndex: number, direction: -1 | 1) => {
|
||||
const toIndex = fromIndex + direction
|
||||
if (toIndex < 0 || toIndex >= queueSongIds.length) return
|
||||
const next = [...queueSongIds]
|
||||
const [item] = next.splice(fromIndex, 1)
|
||||
next.splice(toIndex, 0, item)
|
||||
void reorderQueue(next)
|
||||
},
|
||||
[queueSongIds, reorderQueue]
|
||||
)
|
||||
|
||||
function handleClearQueue() {
|
||||
if (router.canGoBack()) {
|
||||
router.back()
|
||||
setTimeout(() => {
|
||||
void clearQueue()
|
||||
}, 0)
|
||||
return
|
||||
}
|
||||
|
||||
void clearQueue()
|
||||
}
|
||||
|
||||
return (
|
||||
<>
|
||||
<Stack.Screen
|
||||
options={{
|
||||
headerRight: () =>
|
||||
queueSongIds.length > 0 ? (
|
||||
<Button
|
||||
title="Clear"
|
||||
variant="ghost"
|
||||
onPress={handleClearQueue}
|
||||
/>
|
||||
) : null,
|
||||
}}
|
||||
/>
|
||||
<FlatList
|
||||
style={{ flex: 1, backgroundColor: colors.background }}
|
||||
ListHeaderComponent={
|
||||
<View>
|
||||
<Text style={[styles.section, { color: colors.mutedForeground }]}>
|
||||
Up Next
|
||||
</Text>
|
||||
{queueSongIds.length === 0 ? (
|
||||
<Text style={[styles.empty, { color: colors.mutedForeground }]}>
|
||||
Queue is empty
|
||||
</Text>
|
||||
) : null}
|
||||
</View>
|
||||
}
|
||||
{...longListProps}
|
||||
data={items}
|
||||
keyExtractor={queueItemKey}
|
||||
contentContainerStyle={{ paddingBottom: contentBottomInset }}
|
||||
contentInsetAdjustmentBehavior="automatic"
|
||||
renderItem={({ item }) => (
|
||||
<QueueRow
|
||||
songId={item.songId}
|
||||
queueIndex={item.queueIndex}
|
||||
isLast={item.queueIndex === queueSongIds.length - 1}
|
||||
isCurrent={item.queueIndex === 0}
|
||||
onSkipTo={skipToQueueIndex}
|
||||
onMove={moveSong}
|
||||
/>
|
||||
)}
|
||||
ListFooterComponent={
|
||||
queueHistorySongIds.length > 0 ? (
|
||||
<View style={styles.history}>
|
||||
<Text style={[styles.section, { color: colors.mutedForeground }]}>
|
||||
History
|
||||
</Text>
|
||||
{historySongs.map((song, index) =>
|
||||
song ? (
|
||||
<SongRow key={`${song.id}-${index}`} song={song} />
|
||||
) : (
|
||||
<SongRowSkeleton
|
||||
key={`${queueHistorySongIds[index]}-${index}`}
|
||||
/>
|
||||
)
|
||||
)}
|
||||
</View>
|
||||
) : undefined
|
||||
}
|
||||
/>
|
||||
</>
|
||||
)
|
||||
}
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
section: {
|
||||
paddingHorizontal: spacing.lg,
|
||||
paddingTop: spacing.md,
|
||||
fontSize: 12,
|
||||
fontWeight: "700",
|
||||
textTransform: "uppercase",
|
||||
},
|
||||
empty: { padding: spacing.lg },
|
||||
queueActions: {
|
||||
flexDirection: "row",
|
||||
gap: spacing.lg,
|
||||
paddingHorizontal: spacing.lg,
|
||||
paddingBottom: spacing.sm,
|
||||
},
|
||||
history: { marginTop: spacing.lg },
|
||||
})
|
||||
@@ -23,6 +23,7 @@ import { useServerConfig } from "@/contexts/server-config"
|
||||
import {
|
||||
setArtworkColorsEnabled,
|
||||
useArtworkColorsEnabled,
|
||||
useArtworkColorPreferenceLoaded,
|
||||
} from "@/lib/artwork-color-preference"
|
||||
import { initialsFromName } from "@/lib/format"
|
||||
import { useCachedQuery } from "@/hooks/use-cached-query"
|
||||
@@ -171,6 +172,7 @@ export default function SettingsScreen() {
|
||||
|
||||
function AppearanceSection() {
|
||||
const enabled = useArtworkColorsEnabled()
|
||||
const loaded = useArtworkColorPreferenceLoaded()
|
||||
const [saving, setSaving] = useState(false)
|
||||
|
||||
return (
|
||||
@@ -178,8 +180,8 @@ function AppearanceSection() {
|
||||
<SwitchRow
|
||||
title="New artwork colors"
|
||||
subtitle="Use the new color algorithm on this device."
|
||||
value={enabled ?? false}
|
||||
disabled={enabled === undefined || saving}
|
||||
value={enabled}
|
||||
disabled={!loaded || saving}
|
||||
onValueChange={async (checked) => {
|
||||
setSaving(true)
|
||||
try {
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
export { default } from "../home/queue"
|
||||
@@ -0,0 +1 @@
|
||||
export { default } from "../home/queue"
|
||||
@@ -39,7 +39,7 @@ import { MarqueeText } from "@/components/marquee-text"
|
||||
import {
|
||||
MediaActionMenu,
|
||||
type MediaAction,
|
||||
} from "@/components/media-context-menu"
|
||||
} from "@/components/media-actions-sheet"
|
||||
import {
|
||||
NowPlayingQueue,
|
||||
QUEUE_HORIZONTAL_INSET,
|
||||
|
||||
@@ -134,7 +134,7 @@ function songEntity(song: {
|
||||
albumId: song.albumId,
|
||||
duration: String(song.durationSeconds),
|
||||
genres: song.genres ?? "",
|
||||
year: song.year == null ? "" : String(song.year),
|
||||
year: song.year ? String(song.year) : "",
|
||||
track: song.track == null ? "" : String(song.track),
|
||||
disk: song.diskNumber == null ? "" : String(song.diskNumber),
|
||||
favorite: song.favorite ? "1" : "0",
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
export type { MediaAction, MediaMenuConfig, MediaNavigation } from "@/components/media-context-menu"
|
||||
export type { MediaShareContext } from "@/lib/media-links"
|
||||
export {
|
||||
buildMediaMenuActions,
|
||||
MediaActionMenu,
|
||||
MediaContextMenu,
|
||||
} from "@/components/media-context-menu"
|
||||
@@ -45,8 +45,6 @@ export const SongRow = memo(function SongRow({
|
||||
swipe?: {
|
||||
group: SwipeRowGroup
|
||||
onPlayNext: () => void
|
||||
onAddToQueue: () => void
|
||||
onRemove?: () => void
|
||||
backgroundColor: string
|
||||
}
|
||||
/** Album/playlist layout: the divider starts at the title, not the artwork. */
|
||||
@@ -109,12 +107,10 @@ export const SongRow = memo(function SongRow({
|
||||
? styles.insetRow
|
||||
: [styles.row, { borderBottomColor: divider }]
|
||||
const row =
|
||||
swipe && Platform.OS !== "web" ? (
|
||||
swipe && Platform.OS === "ios" ? (
|
||||
<SongSwipeRow
|
||||
group={swipe.group}
|
||||
onPlayNext={swipe.onPlayNext}
|
||||
onAddToQueue={swipe.onAddToQueue}
|
||||
onRemove={swipe.onRemove}
|
||||
backgroundColor={swipe.backgroundColor}
|
||||
onPress={onPress}
|
||||
style={rowStyle}
|
||||
@@ -171,8 +167,6 @@ export const SongListRow = memo(function SongListRow({
|
||||
swipe?: {
|
||||
group: SwipeRowGroup
|
||||
onPlayNext: () => void
|
||||
onAddToQueue: () => void
|
||||
onRemove?: () => void
|
||||
backgroundColor: string
|
||||
}
|
||||
onPlay: (song: BrowseSong) => void
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
import { Ionicons } from "@expo/vector-icons"
|
||||
import * as Haptics from "expo-haptics"
|
||||
import { SymbolView } from "expo-symbols"
|
||||
import {
|
||||
@@ -9,7 +8,6 @@ import {
|
||||
type ReactNode,
|
||||
} from "react"
|
||||
import {
|
||||
Platform,
|
||||
Pressable,
|
||||
StyleSheet,
|
||||
type StyleProp,
|
||||
@@ -28,10 +26,7 @@ import Animated, {
|
||||
import { scheduleOnRN } from "react-native-worklets"
|
||||
import type { SwipeRowGroup } from "@/components/ios-swipe-to-remove-row"
|
||||
|
||||
const IS_ANDROID = Platform.OS === "android"
|
||||
|
||||
const ACTION_WIDTH = 82
|
||||
const LEADING_ACTION_WIDTH = 72
|
||||
const SPRING = { duration: 450, dampingRatio: 1 }
|
||||
|
||||
function impact() {
|
||||
@@ -46,8 +41,6 @@ export function SongSwipeRow({
|
||||
group,
|
||||
onPress,
|
||||
onPlayNext,
|
||||
onAddToQueue,
|
||||
onRemove,
|
||||
}: {
|
||||
children: ReactNode
|
||||
style?: StyleProp<ViewStyle>
|
||||
@@ -55,10 +48,7 @@ export function SongSwipeRow({
|
||||
group: SwipeRowGroup
|
||||
onPress?: () => void
|
||||
onPlayNext: () => void
|
||||
onAddToQueue: () => void
|
||||
onRemove?: () => void
|
||||
}) {
|
||||
const hasRemove = IS_ANDROID && !!onRemove
|
||||
const x = useSharedValue(0)
|
||||
const startX = useSharedValue(0)
|
||||
const width = useSharedValue(0)
|
||||
@@ -88,10 +78,10 @@ export function SongSwipeRow({
|
||||
const activate = useCallback(
|
||||
(side: number) => {
|
||||
close()
|
||||
if (side > 0) onAddToQueue()
|
||||
if (side > 0) onPlayNext()
|
||||
// Download is intentionally a placeholder.
|
||||
},
|
||||
[close, onAddToQueue]
|
||||
[close, onPlayNext]
|
||||
)
|
||||
const tapRow = useCallback(() => {
|
||||
if (open) close()
|
||||
@@ -115,13 +105,7 @@ export function SongSwipeRow({
|
||||
Math.min(width.value, startX.value + event.translationX)
|
||||
)
|
||||
const commit =
|
||||
Math.abs(x.value) >
|
||||
Math.max(
|
||||
x.value > 0
|
||||
? LEADING_ACTION_WIDTH * 2
|
||||
: ACTION_WIDTH * (hasRemove ? 2 : 1),
|
||||
width.value * 0.55
|
||||
)
|
||||
Math.abs(x.value) > Math.max(ACTION_WIDTH, width.value * 0.55)
|
||||
if (commit !== committed.value) {
|
||||
committed.value = commit
|
||||
commitProgress.value = withSpring(commit ? 1 : 0, SPRING)
|
||||
@@ -140,16 +124,10 @@ export function SongSwipeRow({
|
||||
Math.abs(x.value) > 10 && projected * side > ACTION_WIDTH / 2
|
||||
? side
|
||||
: 0
|
||||
x.value = withSpring(
|
||||
target *
|
||||
(target > 0
|
||||
? LEADING_ACTION_WIDTH * 2
|
||||
: ACTION_WIDTH * (hasRemove ? 2 : 1)),
|
||||
{
|
||||
...SPRING,
|
||||
velocity: event.velocityX,
|
||||
}
|
||||
)
|
||||
x.value = withSpring(target * ACTION_WIDTH, {
|
||||
...SPRING,
|
||||
velocity: event.velocityX,
|
||||
})
|
||||
scheduleOnRN(settle, target)
|
||||
})
|
||||
.onFinalize((_event, success) => {
|
||||
@@ -167,7 +145,6 @@ export function SongSwipeRow({
|
||||
return Gesture.Exclusive(pan, tap)
|
||||
}, [
|
||||
activate,
|
||||
hasRemove,
|
||||
begin,
|
||||
close,
|
||||
commitProgress,
|
||||
@@ -181,14 +158,12 @@ export function SongSwipeRow({
|
||||
|
||||
const rowStyle = useAnimatedStyle(() => ({
|
||||
transform: [{ translateX: x.value }],
|
||||
borderRadius: IS_ANDROID
|
||||
? 0
|
||||
: interpolate(
|
||||
Math.abs(x.value),
|
||||
[0, 40],
|
||||
[0, height.value / 2],
|
||||
Extrapolation.CLAMP
|
||||
),
|
||||
borderRadius: interpolate(
|
||||
Math.abs(x.value),
|
||||
[0, 40],
|
||||
[0, height.value / 2],
|
||||
Extrapolation.CLAMP
|
||||
),
|
||||
}))
|
||||
const fillStyle = useAnimatedStyle(() => ({
|
||||
opacity: interpolate(
|
||||
@@ -215,37 +190,8 @@ export function SongSwipeRow({
|
||||
open={open === 1}
|
||||
onPress={() => activate(1)}
|
||||
/>
|
||||
<SwipeAction
|
||||
side={1}
|
||||
secondary
|
||||
x={x}
|
||||
height={height}
|
||||
progress={commitProgress}
|
||||
open={open === 1}
|
||||
onPress={() => {
|
||||
close()
|
||||
onPlayNext()
|
||||
}}
|
||||
/>
|
||||
{hasRemove && (
|
||||
<SwipeAction
|
||||
side={-1}
|
||||
secondary
|
||||
paired
|
||||
remove
|
||||
x={x}
|
||||
height={height}
|
||||
progress={commitProgress}
|
||||
open={open === -1}
|
||||
onPress={() => {
|
||||
close()
|
||||
onRemove?.()
|
||||
}}
|
||||
/>
|
||||
)}
|
||||
<SwipeAction
|
||||
side={-1}
|
||||
paired={hasRemove}
|
||||
x={x}
|
||||
height={height}
|
||||
progress={commitProgress}
|
||||
@@ -258,23 +204,11 @@ export function SongSwipeRow({
|
||||
accessibilityRole="button"
|
||||
onAccessibilityTap={tapRow}
|
||||
accessibilityActions={[
|
||||
{ name: "addToQueue", label: "Add to Queue" },
|
||||
{ name: "playNext", label: "Play Next" },
|
||||
{ name: "download", label: "Download" },
|
||||
...(hasRemove
|
||||
? [{ name: "remove", label: "Remove from Playlist" }]
|
||||
: []),
|
||||
]}
|
||||
onAccessibilityAction={(event) => {
|
||||
if (event.nativeEvent.actionName === "remove" && hasRemove) {
|
||||
close()
|
||||
onRemove?.()
|
||||
}
|
||||
if (event.nativeEvent.actionName === "addToQueue") activate(1)
|
||||
if (event.nativeEvent.actionName === "playNext") {
|
||||
close()
|
||||
onPlayNext()
|
||||
}
|
||||
if (event.nativeEvent.actionName === "playNext") activate(1)
|
||||
}}
|
||||
style={[styles.row, { backgroundColor }, rowStyle]}
|
||||
>
|
||||
@@ -291,9 +225,6 @@ export function SongSwipeRow({
|
||||
|
||||
function SwipeAction({
|
||||
side,
|
||||
secondary = false,
|
||||
paired = side > 0,
|
||||
remove = false,
|
||||
x,
|
||||
height,
|
||||
progress,
|
||||
@@ -301,48 +232,22 @@ function SwipeAction({
|
||||
onPress,
|
||||
}: {
|
||||
side: 1 | -1
|
||||
secondary?: boolean
|
||||
paired?: boolean
|
||||
remove?: boolean
|
||||
x: SharedValue<number>
|
||||
height: SharedValue<number>
|
||||
progress: SharedValue<number>
|
||||
open: boolean
|
||||
onPress: () => void
|
||||
}) {
|
||||
const actionStyle = useAnimatedStyle(() => {
|
||||
const revealed = Math.max(0, x.value * side)
|
||||
const primaryWidth = (revealed * (1 + progress.value)) / 2
|
||||
return {
|
||||
width: !paired
|
||||
? revealed
|
||||
: secondary
|
||||
? revealed - primaryWidth
|
||||
: primaryWidth,
|
||||
...(secondary
|
||||
? side > 0
|
||||
? { left: primaryWidth }
|
||||
: { right: primaryWidth }
|
||||
: {}),
|
||||
}
|
||||
})
|
||||
const actionStyle = useAnimatedStyle(() => ({
|
||||
width: Math.max(0, x.value * side),
|
||||
}))
|
||||
const pillStyle = useAnimatedStyle(() => {
|
||||
const total = Math.max(0, x.value * side)
|
||||
const revealed = !paired
|
||||
? total
|
||||
: (total * (secondary ? 1 - progress.value : 1 + progress.value)) / 2
|
||||
if (IS_ANDROID) {
|
||||
return { width: revealed, height: height.value, borderRadius: 0 }
|
||||
}
|
||||
const revealed = Math.max(0, x.value * side)
|
||||
const resting = Math.max(
|
||||
0,
|
||||
Math.min(
|
||||
revealed - (side > 0 ? 10 : 20),
|
||||
interpolate(
|
||||
revealed,
|
||||
[24, side > 0 ? LEADING_ACTION_WIDTH : ACTION_WIDTH, 220],
|
||||
[0, 62, 200]
|
||||
)
|
||||
revealed - 20,
|
||||
interpolate(revealed, [24, ACTION_WIDTH, 220], [0, 62, 200])
|
||||
)
|
||||
)
|
||||
const pillWidth =
|
||||
@@ -387,61 +292,27 @@ function SwipeAction({
|
||||
>
|
||||
<Pressable
|
||||
accessibilityRole="button"
|
||||
accessibilityLabel={
|
||||
remove
|
||||
? "Remove from Playlist"
|
||||
: side > 0
|
||||
? secondary
|
||||
? "Play Next"
|
||||
: "Add to Queue"
|
||||
: "Download"
|
||||
}
|
||||
accessibilityLabel={side > 0 ? "Play Next" : "Download"}
|
||||
onPress={onPress}
|
||||
style={styles.actionButton}
|
||||
>
|
||||
<Animated.View
|
||||
style={[
|
||||
styles.pill,
|
||||
{
|
||||
backgroundColor: remove
|
||||
? "#d32f2f"
|
||||
: side > 0
|
||||
? secondary
|
||||
? "#6b5bff"
|
||||
: "#f29943"
|
||||
: "#008dff",
|
||||
},
|
||||
{ backgroundColor: side > 0 ? "#6b5bff" : "#008dff" },
|
||||
pillStyle,
|
||||
]}
|
||||
>
|
||||
<Animated.View style={iconStyle}>
|
||||
{IS_ANDROID ? (
|
||||
<Ionicons
|
||||
name={
|
||||
remove
|
||||
? "trash-outline"
|
||||
: side < 0
|
||||
? "arrow-down"
|
||||
: secondary
|
||||
? "play-forward"
|
||||
: "list"
|
||||
}
|
||||
size={22}
|
||||
color="white"
|
||||
/>
|
||||
) : (
|
||||
<SymbolView
|
||||
name={
|
||||
side > 0
|
||||
? secondary
|
||||
? "text.line.first.and.arrowtriangle.forward"
|
||||
: "text.line.last.and.arrowtriangle.forward"
|
||||
: "arrow.down"
|
||||
}
|
||||
size={22}
|
||||
tintColor="white"
|
||||
/>
|
||||
)}
|
||||
<SymbolView
|
||||
name={
|
||||
side > 0
|
||||
? "text.line.first.and.arrowtriangle.forward"
|
||||
: "arrow.down"
|
||||
}
|
||||
size={22}
|
||||
tintColor="white"
|
||||
/>
|
||||
</Animated.View>
|
||||
</Animated.View>
|
||||
</Pressable>
|
||||
|
||||
@@ -18,7 +18,7 @@ import {
|
||||
import { useTabletPlayerInsets } from "@/contexts/tablet-player-layout"
|
||||
|
||||
import { CoverImage } from "@/components/cover-image"
|
||||
import { MediaActionMenu } from "@/components/media-context-menu"
|
||||
import { MediaActionMenu } from "@/components/media-actions-sheet"
|
||||
import { PlayerSymbol } from "@/components/player-symbol"
|
||||
import { useFavorites } from "@/contexts/favorites"
|
||||
import { usePlaybackActions, usePlaybackQueue } from "@/contexts/playback"
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
import { createContext, useContext, useMemo, type ReactNode } from "react"
|
||||
import { createContext, useContext, type ReactNode } from "react"
|
||||
|
||||
type ConvexAuthSessionContextValue = {
|
||||
invalidateSession: () => Promise<void>
|
||||
}
|
||||
|
||||
const ConvexAuthSessionContext =
|
||||
createContext<ConvexAuthSessionContextValue | null>(null)
|
||||
const ConvexAuthSessionContext = createContext<ConvexAuthSessionContextValue | null>(
|
||||
null
|
||||
)
|
||||
|
||||
export function ConvexAuthSessionProvider({
|
||||
children,
|
||||
@@ -14,9 +15,8 @@ export function ConvexAuthSessionProvider({
|
||||
children: ReactNode
|
||||
invalidateSession: () => Promise<void>
|
||||
}) {
|
||||
const value = useMemo(() => ({ invalidateSession }), [invalidateSession])
|
||||
return (
|
||||
<ConvexAuthSessionContext.Provider value={value}>
|
||||
<ConvexAuthSessionContext.Provider value={{ invalidateSession }}>
|
||||
{children}
|
||||
</ConvexAuthSessionContext.Provider>
|
||||
)
|
||||
@@ -25,9 +25,7 @@ export function ConvexAuthSessionProvider({
|
||||
export function useInvalidateAuthSession() {
|
||||
const context = useContext(ConvexAuthSessionContext)
|
||||
if (!context) {
|
||||
throw new Error(
|
||||
"useInvalidateAuthSession must be used within ConvexAuthSessionProvider"
|
||||
)
|
||||
throw new Error("useInvalidateAuthSession must be used within ConvexAppProvider")
|
||||
}
|
||||
return context
|
||||
}
|
||||
+783
-142
File diff suppressed because it is too large.
Load diff
@@ -1,142 +0,0 @@
|
||||
import { useEffect, useMemo, useState } from "react"
|
||||
|
||||
import { themeCoverPalette, type CoverPalette } from "@/lib/cover-palette"
|
||||
import { readCache, writeCache } from "@/lib/persistent-cache"
|
||||
import { useIsDark, useThemeColors } from "@/lib/theme"
|
||||
import { withCoverImageSize } from "@/lib/urls"
|
||||
|
||||
// How long a screen holds its skeleton for the first extraction of a cover,
|
||||
// so rows render once with final colors instead of flashing from the theme.
|
||||
export const COVER_PALETTE_WAIT_MS = 400
|
||||
|
||||
export type CoverPaletteResult = { palette: CoverPalette; settled: boolean }
|
||||
|
||||
type CoverPaletteSourceOptions<Swatches> = {
|
||||
/** Persistent cache key for a 64px cover URI. */
|
||||
cacheKey: (colorSourceUri: string) => string
|
||||
extract: (colorSourceUri: string) => Promise<Swatches | null>
|
||||
derive: (swatches: Swatches, isDark: boolean) => CoverPalette | null
|
||||
/** Reject persisted entries written in an older shape. */
|
||||
isValidCache?: (swatches: Swatches) => boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* One artwork color pipeline: an extractor and palette derivation with their
|
||||
* own memory cache, persistent cache and in-flight requests.
|
||||
*/
|
||||
export function createCoverPaletteSource<Swatches>({
|
||||
cacheKey,
|
||||
extract,
|
||||
derive,
|
||||
isValidCache,
|
||||
}: CoverPaletteSourceOptions<Swatches>) {
|
||||
const swatchesByKey = new Map<string, Swatches | null>()
|
||||
const pending = new Map<string, Promise<Swatches | null>>()
|
||||
|
||||
function cachedSwatches(key: string): Swatches | null | undefined {
|
||||
if (swatchesByKey.has(key)) return swatchesByKey.get(key)
|
||||
const cached = readCache<Swatches>(cacheKey(key))
|
||||
return cached && isValidCache && !isValidCache(cached) ? undefined : cached
|
||||
}
|
||||
|
||||
function extractSwatches(key: string) {
|
||||
const inFlight = pending.get(key)
|
||||
if (inFlight) return inFlight
|
||||
|
||||
const request = extract(key)
|
||||
.catch(() => null)
|
||||
.then((swatches) => {
|
||||
swatchesByKey.set(key, swatches)
|
||||
if (swatches) writeCache(cacheKey(key), swatches)
|
||||
pending.delete(key)
|
||||
return swatches
|
||||
})
|
||||
pending.set(key, request)
|
||||
return request
|
||||
}
|
||||
|
||||
function prefetch(uri: string) {
|
||||
const key = withCoverImageSize(uri, 64)
|
||||
if (cachedSwatches(key) !== undefined) return
|
||||
void extractSwatches(key)
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors for a screen tinted by `uri`'s cover art. Pass `uri` as "" to skip
|
||||
* extraction. Pass `hasCover` as `undefined` while it isn't known yet so
|
||||
* extraction can start early.
|
||||
*
|
||||
* `settled` turns true once the palette is final or after
|
||||
* `COVER_PALETTE_WAIT_MS`, whichever comes first.
|
||||
*/
|
||||
function usePalette(
|
||||
uri: string,
|
||||
hasCover: boolean | undefined
|
||||
): CoverPaletteResult {
|
||||
const theme = useThemeColors()
|
||||
const isDark = useIsDark()
|
||||
const key = uri ? withCoverImageSize(uri, 64) : ""
|
||||
const [resolved, setResolved] = useState(() => ({
|
||||
key,
|
||||
swatches: key ? cachedSwatches(key) : null,
|
||||
}))
|
||||
const [waitedKey, setWaitedKey] = useState<string | null>(null)
|
||||
|
||||
const swatches =
|
||||
resolved.key === key ? resolved.swatches : key ? cachedSwatches(key) : null
|
||||
|
||||
useEffect(() => {
|
||||
if (!key || hasCover === false) return
|
||||
let cancelled = false
|
||||
const known = cachedSwatches(key)
|
||||
const show = (next: Swatches | null) =>
|
||||
setResolved((prev) =>
|
||||
prev.key === key && sameSwatches(prev.swatches, next)
|
||||
? prev
|
||||
: { key, swatches: next }
|
||||
)
|
||||
if (known !== undefined && swatchesByKey.has(key)) {
|
||||
show(known)
|
||||
return
|
||||
}
|
||||
|
||||
// Persisted swatches render immediately; refresh them in the background
|
||||
// in case the cover changed.
|
||||
const timer =
|
||||
known === undefined
|
||||
? setTimeout(
|
||||
() => !cancelled && setWaitedKey(key),
|
||||
COVER_PALETTE_WAIT_MS
|
||||
)
|
||||
: null
|
||||
void extractSwatches(key).then((next) => {
|
||||
if (!cancelled) show(next ?? known ?? null)
|
||||
})
|
||||
return () => {
|
||||
cancelled = true
|
||||
if (timer) clearTimeout(timer)
|
||||
}
|
||||
}, [hasCover, key])
|
||||
|
||||
const palette = useMemo(() => {
|
||||
const fromArt =
|
||||
hasCover !== false && swatches ? derive(swatches, isDark) : null
|
||||
return fromArt ?? themeCoverPalette(theme, isDark)
|
||||
}, [hasCover, isDark, swatches, theme])
|
||||
|
||||
return {
|
||||
palette,
|
||||
settled:
|
||||
!key ||
|
||||
hasCover === false ||
|
||||
swatches !== undefined ||
|
||||
waitedKey === key,
|
||||
}
|
||||
}
|
||||
|
||||
return { prefetch, usePalette }
|
||||
}
|
||||
|
||||
function sameSwatches(a: unknown, b: unknown) {
|
||||
return a === b || JSON.stringify(a) === JSON.stringify(b)
|
||||
}
|
||||
@@ -1,47 +1,147 @@
|
||||
import { useEffect, useMemo, useState } from "react"
|
||||
import {
|
||||
createCoverPaletteSource,
|
||||
type CoverPaletteResult,
|
||||
} from "@/hooks/cover-palette-source"
|
||||
import {
|
||||
prefetchLegacyCoverPalette,
|
||||
useLegacyCoverPalette,
|
||||
} from "@/hooks/use-legacy-cover-palette"
|
||||
import {
|
||||
loadArtworkColorsEnabled,
|
||||
artworkColorsEnabled,
|
||||
useArtworkColorsEnabled,
|
||||
} from "@/lib/artwork-color-preference"
|
||||
import { prefetchLegacyCoverPalette, useLegacyCoverPalette } from "@/hooks/use-legacy-cover-palette"
|
||||
import { extractCoverSwatches } from "@/lib/artwork-colors"
|
||||
import { deriveCoverPalette, type CoverSwatches } from "@/lib/cover-palette"
|
||||
|
||||
export { COVER_PALETTE_WAIT_MS } from "@/hooks/cover-palette-source"
|
||||
import {
|
||||
deriveCoverPalette,
|
||||
themeCoverPalette,
|
||||
type CoverPalette,
|
||||
type CoverSwatches,
|
||||
} from "@/lib/cover-palette"
|
||||
import { readCache, writeCache } from "@/lib/persistent-cache"
|
||||
import { useIsDark, useThemeColors } from "@/lib/theme"
|
||||
import { withCoverImageSize } from "@/lib/urls"
|
||||
|
||||
const region = createCoverPaletteSource<CoverSwatches>({
|
||||
cacheKey: (colorSourceUri) => `palette:v2:${colorSourceUri}`,
|
||||
extract: extractCoverSwatches,
|
||||
derive: (swatches) => deriveCoverPalette(swatches),
|
||||
})
|
||||
// How long a screen holds its skeleton for the first extraction of a cover,
|
||||
// so rows render once with final colors instead of flashing from the theme.
|
||||
export const COVER_PALETTE_WAIT_MS = 400
|
||||
|
||||
const swatchesByKey = new Map<string, CoverSwatches | null>()
|
||||
const pending = new Map<string, Promise<CoverSwatches | null>>()
|
||||
|
||||
function cacheKey(colorSourceUri: string) {
|
||||
return `palette:v2:${colorSourceUri}`
|
||||
}
|
||||
|
||||
function sameSwatches(
|
||||
a: CoverSwatches | null | undefined,
|
||||
b: CoverSwatches | null | undefined
|
||||
) {
|
||||
return a === b || JSON.stringify(a) === JSON.stringify(b)
|
||||
}
|
||||
|
||||
function cachedSwatches(key: string): CoverSwatches | null | undefined {
|
||||
if (swatchesByKey.has(key)) return swatchesByKey.get(key)
|
||||
return readCache<CoverSwatches>(cacheKey(key))
|
||||
}
|
||||
|
||||
function extractSwatches(key: string) {
|
||||
const inFlight = pending.get(key)
|
||||
if (inFlight) return inFlight
|
||||
|
||||
const request = extractCoverSwatches(key)
|
||||
.catch(() => null)
|
||||
.then((swatches) => {
|
||||
swatchesByKey.set(key, swatches)
|
||||
if (swatches) writeCache(cacheKey(key), swatches)
|
||||
pending.delete(key)
|
||||
return swatches
|
||||
})
|
||||
pending.set(key, request)
|
||||
return request
|
||||
}
|
||||
|
||||
/** Warm visible artwork colors before a detail page is pushed. */
|
||||
export function prefetchCoverPalette(uri: string) {
|
||||
void loadArtworkColorsEnabled().then((enabled) =>
|
||||
enabled ? region.prefetch(uri) : prefetchLegacyCoverPalette(uri)
|
||||
)
|
||||
if (!artworkColorsEnabled()) {
|
||||
prefetchLegacyCoverPalette(uri)
|
||||
return
|
||||
}
|
||||
const key = withCoverImageSize(uri, 64)
|
||||
if (cachedSwatches(key) !== undefined) return
|
||||
void extractSwatches(key)
|
||||
}
|
||||
|
||||
/**
|
||||
* Colors for a screen tinted by `uri`'s cover art, from whichever pipeline the
|
||||
* device preference selects. Nothing is extracted until the preference loads,
|
||||
* and the screen stays unsettled meanwhile so it doesn't flash theme colors.
|
||||
* Colors for a screen tinted by `uri`'s cover art. Extraction runs once per
|
||||
* cover and is cached on device. Pass `hasCover` as `undefined` while it isn't
|
||||
* known yet so extraction can start early.
|
||||
*
|
||||
* `settled` turns true once the palette is final or after
|
||||
* `COVER_PALETTE_WAIT_MS`, whichever comes first.
|
||||
*/
|
||||
export function useCoverPalette(
|
||||
function useRegionCoverPalette(
|
||||
uri: string,
|
||||
hasCover: boolean | undefined
|
||||
): CoverPaletteResult {
|
||||
const enabled = useArtworkColorsEnabled()
|
||||
const current = region.usePalette(enabled === true ? uri : "", hasCover)
|
||||
const legacy = useLegacyCoverPalette(enabled === false ? uri : "", hasCover)
|
||||
if (enabled === undefined) {
|
||||
return { palette: current.palette, settled: !uri || hasCover === false }
|
||||
): { palette: CoverPalette; settled: boolean } {
|
||||
const theme = useThemeColors()
|
||||
const isDark = useIsDark()
|
||||
const key = uri ? withCoverImageSize(uri, 64) : ""
|
||||
const [resolved, setResolved] = useState(() => ({
|
||||
key,
|
||||
swatches: key ? cachedSwatches(key) : null,
|
||||
}))
|
||||
const [waitedKey, setWaitedKey] = useState<string | null>(null)
|
||||
|
||||
const swatches =
|
||||
resolved.key === key ? resolved.swatches : key ? cachedSwatches(key) : null
|
||||
|
||||
useEffect(() => {
|
||||
if (!key || hasCover === false) return
|
||||
let cancelled = false
|
||||
const known = cachedSwatches(key)
|
||||
const show = (next: CoverSwatches | null) =>
|
||||
setResolved((prev) =>
|
||||
prev.key === key && sameSwatches(prev.swatches, next)
|
||||
? prev
|
||||
: { key, swatches: next }
|
||||
)
|
||||
if (known !== undefined && swatchesByKey.has(key)) {
|
||||
show(known)
|
||||
return
|
||||
}
|
||||
|
||||
// Persisted swatches render immediately; refresh them in the background in
|
||||
// case the cover changed.
|
||||
const timer =
|
||||
known === undefined
|
||||
? setTimeout(
|
||||
() => !cancelled && setWaitedKey(key),
|
||||
COVER_PALETTE_WAIT_MS
|
||||
)
|
||||
: null
|
||||
void extractSwatches(key).then((next) => {
|
||||
if (!cancelled) show(next ?? known ?? null)
|
||||
})
|
||||
return () => {
|
||||
cancelled = true
|
||||
if (timer) clearTimeout(timer)
|
||||
}
|
||||
}, [hasCover, key])
|
||||
|
||||
const palette = useMemo(() => {
|
||||
const fromArt =
|
||||
hasCover !== false && swatches
|
||||
? deriveCoverPalette(swatches)
|
||||
: null
|
||||
return fromArt ?? themeCoverPalette(theme, isDark)
|
||||
}, [hasCover, isDark, swatches, theme])
|
||||
|
||||
return {
|
||||
palette,
|
||||
settled:
|
||||
!key || hasCover === false || swatches !== undefined || waitedKey === key,
|
||||
}
|
||||
return enabled ? current : legacy
|
||||
}
|
||||
|
||||
/** Switch both extraction and palette derivation without mixing their caches. */
|
||||
export function useCoverPalette(uri: string, hasCover: boolean | undefined) {
|
||||
const enabled = useArtworkColorsEnabled()
|
||||
const region = useRegionCoverPalette(enabled ? uri : "", hasCover)
|
||||
const legacy = useLegacyCoverPalette(enabled ? "" : uri, hasCover)
|
||||
return enabled ? region : legacy
|
||||
}
|
||||
@@ -1,14 +1,29 @@
|
||||
import { useEffect, useMemo, useState } from "react"
|
||||
import { getColors, type ImageColorsResult } from "react-native-image-colors"
|
||||
|
||||
import { createCoverPaletteSource } from "@/hooks/cover-palette-source"
|
||||
import {
|
||||
deriveCoverPalette,
|
||||
type LegacyCoverSwatches as CoverSwatches,
|
||||
} from "@/lib/legacy-cover-palette"
|
||||
themeCoverPalette,
|
||||
type CoverPalette,
|
||||
} from "@/lib/cover-palette"
|
||||
import { deriveCoverPalette, type LegacyCoverSwatches as CoverSwatches } from "@/lib/legacy-cover-palette"
|
||||
import { readCache, writeCache } from "@/lib/persistent-cache"
|
||||
import { useIsDark, useThemeColors } from "@/lib/theme"
|
||||
import { withCoverImageSize } from "@/lib/urls"
|
||||
|
||||
// How long a screen holds its skeleton for the first extraction of a cover,
|
||||
// so rows render once with final colors instead of flashing from the theme.
|
||||
const COVER_PALETTE_WAIT_MS = 400
|
||||
|
||||
// image-colors substitutes this for swatches it couldn't find.
|
||||
const MISSING = "#010203"
|
||||
|
||||
const swatchesByKey = new Map<string, CoverSwatches | null>()
|
||||
const pending = new Map<string, Promise<CoverSwatches | null>>()
|
||||
|
||||
function cacheKey(colorSourceUri: string) {
|
||||
return `palette:${colorSourceUri}`
|
||||
}
|
||||
|
||||
function present(colors: (string | undefined)[]) {
|
||||
return colors.filter(
|
||||
(color): color is string => !!color && color.toLowerCase() !== MISSING
|
||||
@@ -44,24 +59,120 @@ function toSwatches(result: ImageColorsResult): CoverSwatches | null {
|
||||
}
|
||||
}
|
||||
|
||||
const legacy = createCoverPaletteSource<CoverSwatches>({
|
||||
cacheKey: (colorSourceUri) => `palette:${colorSourceUri}`,
|
||||
extract: (key) =>
|
||||
getColors(key, {
|
||||
fallback: MISSING,
|
||||
cache: true,
|
||||
key,
|
||||
quality: "low",
|
||||
pixelSpacing: 4,
|
||||
}).then(toSwatches),
|
||||
derive: deriveCoverPalette,
|
||||
function sameSwatches(
|
||||
a: CoverSwatches | null | undefined,
|
||||
b: CoverSwatches | null | undefined
|
||||
) {
|
||||
return a === b || JSON.stringify(a) === JSON.stringify(b)
|
||||
}
|
||||
|
||||
function cachedSwatches(key: string): CoverSwatches | null | undefined {
|
||||
if (swatchesByKey.has(key)) return swatchesByKey.get(key)
|
||||
const cached = readCache<CoverSwatches>(cacheKey(key))
|
||||
// Discard the background-only entries written by the tablet palette experiment.
|
||||
isValidCache: (cached) =>
|
||||
Array.isArray(cached.text) && Array.isArray(cached.accent),
|
||||
})
|
||||
return cached && (!Array.isArray(cached.text) || !Array.isArray(cached.accent))
|
||||
? undefined
|
||||
: cached
|
||||
}
|
||||
|
||||
function extractSwatches(key: string) {
|
||||
const inFlight = pending.get(key)
|
||||
if (inFlight) return inFlight
|
||||
|
||||
const request = getColors(key, {
|
||||
fallback: MISSING,
|
||||
cache: true,
|
||||
key,
|
||||
quality: "low",
|
||||
pixelSpacing: 4,
|
||||
})
|
||||
.then(toSwatches)
|
||||
.catch(() => null)
|
||||
.then((swatches) => {
|
||||
swatchesByKey.set(key, swatches)
|
||||
if (swatches) writeCache(cacheKey(key), swatches)
|
||||
pending.delete(key)
|
||||
return swatches
|
||||
})
|
||||
pending.set(key, request)
|
||||
return request
|
||||
}
|
||||
|
||||
/** Warm visible artwork colors before a detail page is pushed. */
|
||||
export const prefetchLegacyCoverPalette = legacy.prefetch
|
||||
export function prefetchLegacyCoverPalette(uri: string) {
|
||||
const key = withCoverImageSize(uri, 64)
|
||||
if (cachedSwatches(key) !== undefined) return
|
||||
void extractSwatches(key)
|
||||
}
|
||||
|
||||
/** `react-native-image-colors` pipeline used when new artwork colors are off. */
|
||||
export const useLegacyCoverPalette = legacy.usePalette
|
||||
/**
|
||||
* Colors for a screen tinted by `uri`'s cover art. Extraction runs once per
|
||||
* cover and is cached on device. Pass `hasCover` as `undefined` while it isn't
|
||||
* known yet so extraction can start early.
|
||||
*
|
||||
* `settled` turns true once the palette is final or after
|
||||
* `COVER_PALETTE_WAIT_MS`, whichever comes first.
|
||||
*/
|
||||
export function useLegacyCoverPalette(
|
||||
uri: string,
|
||||
hasCover: boolean | undefined
|
||||
): { palette: CoverPalette; settled: boolean } {
|
||||
const theme = useThemeColors()
|
||||
const isDark = useIsDark()
|
||||
const key = uri ? withCoverImageSize(uri, 64) : ""
|
||||
const [resolved, setResolved] = useState(() => ({
|
||||
key,
|
||||
swatches: key ? cachedSwatches(key) : null,
|
||||
}))
|
||||
const [waitedKey, setWaitedKey] = useState<string | null>(null)
|
||||
|
||||
const swatches =
|
||||
resolved.key === key ? resolved.swatches : key ? cachedSwatches(key) : null
|
||||
|
||||
useEffect(() => {
|
||||
if (!key || hasCover === false) return
|
||||
let cancelled = false
|
||||
const known = cachedSwatches(key)
|
||||
const show = (next: CoverSwatches | null) =>
|
||||
setResolved((prev) =>
|
||||
prev.key === key && sameSwatches(prev.swatches, next)
|
||||
? prev
|
||||
: { key, swatches: next }
|
||||
)
|
||||
if (known !== undefined && swatchesByKey.has(key)) {
|
||||
show(known)
|
||||
return
|
||||
}
|
||||
|
||||
// Persisted swatches render immediately; refresh them in the background in
|
||||
// case the cover changed.
|
||||
const timer =
|
||||
known === undefined
|
||||
? setTimeout(
|
||||
() => !cancelled && setWaitedKey(key),
|
||||
COVER_PALETTE_WAIT_MS
|
||||
)
|
||||
: null
|
||||
void extractSwatches(key).then((next) => {
|
||||
if (!cancelled) show(next ?? known ?? null)
|
||||
})
|
||||
return () => {
|
||||
cancelled = true
|
||||
if (timer) clearTimeout(timer)
|
||||
}
|
||||
}, [hasCover, key])
|
||||
|
||||
const palette = useMemo(() => {
|
||||
const fromArt =
|
||||
hasCover !== false && swatches
|
||||
? deriveCoverPalette(swatches, isDark)
|
||||
: null
|
||||
return fromArt ?? themeCoverPalette(theme, isDark)
|
||||
}, [hasCover, isDark, swatches, theme])
|
||||
|
||||
return {
|
||||
palette,
|
||||
settled:
|
||||
!key || hasCover === false || swatches !== undefined || waitedKey === key,
|
||||
}
|
||||
}
|
||||
@@ -1,728 +0,0 @@
|
||||
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,
|
||||
}
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
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 }
|
||||
}
|
||||
@@ -3,8 +3,8 @@ import { useSyncExternalStore } from "react"
|
||||
|
||||
const STORAGE_KEY = "otunes:artwork-colors"
|
||||
const listeners = new Set<() => void>()
|
||||
// Undefined until storage has been read, so callers never act on a guess.
|
||||
let enabled: boolean | undefined
|
||||
let enabled = true
|
||||
let loaded = false
|
||||
let loading: Promise<void> | undefined
|
||||
|
||||
function notify() {
|
||||
@@ -13,40 +13,37 @@ function notify() {
|
||||
|
||||
function load() {
|
||||
return (loading ??= AsyncStorage.getItem(STORAGE_KEY)
|
||||
.then((value) => value !== "false")
|
||||
// Keep the default when local storage is unavailable.
|
||||
.catch(() => true)
|
||||
.then((value) => {
|
||||
enabled = value
|
||||
enabled = value !== "false"
|
||||
})
|
||||
.catch(() => {
|
||||
// Keep the default when local storage is unavailable.
|
||||
})
|
||||
.finally(() => {
|
||||
loaded = true
|
||||
notify()
|
||||
}))
|
||||
}
|
||||
|
||||
void load()
|
||||
|
||||
function subscribe(listener: () => void) {
|
||||
listeners.add(listener)
|
||||
void load()
|
||||
return () => {
|
||||
listeners.delete(listener)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Device preference, kept outside account data and the disposable query cache.
|
||||
* `undefined` until it has loaded.
|
||||
*/
|
||||
/** Device preference, kept outside account data and the disposable query cache. */
|
||||
export function useArtworkColorsEnabled() {
|
||||
return useSyncExternalStore(
|
||||
subscribe,
|
||||
() => enabled,
|
||||
() => undefined
|
||||
)
|
||||
return useSyncExternalStore(subscribe, () => loaded && enabled, () => false)
|
||||
}
|
||||
|
||||
/** Resolves with the preference once it has loaded. */
|
||||
export async function loadArtworkColorsEnabled() {
|
||||
await load()
|
||||
return enabled ?? true
|
||||
export function useArtworkColorPreferenceLoaded() {
|
||||
return useSyncExternalStore(subscribe, () => loaded, () => false)
|
||||
}
|
||||
|
||||
export function artworkColorsEnabled() {
|
||||
return loaded && enabled
|
||||
}
|
||||
|
||||
export async function setArtworkColorsEnabled(value: boolean) {
|
||||
|
||||
@@ -44,7 +44,12 @@ import {
|
||||
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 formatDuration(seconds: number): string {
|
||||
const minutes = Math.floor(seconds / 60)
|
||||
const remainingSeconds = seconds % 60
|
||||
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
|
||||
}
|
||||
|
||||
function formatMetadata(genre: string | null, year: number | null): string | null {
|
||||
const parts: string[] = []
|
||||
|
||||
@@ -955,7 +955,6 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
if (!shouldContinuePlaying) {
|
||||
autoPlayNextRef.current = false
|
||||
isPlayingRef.current = false
|
||||
audio.pause()
|
||||
audio.currentTime = 0
|
||||
currentTimeRef.current = 0
|
||||
setCurrentTime(0)
|
||||
@@ -1198,7 +1197,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
convex,
|
||||
cacheScope,
|
||||
api.library.browseSortedSongIds,
|
||||
sort
|
||||
{ ...sort, fromSongId: songId }
|
||||
)
|
||||
} catch {
|
||||
return
|
||||
|
||||
@@ -31,7 +31,13 @@ import { Slider } from "@/components/ui/slider"
|
||||
import { useSidebar } from "@/components/ui/sidebar"
|
||||
import { albumCoverUrl } from "@/lib/cover-urls"
|
||||
import { cn } from "@/lib/utils"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
|
||||
function formatDuration(seconds: number): string {
|
||||
const total = Math.max(0, Math.floor(seconds))
|
||||
const minutes = Math.floor(total / 60)
|
||||
const remainingSeconds = total % 60
|
||||
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
|
||||
}
|
||||
|
||||
export function PlayerBar() {
|
||||
const {
|
||||
|
||||
@@ -46,10 +46,15 @@ import {
|
||||
TRACK_ROW_PADDING,
|
||||
type SelectionRangePosition,
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
|
||||
const ADD_TO_ANOTHER_PLAYLIST = "Add to Another Playlist"
|
||||
|
||||
function formatDuration(seconds: number): string {
|
||||
const minutes = Math.floor(seconds / 60)
|
||||
const remainingSeconds = seconds % 60
|
||||
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
|
||||
}
|
||||
|
||||
function PlaylistSongCover({
|
||||
song,
|
||||
inRange,
|
||||
|
||||
@@ -28,7 +28,6 @@ import {
|
||||
} from "@/lib/selection-range-styles"
|
||||
import { useSongs } from "@/lib/song-cache"
|
||||
import { cn } from "@/lib/utils"
|
||||
import { formatDuration } from "@/lib/format-duration"
|
||||
|
||||
const QUEUE_INITIAL_VISIBLE_COUNT = 100
|
||||
const QUEUE_PAGE_SIZE = 50
|
||||
@@ -41,6 +40,12 @@ type QueueItem = {
|
||||
song: QueueSelectable | null
|
||||
}
|
||||
|
||||
function formatDuration(seconds: number): string {
|
||||
const minutes = Math.floor(seconds / 60)
|
||||
const remainingSeconds = seconds % 60
|
||||
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
|
||||
}
|
||||
|
||||
function toSelectableQueue(
|
||||
songIds: Id<"songs">[],
|
||||
songs: (BrowseSong | undefined)[]
|
||||
|
||||
@@ -52,7 +52,6 @@ import {
|
||||
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"
|
||||
@@ -65,6 +64,12 @@ const nameColumnLayout =
|
||||
"grid grid-cols-[2rem_2.5rem_minmax(0,10rem)] items-center gap-x-2"
|
||||
const songColumnClass = "w-36 shrink-0 truncate"
|
||||
|
||||
function formatDuration(seconds: number): string {
|
||||
const minutes = Math.floor(seconds / 60)
|
||||
const remainingSeconds = seconds % 60
|
||||
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
|
||||
}
|
||||
|
||||
function SongCover({
|
||||
song,
|
||||
inRange,
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
import { exportJWK, exportPKCS8, generateKeyPair } from "jose";
|
||||
|
||||
const keys = await generateKeyPair("RS256", {
|
||||
extractable: true,
|
||||
});
|
||||
const privateKey = await exportPKCS8(keys.privateKey);
|
||||
const publicKey = await exportJWK(keys.publicKey);
|
||||
const jwks = JSON.stringify({ keys: [{ use: "sig", ...publicKey }] });
|
||||
|
||||
process.stdout.write(
|
||||
`JWT_PRIVATE_KEY="${privateKey.trimEnd().replace(/\n/g, " ")}"`,
|
||||
);
|
||||
process.stdout.write("\n");
|
||||
process.stdout.write(`JWKS=${jwks}`);
|
||||
process.stdout.write("\n");
|
||||
@@ -1,3 +1,9 @@
|
||||
/** Shared layout for album grids. */
|
||||
/** Shared layout for album grids and carousel slides (gap-x-6 = 1.5rem). */
|
||||
export const albumGridClassName =
|
||||
"grid grid-cols-2 gap-x-6 gap-y-8 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6"
|
||||
|
||||
/** Slide width matches one cell of `albumGridClassName` inside an `@container` ancestor. */
|
||||
export const albumGridCarouselSlideClassName =
|
||||
"w-[calc((100cqw-1.5rem)/2)] shrink-0 grow-0 basis-auto pl-6 sm:w-[calc((100cqw-3rem)/3)] md:w-[calc((100cqw-4.5rem)/4)] lg:w-[calc((100cqw-6rem)/5)] xl:w-[calc((100cqw-7.5rem)/6)]"
|
||||
|
||||
export const albumGridCarouselContentClassName = "-ml-6"
|
||||
@@ -0,0 +1,19 @@
|
||||
import type {
|
||||
BrowseAlbum,
|
||||
BrowseAlbumDetail,
|
||||
BrowseAlbumTrack,
|
||||
BrowseArtist,
|
||||
BrowsePlaylistDetail,
|
||||
BrowsePlaylistOwner,
|
||||
BrowseSong,
|
||||
PlaylistSummary,
|
||||
} from "@otunes/convex/types"
|
||||
|
||||
export type Artist = BrowseArtist
|
||||
export type Album = BrowseAlbum
|
||||
export type Song = BrowseSong
|
||||
export type Playlist = PlaylistSummary
|
||||
export type PlaylistOwner = BrowsePlaylistOwner
|
||||
export type PlaylistDetail = BrowsePlaylistDetail
|
||||
export type AlbumTrack = BrowseAlbumTrack
|
||||
export type AlbumDetail = BrowseAlbumDetail
|
||||
@@ -1,7 +0,0 @@
|
||||
/** Formats seconds as `m:ss`, flooring fractional and negative input. */
|
||||
export function formatDuration(seconds: number): string {
|
||||
const total = Math.max(0, Math.floor(seconds))
|
||||
const minutes = Math.floor(total / 60)
|
||||
const remainingSeconds = total % 60
|
||||
return `${minutes}:${remainingSeconds.toString().padStart(2, "0")}`
|
||||
}
|
||||
@@ -13,15 +13,15 @@ function mediaOrigin() {
|
||||
return window.location.origin
|
||||
}
|
||||
|
||||
function albumShareUrl(albumId: string) {
|
||||
export function albumShareUrl(albumId: string) {
|
||||
return `${mediaOrigin()}/album/${albumId}`
|
||||
}
|
||||
|
||||
function songShareUrl(albumId: string, songId: string) {
|
||||
export function songShareUrl(albumId: string, songId: string) {
|
||||
return `${mediaOrigin()}/album/${albumId}?s=${songId}`
|
||||
}
|
||||
|
||||
function playlistShareUrl(
|
||||
export function playlistShareUrl(
|
||||
playlistId: string,
|
||||
options?: { isFavorites?: boolean }
|
||||
) {
|
||||
@@ -31,11 +31,11 @@ function playlistShareUrl(
|
||||
return `${mediaOrigin()}/playlist/${playlistId}`
|
||||
}
|
||||
|
||||
function artistShareUrl(artistId: string) {
|
||||
export function artistShareUrl(artistId: string) {
|
||||
return `${mediaOrigin()}/artist/${artistId}`
|
||||
}
|
||||
|
||||
function mediaShareUrl(share: MediaShareContext) {
|
||||
export function mediaShareUrl(share: MediaShareContext) {
|
||||
switch (share.type) {
|
||||
case "album":
|
||||
return albumShareUrl(share.albumId)
|
||||
@@ -50,7 +50,7 @@ function mediaShareUrl(share: MediaShareContext) {
|
||||
}
|
||||
}
|
||||
|
||||
async function copyTextToClipboard(text: string) {
|
||||
export async function copyTextToClipboard(text: string) {
|
||||
await navigator.clipboard.writeText(text)
|
||||
toast.success("Link Copied")
|
||||
}
|
||||
@@ -63,6 +63,10 @@ export async function copyAlbumLink(albumId: string) {
|
||||
await copyMediaShareLink({ type: "album", albumId })
|
||||
}
|
||||
|
||||
export async function copySongLink(albumId: string, songId: string) {
|
||||
await copyMediaShareLink({ type: "song", albumId, songId })
|
||||
}
|
||||
|
||||
export async function copyPlaylistLink(
|
||||
playlistId: string,
|
||||
options?: { isFavorites?: boolean }
|
||||
@@ -73,3 +77,7 @@ export async function copyPlaylistLink(
|
||||
isFavorites: options?.isFavorites,
|
||||
})
|
||||
}
|
||||
|
||||
export async function copyArtistLink(artistId: string) {
|
||||
await copyMediaShareLink({ type: "artist", artistId })
|
||||
}
|
||||
@@ -46,7 +46,7 @@ export function getSelectionRangePositions(
|
||||
return positions
|
||||
}
|
||||
|
||||
function selectionHighlightRadiusClass(
|
||||
export function selectionHighlightRadiusClass(
|
||||
position: SelectionRangePosition
|
||||
) {
|
||||
switch (position) {
|
||||
@@ -61,7 +61,7 @@ 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"
|
||||
|
||||
export function SelectionRangeHighlight({
|
||||
position,
|
||||
@@ -117,7 +117,7 @@ export const TRACK_ROW_PADDING = "pl-8 pr-10"
|
||||
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 const SONGS_ROW_HIGHLIGHT_INSET = "absolute inset-0"
|
||||
|
||||
export function SongsSelectionRangeHighlight({
|
||||
position,
|
||||
@@ -162,7 +162,7 @@ export function isInSelectionRange(position: SelectionRangePosition) {
|
||||
}
|
||||
|
||||
/** Full-width, square-corner highlights for the queue sidebar. */
|
||||
const QUEUE_ROW_HIGHLIGHT_INSET = "absolute inset-0"
|
||||
export const QUEUE_ROW_HIGHLIGHT_INSET = "absolute inset-0"
|
||||
|
||||
export function QueueSelectionRangeHighlight({
|
||||
position,
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
import assert from "node:assert/strict"
|
||||
import test from "node:test"
|
||||
|
||||
import { stationArtistId } from "./station-artist.ts"
|
||||
|
||||
const songs = [
|
||||
{ id: "song-a", artist: { id: "artist-a" } },
|
||||
{ id: "song-b", artist: { id: "artist-a" } },
|
||||
{ id: "song-c", artist: { id: "artist-b" } },
|
||||
]
|
||||
|
||||
test("a single song or a selection sharing one artist can create a station", () => {
|
||||
assert.equal(stationArtistId(songs, new Set(["song-c"])), "artist-b")
|
||||
assert.equal(
|
||||
stationArtistId(songs, new Set(["song-a", "song-b"])),
|
||||
"artist-a"
|
||||
)
|
||||
})
|
||||
|
||||
test("mixed artists cannot create a station", () => {
|
||||
assert.equal(stationArtistId(songs, new Set(["song-a", "song-c"])), undefined)
|
||||
})
|
||||
|
||||
test("empty or partially missing selections cannot create a station", () => {
|
||||
assert.equal(stationArtistId(songs, new Set()), undefined)
|
||||
assert.equal(
|
||||
stationArtistId(songs, new Set(["song-a", "missing"])),
|
||||
undefined
|
||||
)
|
||||
})
|
||||
+6
-27
@@ -46,34 +46,22 @@ stop() {
|
||||
}
|
||||
trap 'stop; exit 0' TERM INT
|
||||
|
||||
as_convex=(setpriv --reuid=convex --regid=convex --init-groups env HOME=/home/convex)
|
||||
|
||||
convex_cli() {
|
||||
(
|
||||
cd "$FUNCTIONS_DIR"
|
||||
unset CONVEX_DEPLOYMENT CONVEX_DEPLOY_KEY
|
||||
CONVEX_SELF_HOSTED_URL="$BACKEND_URL" \
|
||||
CONVEX_SELF_HOSTED_ADMIN_KEY="$admin_key" \
|
||||
"${as_convex[@]}" "$NODE" node_modules/convex/bin/main.js "$@"
|
||||
"$NODE" node_modules/convex/bin/main.js "$@"
|
||||
)
|
||||
}
|
||||
|
||||
# Only the convex user may read the database and instance secret. Volumes from
|
||||
# images that ran the backend as root are still owned by root, and
|
||||
# read_credentials.sh generates a new instance secret if it cannot read the old one.
|
||||
# Only root (the backend) may read the database and instance secret.
|
||||
mkdir -p "$CONVEX_DATA_DIR"
|
||||
find "$CONVEX_DATA_DIR" \( ! -user convex -o ! -group convex \) \
|
||||
-exec chown -h convex:convex {} +
|
||||
chmod 700 "$CONVEX_DATA_DIR"
|
||||
|
||||
# The web server writes HLS streams here and a Convex cron deletes stale ones.
|
||||
mkdir -p /tmp/otunes
|
||||
chown otunes:otunes /tmp/otunes
|
||||
chmod -R g+rwX /tmp/otunes
|
||||
chmod g+s,o-rwx /tmp/otunes
|
||||
|
||||
log "Starting Convex backend"
|
||||
(cd /convex && umask 077 && exec "${as_convex[@]}" ./run_backend.sh) &
|
||||
(cd /convex && umask 077 && exec ./run_backend.sh) &
|
||||
backend_pid=$!
|
||||
|
||||
for _ in $(seq 1 120); do
|
||||
@@ -92,24 +80,17 @@ if ! curl -fsS "$BACKEND_URL/version" >/dev/null 2>&1; then
|
||||
exit 1
|
||||
fi
|
||||
|
||||
admin_key=$(cd /convex && umask 077 && "${as_convex[@]}" ./generate_admin_key.sh)
|
||||
admin_key=$(cd /convex && ./generate_admin_key.sh)
|
||||
|
||||
log "Deploying Convex functions"
|
||||
convex_cli deploy --typecheck disable --codegen disable
|
||||
|
||||
# `env get` exits 0 with no output when the variable is unset. Any other failure
|
||||
# must not be read as "no keys": regenerating them signs every user out.
|
||||
if ! jwks=$(convex_cli env get JWKS); then
|
||||
log "Could not read Convex Auth signing keys"
|
||||
stop
|
||||
exit 1
|
||||
fi
|
||||
if [ -z "$jwks" ]; then
|
||||
if [ -z "$(convex_cli env get JWKS 2>/dev/null || true)" ]; then
|
||||
log "Generating Convex Auth signing keys"
|
||||
"$NODE" /opt/otunes/generate-auth-keys.mjs | convex_cli env set --force
|
||||
fi
|
||||
|
||||
unset admin_key jwks
|
||||
unset admin_key
|
||||
|
||||
log "Starting web server"
|
||||
(
|
||||
@@ -119,8 +100,6 @@ log "Starting web server"
|
||||
# Server-side Convex helpers fall back to this at runtime. The browser bundle
|
||||
# is built without it, so browsers still derive their own URL.
|
||||
export NEXT_PUBLIC_CONVEX_URL="$BACKEND_URL"
|
||||
# Lets the convex group member delete stale HLS streams.
|
||||
umask 0002
|
||||
exec setpriv --reuid=otunes --regid=otunes --init-groups \
|
||||
"$NODE" apps/web/server.js
|
||||
) &
|
||||
|
||||
+461
-466
@@ -61,512 +61,494 @@ async function cleanHlsStreamsOlderThan(maxIdleMs: number) {
|
||||
return { checked, removed, failed }
|
||||
}
|
||||
|
||||
async function coverPathIfExists(path: string): Promise<string | null> {
|
||||
return fs
|
||||
.access(path)
|
||||
.then(() => path)
|
||||
.catch(() => null)
|
||||
}
|
||||
const SCAN_PAGE_SIZE = 2000
|
||||
/** Outlives the 10 minute action timeout so a crashed scan frees the lock. */
|
||||
const SCAN_LOCK_LEASE_MS = 15 * 60 * 1000
|
||||
/** New files left unparsed after this are picked up by the next scan. */
|
||||
const SCAN_PARSE_BUDGET_MS = 6 * 60 * 1000
|
||||
const SCAN_BATCH_SIZE = 200
|
||||
const FS_CONCURRENCY = 16
|
||||
|
||||
async function syncArtistCover(
|
||||
ctx: ActionCtx,
|
||||
codec: string,
|
||||
dbCover: string | null,
|
||||
diskPath: string,
|
||||
id: Id<"artists">
|
||||
) {
|
||||
const onDisk = await coverPathIfExists(diskPath)
|
||||
if (onDisk !== null) {
|
||||
if (dbCover !== onDisk) {
|
||||
await ctx.runMutation(internal.library.updateArtistCover, {
|
||||
id,
|
||||
cover: onDisk,
|
||||
})
|
||||
type Page<T> = { page: T[]; isDone: boolean; continueCursor: string }
|
||||
|
||||
/** Reads every page of an internal paginated query. */
|
||||
async function collectPages<T>(
|
||||
load: (cursor: string | null) => Promise<Page<T>>
|
||||
): Promise<T[]> {
|
||||
const items: T[] = []
|
||||
let cursor: string | null = null
|
||||
for (;;) {
|
||||
const result = await load(cursor)
|
||||
items.push(...result.page)
|
||||
if (result.isDone) {
|
||||
return items
|
||||
}
|
||||
} else if (dbCover !== null && dbCover.includes(codec)) {
|
||||
await ctx.runMutation(internal.library.updateArtistCover, {
|
||||
id,
|
||||
cover: null,
|
||||
})
|
||||
cursor = result.continueCursor
|
||||
}
|
||||
}
|
||||
|
||||
async function syncAlbumCover(
|
||||
ctx: ActionCtx,
|
||||
codec: string,
|
||||
dbCover: string | null,
|
||||
diskPath: string,
|
||||
id: Id<"albums">
|
||||
) {
|
||||
const onDisk = await coverPathIfExists(diskPath)
|
||||
if (onDisk !== null) {
|
||||
if (dbCover !== onDisk) {
|
||||
await ctx.runMutation(internal.library.updateAlbumCover, {
|
||||
id,
|
||||
cover: onDisk,
|
||||
})
|
||||
/** Like `Promise.all(items.map(fn))` with at most `limit` calls in flight. */
|
||||
async function mapLimit<T, R>(
|
||||
items: T[],
|
||||
limit: number,
|
||||
fn: (item: T) => Promise<R>
|
||||
): Promise<R[]> {
|
||||
const results = new Array<R>(items.length)
|
||||
let next = 0
|
||||
const worker = async () => {
|
||||
while (next < items.length) {
|
||||
const index = next++
|
||||
results[index] = await fn(items[index])
|
||||
}
|
||||
} else if (dbCover !== null && dbCover.includes(codec)) {
|
||||
await ctx.runMutation(internal.library.updateAlbumCover, {
|
||||
id,
|
||||
cover: null,
|
||||
})
|
||||
}
|
||||
await Promise.all(
|
||||
Array.from({ length: Math.min(limit, items.length) }, worker)
|
||||
)
|
||||
return results
|
||||
}
|
||||
|
||||
function chunk<T>(items: T[], size: number): T[][] {
|
||||
const chunks: T[][] = []
|
||||
for (let i = 0; i < items.length; i += size) {
|
||||
chunks.push(items.slice(i, i + size))
|
||||
}
|
||||
return chunks
|
||||
}
|
||||
|
||||
async function readDirents(dir: string): Promise<fsSync.Dirent[]> {
|
||||
try {
|
||||
return await fs.readdir(dir, { withFileTypes: true })
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code === "ENOENT") {
|
||||
return []
|
||||
}
|
||||
throw error
|
||||
}
|
||||
}
|
||||
|
||||
async function purgeRemovedSongs(ctx: ActionCtx, ids: Id<"songs">[]) {
|
||||
if (ids.length === 0) {
|
||||
return
|
||||
}
|
||||
await ctx.runMutation(internal.library.purgeSongsFromUsersAndPlaylists, {
|
||||
ids,
|
||||
type DiskAlbum = {
|
||||
codec: string
|
||||
artistFolder: string
|
||||
albumFolder: string
|
||||
files: string[]
|
||||
}
|
||||
|
||||
type DiskLibrary = {
|
||||
/** Every audio file path. */
|
||||
files: Set<string>
|
||||
/** Every `folder.jpg` / `cover.jpg` path. */
|
||||
covers: Set<string>
|
||||
albums: DiskAlbum[]
|
||||
}
|
||||
|
||||
/** Lists `DATA_DIR/<codec>/<artist>/<album>/<file>` with one readdir per directory. */
|
||||
async function walkLibrary(codecs: string[]): Promise<DiskLibrary> {
|
||||
const files = new Set<string>()
|
||||
const covers = new Set<string>()
|
||||
|
||||
const artistDirs = (
|
||||
await Promise.all(
|
||||
codecs.map(async (codec) =>
|
||||
(await readDirents(`${DATA_DIR}/${codec}`))
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => ({ codec, artistFolder: dirent.name }))
|
||||
)
|
||||
)
|
||||
).flat()
|
||||
|
||||
const albumDirs = (
|
||||
await mapLimit(
|
||||
artistDirs,
|
||||
FS_CONCURRENCY,
|
||||
async ({ codec, artistFolder }) => {
|
||||
const artistPath = `${DATA_DIR}/${codec}/${artistFolder}`
|
||||
const dirents = await readDirents(artistPath)
|
||||
if (dirents.some((d) => !d.isDirectory() && d.name === "folder.jpg")) {
|
||||
covers.add(`${artistPath}/folder.jpg`)
|
||||
}
|
||||
return dirents
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => ({ codec, artistFolder, albumFolder: dirent.name }))
|
||||
}
|
||||
)
|
||||
).flat()
|
||||
|
||||
const albums = await mapLimit(albumDirs, FS_CONCURRENCY, async (album) => {
|
||||
const albumPath = `${DATA_DIR}/${album.codec}/${album.artistFolder}/${album.albumFolder}`
|
||||
const albumFiles: string[] = []
|
||||
for (const dirent of await readDirents(albumPath)) {
|
||||
if (dirent.isDirectory()) {
|
||||
continue
|
||||
}
|
||||
const filePath = `${albumPath}/${dirent.name}`
|
||||
if (dirent.name === "cover.jpg") {
|
||||
covers.add(filePath)
|
||||
} else {
|
||||
files.add(filePath)
|
||||
albumFiles.push(filePath)
|
||||
}
|
||||
}
|
||||
return { ...album, files: albumFiles }
|
||||
})
|
||||
|
||||
return { files, covers, albums }
|
||||
}
|
||||
|
||||
async function purgeRemovedAlbums(ctx: ActionCtx, ids: Id<"albums">[]) {
|
||||
if (ids.length === 0) {
|
||||
return
|
||||
/**
|
||||
* Keeps the current cover while its file exists, otherwise the first codec's
|
||||
* cover on disk. Covers outside the data directory are left alone.
|
||||
*/
|
||||
function pickCover(
|
||||
current: string | null,
|
||||
candidates: string[],
|
||||
covers: Set<string>
|
||||
): string | null {
|
||||
if (
|
||||
current !== null &&
|
||||
(covers.has(current) || !current.startsWith(`${DATA_DIR}/`))
|
||||
) {
|
||||
return current
|
||||
}
|
||||
await ctx.runMutation(internal.library.purgeAlbumsFromUsers, { ids })
|
||||
return candidates.find((candidate) => covers.has(candidate)) ?? null
|
||||
}
|
||||
|
||||
async function purgeRemovedArtists(ctx: ActionCtx, ids: Id<"artists">[]) {
|
||||
if (ids.length === 0) {
|
||||
return
|
||||
/** Untagged years are stored as 0 / "", which both clients treat as unknown. */
|
||||
function releaseDate(common: music.ICommonTagsResult) {
|
||||
if (common.date) {
|
||||
return common.date
|
||||
}
|
||||
await ctx.runMutation(internal.library.purgeArtistsFromUsers, { ids })
|
||||
return common.year ? `01-01-${common.year}` : ""
|
||||
}
|
||||
|
||||
async function removeCodecFromDatabase(ctx: ActionCtx, codec: string) {
|
||||
const allSongs = await ctx.runQuery(internal.library.getSongs)
|
||||
type NewSong = {
|
||||
name: string
|
||||
files: Record<string, string>
|
||||
artist: string | string[]
|
||||
length: number
|
||||
diskNumber: number | null
|
||||
track: number
|
||||
year: number
|
||||
date: string
|
||||
genres: string[]
|
||||
}
|
||||
|
||||
const songsToRemove: Id<"songs">[] = []
|
||||
const songsToUpdate: { id: Id<"songs">; files: Record<string, string> }[] = []
|
||||
for (const song of allSongs) {
|
||||
if (!(codec in song.files)) {
|
||||
type ImportEntry = {
|
||||
artist: { name: string; folder: string; cover: string | null }
|
||||
album: {
|
||||
name: string
|
||||
folder: string
|
||||
cover: string | null
|
||||
year: number
|
||||
date: string
|
||||
}
|
||||
songs: Map<string, NewSong>
|
||||
}
|
||||
|
||||
/**
|
||||
* Reconciles the database with the files on disk. Reads the library once in
|
||||
* pages, walks the disk once, parses only untracked files and writes only
|
||||
* what changed, so re-scanning an unchanged library makes no writes.
|
||||
*/
|
||||
async function scanLibrary(ctx: ActionCtx) {
|
||||
const startedAt = Date.now()
|
||||
const codecs = (await fs.readdir(DATA_DIR, { withFileTypes: true }))
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => dirent.name)
|
||||
|
||||
const [artists, albums, songs, disk] = await Promise.all([
|
||||
collectPages((cursor) =>
|
||||
ctx.runQuery(internal.library.scanArtistsPage, {
|
||||
paginationOpts: { numItems: SCAN_PAGE_SIZE, cursor },
|
||||
})
|
||||
),
|
||||
collectPages((cursor) =>
|
||||
ctx.runQuery(internal.library.scanAlbumsPage, {
|
||||
paginationOpts: { numItems: SCAN_PAGE_SIZE, cursor },
|
||||
})
|
||||
),
|
||||
collectPages((cursor) =>
|
||||
ctx.runQuery(internal.library.scanSongsPage, {
|
||||
paginationOpts: { numItems: SCAN_PAGE_SIZE, cursor },
|
||||
})
|
||||
),
|
||||
walkLibrary(codecs),
|
||||
])
|
||||
|
||||
if (disk.files.size === 0 && songs.length > 0) {
|
||||
throw new Error(
|
||||
`No audio files found under ${DATA_DIR}; refusing to empty the library`
|
||||
)
|
||||
}
|
||||
|
||||
// Drop file paths that are gone from disk (including removed codecs). Songs
|
||||
// left without files are deleted below unless a new file matches them.
|
||||
const songFiles = new Map<Id<"songs">, Record<string, string>>()
|
||||
const changedSongs = new Set<Id<"songs">>()
|
||||
const songsByAlbum = new Map<Id<"albums">, Map<string, Id<"songs">>>()
|
||||
const tracked = new Set<string>()
|
||||
for (const song of songs) {
|
||||
const entries = Object.entries(song.files)
|
||||
const kept = entries.filter(([, filePath]) => disk.files.has(filePath))
|
||||
if (kept.length !== entries.length) {
|
||||
changedSongs.add(song._id)
|
||||
}
|
||||
songFiles.set(song._id, Object.fromEntries(kept))
|
||||
for (const [, filePath] of kept) {
|
||||
tracked.add(filePath)
|
||||
}
|
||||
const byName = songsByAlbum.get(song.album) ?? new Map()
|
||||
if (!byName.has(song.name)) {
|
||||
byName.set(song.name, song._id)
|
||||
}
|
||||
songsByAlbum.set(song.album, byName)
|
||||
}
|
||||
|
||||
// Parse untracked files only.
|
||||
const untracked = disk.albums.flatMap((album) =>
|
||||
album.files
|
||||
.filter((filePath) => !tracked.has(filePath))
|
||||
.map((filePath) => ({ ...album, filePath }))
|
||||
)
|
||||
const deadline = startedAt + SCAN_PARSE_BUDGET_MS
|
||||
const parsed = await mapLimit(untracked, FS_CONCURRENCY, async (file) => {
|
||||
if (Date.now() > deadline) {
|
||||
return null
|
||||
}
|
||||
try {
|
||||
const metadata = await music.parseFile(file.filePath, {
|
||||
skipCovers: true,
|
||||
})
|
||||
return { ...file, metadata }
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
})
|
||||
const skipped = parsed.filter((file) => file === null).length
|
||||
|
||||
const artistByFolder = new Map(
|
||||
artists.map((artist) => [artist.folder, artist])
|
||||
)
|
||||
const albumByKey = new Map(
|
||||
albums.map((album) => [`${album.artist}/${album.folder}`, album])
|
||||
)
|
||||
const imports = new Map<string, ImportEntry>()
|
||||
for (const file of parsed) {
|
||||
if (file === null) {
|
||||
continue
|
||||
}
|
||||
const { codec, artistFolder, albumFolder, filePath, metadata } = file
|
||||
const common = metadata.common
|
||||
const title = common.title || path.parse(filePath).name
|
||||
|
||||
const dbArtist = artistByFolder.get(artistFolder)
|
||||
const dbAlbum = dbArtist
|
||||
? albumByKey.get(`${dbArtist._id}/${albumFolder}`)
|
||||
: undefined
|
||||
const existingId = dbAlbum && songsByAlbum.get(dbAlbum._id)?.get(title)
|
||||
if (existingId) {
|
||||
// A same-titled sibling must not steal a path that still exists.
|
||||
const files = songFiles.get(existingId)!
|
||||
if (!(codec in files)) {
|
||||
songFiles.set(existingId, { ...files, [codec]: filePath })
|
||||
changedSongs.add(existingId)
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
const { [codec]: _, ...update } = song.files
|
||||
if (Object.keys(update).length === 0) {
|
||||
songsToRemove.push(song._id)
|
||||
} else {
|
||||
songsToUpdate.push({
|
||||
id: song._id,
|
||||
files: update,
|
||||
})
|
||||
const key = `${artistFolder}/${albumFolder}`
|
||||
let entry = imports.get(key)
|
||||
if (!entry) {
|
||||
entry = {
|
||||
artist: {
|
||||
name: common.albumartist || artistFolder,
|
||||
folder: artistFolder,
|
||||
cover: pickCover(
|
||||
null,
|
||||
codecs.map((c) => `${DATA_DIR}/${c}/${artistFolder}/folder.jpg`),
|
||||
disk.covers
|
||||
),
|
||||
},
|
||||
album: {
|
||||
name: common.album || albumFolder,
|
||||
folder: albumFolder,
|
||||
cover: pickCover(
|
||||
null,
|
||||
codecs.map(
|
||||
(c) => `${DATA_DIR}/${c}/${artistFolder}/${albumFolder}/cover.jpg`
|
||||
),
|
||||
disk.covers
|
||||
),
|
||||
year: common.year || 0,
|
||||
date: releaseDate(common),
|
||||
},
|
||||
songs: new Map(),
|
||||
}
|
||||
imports.set(key, entry)
|
||||
}
|
||||
|
||||
const pending = entry.songs.get(title)
|
||||
if (pending) {
|
||||
pending.files[codec] ??= filePath
|
||||
continue
|
||||
}
|
||||
entry.songs.set(title, {
|
||||
name: title,
|
||||
files: { [codec]: filePath },
|
||||
artist:
|
||||
common.artist ?? common.artists ?? dbArtist?.name ?? entry.artist.name,
|
||||
length: Math.round(metadata.format.duration || 0),
|
||||
diskNumber: common.disk.of === 1 ? null : common.disk.no,
|
||||
track: common.track.no || 0,
|
||||
year: common.year || 0,
|
||||
date: releaseDate(common),
|
||||
genres: common.genre || [],
|
||||
})
|
||||
}
|
||||
|
||||
await ctx.runMutation(internal.library.changeFilesForSongs, {
|
||||
songs: songsToUpdate,
|
||||
})
|
||||
await purgeRemovedSongs(ctx, songsToRemove)
|
||||
await ctx.runMutation(internal.library.removeSongs, { ids: songsToRemove })
|
||||
|
||||
const allAlbums = await ctx.runQuery(internal.library.getAlbums)
|
||||
const removedSongIds = new Set(songsToRemove)
|
||||
const albumsWithSongs = new Set(
|
||||
allSongs.flatMap((song) =>
|
||||
removedSongIds.has(song._id) ? [] : [song.album]
|
||||
)
|
||||
const deletedSongs = songs.flatMap((song) =>
|
||||
Object.keys(songFiles.get(song._id)!).length === 0 ? [song._id] : []
|
||||
)
|
||||
const albumsToRemove = allAlbums
|
||||
const deletedSongSet = new Set(deletedSongs)
|
||||
const updatedSongs = [...changedSongs].filter((id) => !deletedSongSet.has(id))
|
||||
|
||||
const albumsWithSongs = new Set(
|
||||
songs.flatMap((song) => (deletedSongSet.has(song._id) ? [] : [song.album]))
|
||||
)
|
||||
const emptyAlbums = albums
|
||||
.filter((album) => !albumsWithSongs.has(album._id))
|
||||
.map((album) => album._id)
|
||||
await purgeRemovedAlbums(ctx, albumsToRemove)
|
||||
await ctx.runMutation(internal.library.removeAlbums, { ids: albumsToRemove })
|
||||
|
||||
const allArtists = await ctx.runQuery(internal.library.getArtists)
|
||||
const removedAlbumIds = new Set(albumsToRemove)
|
||||
const emptyAlbumSet = new Set(emptyAlbums)
|
||||
const artistsWithAlbums = new Set(
|
||||
allAlbums.flatMap((album) =>
|
||||
removedAlbumIds.has(album._id) ? [] : [album.artist]
|
||||
albums.flatMap((album) =>
|
||||
emptyAlbumSet.has(album._id) ? [] : [album.artist]
|
||||
)
|
||||
)
|
||||
const artistsToRemove = allArtists
|
||||
const emptyArtists = artists
|
||||
.filter((artist) => !artistsWithAlbums.has(artist._id))
|
||||
.map((artist) => artist._id)
|
||||
await purgeRemovedArtists(ctx, artistsToRemove)
|
||||
await ctx.runMutation(internal.library.removeArtists, {
|
||||
ids: artistsToRemove,
|
||||
const emptyArtistSet = new Set(emptyArtists)
|
||||
|
||||
// Albums and artists about to be deleted keep their cover.
|
||||
const artistById = new Map(artists.map((artist) => [artist._id, artist]))
|
||||
const artistCovers = artists.flatMap((artist) => {
|
||||
if (emptyArtistSet.has(artist._id)) {
|
||||
return []
|
||||
}
|
||||
const cover = pickCover(
|
||||
artist.cover,
|
||||
codecs.map((c) => `${DATA_DIR}/${c}/${artist.folder}/folder.jpg`),
|
||||
disk.covers
|
||||
)
|
||||
return cover === artist.cover ? [] : [{ id: artist._id, cover }]
|
||||
})
|
||||
const albumCovers = albums.flatMap((album) => {
|
||||
const artist = artistById.get(album.artist)
|
||||
if (!artist || emptyAlbumSet.has(album._id)) {
|
||||
return []
|
||||
}
|
||||
const cover = pickCover(
|
||||
album.cover,
|
||||
codecs.map(
|
||||
(c) => `${DATA_DIR}/${c}/${artist.folder}/${album.folder}/cover.jpg`
|
||||
),
|
||||
disk.covers
|
||||
)
|
||||
return cover === album.cover ? [] : [{ id: album._id, cover }]
|
||||
})
|
||||
|
||||
// Writes. Imports run before the empty-album/artist sweeps, and those
|
||||
// mutations re-check emptiness, so nothing that gained songs is deleted.
|
||||
for (const batch of chunk(updatedSongs, SCAN_BATCH_SIZE)) {
|
||||
await ctx.runMutation(internal.library.changeFilesForSongs, {
|
||||
songs: batch.map((id) => ({ id, files: songFiles.get(id)! })),
|
||||
})
|
||||
}
|
||||
for (const batch of chunk(deletedSongs, SCAN_BATCH_SIZE)) {
|
||||
await ctx.runMutation(internal.library.deleteSongs, { ids: batch })
|
||||
}
|
||||
|
||||
let importBatch: ImportEntry[] = []
|
||||
let importBatchSongs = 0
|
||||
const flushImports = async () => {
|
||||
if (importBatch.length === 0) {
|
||||
return
|
||||
}
|
||||
await ctx.runMutation(internal.library.importAlbums, {
|
||||
albums: importBatch.map((entry) => ({
|
||||
...entry,
|
||||
songs: [...entry.songs.values()],
|
||||
})),
|
||||
})
|
||||
importBatch = []
|
||||
importBatchSongs = 0
|
||||
}
|
||||
for (const entry of imports.values()) {
|
||||
importBatch.push(entry)
|
||||
importBatchSongs += entry.songs.size
|
||||
if (importBatchSongs >= SCAN_BATCH_SIZE) {
|
||||
await flushImports()
|
||||
}
|
||||
}
|
||||
await flushImports()
|
||||
|
||||
for (const batch of chunk(artistCovers, SCAN_BATCH_SIZE)) {
|
||||
await ctx.runMutation(internal.library.updateArtistCovers, {
|
||||
artists: batch,
|
||||
})
|
||||
}
|
||||
for (const batch of chunk(albumCovers, SCAN_BATCH_SIZE)) {
|
||||
await ctx.runMutation(internal.library.updateAlbumCovers, {
|
||||
albums: batch,
|
||||
})
|
||||
}
|
||||
|
||||
let removedAlbums = 0
|
||||
for (const batch of chunk(emptyAlbums, SCAN_BATCH_SIZE)) {
|
||||
removedAlbums += await ctx.runMutation(internal.library.deleteEmptyAlbums, {
|
||||
ids: batch,
|
||||
})
|
||||
}
|
||||
|
||||
let removedArtists = 0
|
||||
for (const batch of chunk(emptyArtists, SCAN_BATCH_SIZE)) {
|
||||
removedArtists += await ctx.runMutation(
|
||||
internal.library.deleteEmptyArtists,
|
||||
{ ids: batch }
|
||||
)
|
||||
}
|
||||
|
||||
const importedSongs = [...imports.values()].reduce(
|
||||
(total, entry) => total + entry.songs.size,
|
||||
0
|
||||
)
|
||||
const summary =
|
||||
`songs: ${importedSongs} added, ${updatedSongs.length} updated, ` +
|
||||
`${deletedSongs.length} removed; albums removed: ${removedAlbums}; ` +
|
||||
`artists removed: ${removedArtists}; covers updated: ` +
|
||||
`${artistCovers.length + albumCovers.length}; ` +
|
||||
`files deferred: ${skipped}; ${Date.now() - startedAt}ms`
|
||||
console.log(`library scan: ${summary}`)
|
||||
return summary
|
||||
}
|
||||
|
||||
/** Runs one scan under the library scan lock; `null` if one is already running. */
|
||||
export const scheduledUpdateLibrary = internalAction({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const codecs = (await fs.readdir(DATA_DIR, { withFileTypes: true }))
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => dirent.name)
|
||||
|
||||
const dbCodecs = Array.from(
|
||||
new Map(
|
||||
(await ctx.runQuery(internal.library.getSongs))
|
||||
.map((song) => {
|
||||
return Object.keys(song.files)
|
||||
})
|
||||
.flat()
|
||||
.map((codec) => [codec, codec])
|
||||
).values()
|
||||
handler: async (ctx): Promise<string | null> => {
|
||||
const token = crypto.randomUUID()
|
||||
const acquired: boolean = await ctx.runMutation(
|
||||
internal.library.acquireLibraryScanLock,
|
||||
{ token, leaseMs: SCAN_LOCK_LEASE_MS }
|
||||
)
|
||||
|
||||
for (const dbCodec of dbCodecs) {
|
||||
if (!codecs.includes(dbCodec)) {
|
||||
await removeCodecFromDatabase(ctx, dbCodec)
|
||||
}
|
||||
if (!acquired) {
|
||||
console.log("library scan: already running, skipped")
|
||||
return null
|
||||
}
|
||||
|
||||
// Removals
|
||||
for (const codec of codecs) {
|
||||
const dbArtists = await ctx.runQuery(internal.library.getArtists)
|
||||
const dbAlbums = await ctx.runQuery(internal.library.getAlbums)
|
||||
const dbSongs = await ctx.runQuery(internal.library.getSongs)
|
||||
|
||||
const dirtySongs = dbSongs
|
||||
.filter((song) => {
|
||||
return codec in song.files && !fsSync.existsSync(song.files[codec])
|
||||
})
|
||||
.map((song) => {
|
||||
const { [codec]: _, ...update } = song.files
|
||||
return { id: song._id, files: update }
|
||||
})
|
||||
|
||||
const songsToDelete = dirtySongs.filter(
|
||||
(song) => Object.keys(song.files).length === 0
|
||||
)
|
||||
const songsToUpdate = dirtySongs.filter(
|
||||
(song) => Object.keys(song.files).length !== 0
|
||||
)
|
||||
const songsToDeleteIDs = songsToDelete.map((song) => song.id)
|
||||
|
||||
await purgeRemovedSongs(ctx, songsToDeleteIDs)
|
||||
await ctx.runMutation(internal.library.removeSongs, {
|
||||
ids: songsToDeleteIDs,
|
||||
})
|
||||
await ctx.runMutation(internal.library.changeFilesForSongs, {
|
||||
songs: songsToUpdate,
|
||||
})
|
||||
|
||||
const deletedSongIds = new Set(songsToDeleteIDs)
|
||||
const albumsWithSongs = new Set(
|
||||
dbSongs.flatMap((song) =>
|
||||
deletedSongIds.has(song._id) ? [] : [song.album]
|
||||
)
|
||||
)
|
||||
const albumsToDelete = dbAlbums
|
||||
.filter((album) => !albumsWithSongs.has(album._id))
|
||||
.map((album) => album._id)
|
||||
await purgeRemovedAlbums(ctx, albumsToDelete)
|
||||
await ctx.runMutation(internal.library.removeAlbums, {
|
||||
ids: albumsToDelete,
|
||||
})
|
||||
|
||||
const deletedAlbumIds = new Set(albumsToDelete)
|
||||
const artistsWithAlbums = new Set(
|
||||
dbAlbums.flatMap((album) =>
|
||||
deletedAlbumIds.has(album._id) ? [] : [album.artist]
|
||||
)
|
||||
)
|
||||
const artistsToDelete = dbArtists
|
||||
.filter((artist) => !artistsWithAlbums.has(artist._id))
|
||||
.map((artist) => artist._id)
|
||||
await purgeRemovedArtists(ctx, artistsToDelete)
|
||||
await ctx.runMutation(internal.library.removeArtists, {
|
||||
ids: artistsToDelete,
|
||||
})
|
||||
try {
|
||||
return await scanLibrary(ctx)
|
||||
} finally {
|
||||
await ctx.runMutation(internal.library.releaseLibraryScanLock, { token })
|
||||
}
|
||||
|
||||
// Additions
|
||||
for (const codec of codecs) {
|
||||
// Artists
|
||||
console.log(`${codec}: artists`)
|
||||
let dbArtists = await ctx.runQuery(internal.library.getArtists)
|
||||
const dbArtistFolders = dbArtists.map((artist) => artist.folder)
|
||||
const artists = (
|
||||
await fs.readdir(`${DATA_DIR}/${codec}`, { withFileTypes: true })
|
||||
)
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => dirent.name)
|
||||
const potentialArtists = artists.filter(
|
||||
(artist) => !dbArtistFolders.includes(artist)
|
||||
)
|
||||
|
||||
const newArtists = []
|
||||
for (const folder of potentialArtists) {
|
||||
const albums = (
|
||||
await fs.readdir(`${DATA_DIR}/${codec}/${folder}`, {
|
||||
withFileTypes: true,
|
||||
})
|
||||
)
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => dirent.name)
|
||||
|
||||
if (albums.length === 0) {
|
||||
continue
|
||||
}
|
||||
|
||||
for (let i = 0; i < albums.length; i++) {
|
||||
const songs = (
|
||||
await fs.readdir(`${DATA_DIR}/${codec}/${folder}/${albums[i]}`, {
|
||||
withFileTypes: true,
|
||||
})
|
||||
)
|
||||
.filter(
|
||||
(dirent) => !dirent.isDirectory() && dirent.name !== "cover.jpg"
|
||||
)
|
||||
.map((dirent) => dirent.name)
|
||||
|
||||
if (songs.length === 0) {
|
||||
continue
|
||||
}
|
||||
|
||||
try {
|
||||
const metadata = await music.parseFile(
|
||||
`${DATA_DIR}/${codec}/${folder}/${albums[i]}/${songs[0]}`,
|
||||
{ skipCovers: true }
|
||||
)
|
||||
|
||||
const artistCoverPath = `${DATA_DIR}/${codec}/${folder}/folder.jpg`
|
||||
const cover = await coverPathIfExists(artistCoverPath)
|
||||
|
||||
newArtists.push({
|
||||
name: metadata.common.albumartist || folder,
|
||||
folder,
|
||||
cover,
|
||||
})
|
||||
break
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
await ctx.runMutation(internal.library.createArtists, {
|
||||
artists: newArtists,
|
||||
})
|
||||
dbArtists = await ctx.runQuery(internal.library.getArtists)
|
||||
|
||||
// Albums
|
||||
console.log(`${codec}: albums`)
|
||||
let dbAlbums = await ctx.runQuery(internal.library.getAlbums)
|
||||
const newAlbums = []
|
||||
for (const dbArtist of dbArtists) {
|
||||
const dbAlbumsInArtist = dbAlbums.filter(
|
||||
(album) => album.artist === dbArtist._id
|
||||
)
|
||||
const dbAlbumFolders = dbAlbumsInArtist.map((album) => album.folder)
|
||||
|
||||
if (!fsSync.existsSync(`${DATA_DIR}/${codec}/${dbArtist.folder}`)) {
|
||||
continue
|
||||
}
|
||||
|
||||
const albums = (
|
||||
await fs.readdir(`${DATA_DIR}/${codec}/${dbArtist.folder}`, {
|
||||
withFileTypes: true,
|
||||
})
|
||||
)
|
||||
.filter((dirent) => dirent.isDirectory())
|
||||
.map((dirent) => dirent.name)
|
||||
const potentialAlbums = albums.filter(
|
||||
(album) => !dbAlbumFolders.includes(album)
|
||||
)
|
||||
|
||||
for (const potentialAlbum of potentialAlbums) {
|
||||
const potentialAlbumPath = `${DATA_DIR}/${codec}/${dbArtist.folder}/${potentialAlbum}`
|
||||
if (!fsSync.existsSync(potentialAlbumPath)) {
|
||||
continue
|
||||
}
|
||||
|
||||
const songs = (
|
||||
await fs.readdir(potentialAlbumPath, {
|
||||
withFileTypes: true,
|
||||
})
|
||||
)
|
||||
.filter(
|
||||
(dirent) => !dirent.isDirectory() && dirent.name !== "cover.jpg"
|
||||
)
|
||||
.map((dirent) => dirent.name)
|
||||
|
||||
if (songs.length === 0) {
|
||||
continue
|
||||
}
|
||||
|
||||
try {
|
||||
const metadata = await music.parseFile(
|
||||
`${potentialAlbumPath}/${songs[0]}`,
|
||||
{ skipCovers: true }
|
||||
)
|
||||
|
||||
const albumCoverPath = `${DATA_DIR}/${codec}/${dbArtist.folder}/${potentialAlbum}/cover.jpg`
|
||||
const cover = await coverPathIfExists(albumCoverPath)
|
||||
|
||||
newAlbums.push({
|
||||
name: metadata.common.album || potentialAlbum,
|
||||
folder: potentialAlbum,
|
||||
cover,
|
||||
year: metadata.common.year || 2026,
|
||||
date:
|
||||
metadata.common.date || `01-01-${metadata.common.year || 2026}`,
|
||||
artist: dbArtist._id,
|
||||
})
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
await ctx.runMutation(internal.library.createAlbums, {
|
||||
albums: newAlbums,
|
||||
})
|
||||
dbAlbums = await ctx.runQuery(internal.library.getAlbums)
|
||||
const dbSongs = await ctx.runQuery(internal.library.getSongs)
|
||||
|
||||
const dbAlbumsArtists = dbAlbums.map((album) => {
|
||||
return {
|
||||
...album,
|
||||
artist: dbArtists.find((artist) => artist._id === album.artist)!,
|
||||
}
|
||||
})
|
||||
|
||||
// Covers
|
||||
console.log(`${codec}: covers`)
|
||||
for (const dbArtist of dbArtists) {
|
||||
const artistPath = `${DATA_DIR}/${codec}/${dbArtist.folder}`
|
||||
if (!fsSync.existsSync(artistPath)) {
|
||||
continue
|
||||
}
|
||||
await syncArtistCover(
|
||||
ctx,
|
||||
codec,
|
||||
dbArtist.cover,
|
||||
`${artistPath}/folder.jpg`,
|
||||
dbArtist._id
|
||||
)
|
||||
}
|
||||
|
||||
for (const dbAlbum of dbAlbumsArtists) {
|
||||
const artistPath = `${DATA_DIR}/${codec}/${dbAlbum.artist.folder}`
|
||||
const albumPath = `${artistPath}/${dbAlbum.folder}`
|
||||
if (!fsSync.existsSync(artistPath) || !fsSync.existsSync(albumPath)) {
|
||||
continue
|
||||
}
|
||||
await syncAlbumCover(
|
||||
ctx,
|
||||
codec,
|
||||
dbAlbum.cover,
|
||||
`${albumPath}/cover.jpg`,
|
||||
dbAlbum._id
|
||||
)
|
||||
}
|
||||
|
||||
// Songs
|
||||
console.log(`${codec}: songs`)
|
||||
|
||||
const newSongs = []
|
||||
const updateSongs = []
|
||||
for (const dbAlbum of dbAlbumsArtists) {
|
||||
const dbSongsInAlbum = dbSongs.filter(
|
||||
(song) => song.album === dbAlbum._id
|
||||
)
|
||||
const dbAlreadyTracked = dbSongsInAlbum
|
||||
.filter((song) => codec in song.files)
|
||||
.map((song) => song.files[codec])
|
||||
|
||||
const artistPath = `${DATA_DIR}/${codec}/${dbAlbum.artist.folder}`
|
||||
const albumPath = `${artistPath}/${dbAlbum.folder}`
|
||||
if (!fsSync.existsSync(artistPath) || !fsSync.existsSync(albumPath)) {
|
||||
continue
|
||||
}
|
||||
|
||||
const songs = (await fs.readdir(albumPath, { withFileTypes: true }))
|
||||
.filter(
|
||||
(dirent) => !dirent.isDirectory() && dirent.name !== "cover.jpg"
|
||||
)
|
||||
.map((dirent) => dirent.name)
|
||||
.filter((song) => !dbAlreadyTracked.includes(`${albumPath}/${song}`))
|
||||
|
||||
for (const song of songs) {
|
||||
try {
|
||||
const path = `${DATA_DIR}/${codec}/${dbAlbum.artist.folder}/${dbAlbum.folder}/${song}`
|
||||
const metadata = await music.parseFile(path, { skipCovers: true })
|
||||
|
||||
if (!metadata.common.title) {
|
||||
continue
|
||||
}
|
||||
|
||||
const existingSong = dbSongsInAlbum.find(
|
||||
(dbSong) => dbSong.name === metadata.common.title
|
||||
)
|
||||
|
||||
if (existingSong) {
|
||||
if (
|
||||
!(codec in existingSong.files) ||
|
||||
existingSong.files[codec] !== path
|
||||
) {
|
||||
const update = { [codec]: path, ...existingSong.files }
|
||||
updateSongs.push({
|
||||
id: existingSong._id,
|
||||
files: update,
|
||||
})
|
||||
}
|
||||
} else {
|
||||
let files = { [codec]: path }
|
||||
|
||||
if (codec !== "atmos") {
|
||||
const artistPath = `${DATA_DIR}/atmos/${dbAlbum.artist.folder}`
|
||||
const albumPath = `${artistPath}/${dbAlbum.folder}`
|
||||
const path = `${albumPath}/${song}`
|
||||
|
||||
if (fsSync.existsSync(path)) {
|
||||
files = { atmos: path, ...files }
|
||||
}
|
||||
}
|
||||
if (codec !== "lossless") {
|
||||
const artistPath = `${DATA_DIR}/lossless/${dbAlbum.artist.folder}`
|
||||
const albumPath = `${artistPath}/${dbAlbum.folder}`
|
||||
const path = `${albumPath}/${song}`
|
||||
|
||||
if (fsSync.existsSync(path)) {
|
||||
files = { lossless: path, ...files }
|
||||
}
|
||||
}
|
||||
if (codec !== "normal") {
|
||||
const artistPath = `${DATA_DIR}/normal/${dbAlbum.artist.folder}`
|
||||
const albumPath = `${artistPath}/${dbAlbum.folder}`
|
||||
const path = `${albumPath}/${song}`
|
||||
|
||||
if (fsSync.existsSync(path)) {
|
||||
files = { normal: path, ...files }
|
||||
}
|
||||
}
|
||||
|
||||
newSongs.push({
|
||||
name: metadata.common.title,
|
||||
files,
|
||||
album: dbAlbum._id,
|
||||
artist:
|
||||
metadata.common.artist ??
|
||||
metadata.common.artists ??
|
||||
dbAlbum.artist.name,
|
||||
albumArtist: dbAlbum.artist._id,
|
||||
length: Math.round(metadata.format.duration || 0),
|
||||
diskNumber:
|
||||
metadata.common.disk.of === 1
|
||||
? null
|
||||
: metadata.common.disk.no,
|
||||
track: metadata.common.track.no || 0,
|
||||
year: metadata.common.year || 2026,
|
||||
date:
|
||||
metadata.common.date ||
|
||||
`01-01-${metadata.common.year || 2026}`,
|
||||
genres: metadata.common.genre || [],
|
||||
})
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
}
|
||||
await ctx.runMutation(internal.library.createSongs, { songs: newSongs })
|
||||
await ctx.runMutation(internal.library.changeFilesForSongs, {
|
||||
songs: updateSongs,
|
||||
})
|
||||
}
|
||||
|
||||
return "success"
|
||||
},
|
||||
})
|
||||
|
||||
@@ -574,7 +556,20 @@ export const updateLibrary = action({
|
||||
args: {},
|
||||
handler: async (ctx): Promise<string> => {
|
||||
await requireAdmin(ctx)
|
||||
return ctx.runAction(internal.actions.scheduledUpdateLibrary)
|
||||
const result: string | null = await ctx.runAction(
|
||||
internal.actions.scheduledUpdateLibrary
|
||||
)
|
||||
if (result === null) {
|
||||
throw new ConvexError("A library scan is already running")
|
||||
}
|
||||
return result
|
||||
},
|
||||
})
|
||||
|
||||
export const cleanupHlsStreams = internalAction({
|
||||
args: {},
|
||||
handler: async () => {
|
||||
return await cleanHlsStreamsOlderThan(HLS_MAX_IDLE_MS)
|
||||
},
|
||||
})
|
||||
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
import { getAuthUserId } from "@convex-dev/auth/server"
|
||||
import { ConvexError, v } from "convex/values"
|
||||
import { paginationOptsValidator } from "convex/server"
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
import type { MutationCtx, QueryCtx } from "./_generated/server"
|
||||
import { mutation, query } from "./_generated/server"
|
||||
import type { BrowsePlaylistDetail, BrowsePlaylistSummary } from "./library"
|
||||
import { browseSongsFromIds } from "./library"
|
||||
import { browseSongsFromIds, paginateSlice } from "./library"
|
||||
|
||||
function uniqueIds<T extends string>(ids: T[]): T[] {
|
||||
return [...new Set(ids)]
|
||||
@@ -180,6 +181,11 @@ async function browseFavoritesSummaryHandler(
|
||||
}
|
||||
}
|
||||
|
||||
export const browseFavoritesSummary = query({
|
||||
args: {},
|
||||
handler: async (ctx) => browseFavoritesSummaryHandler(ctx),
|
||||
})
|
||||
|
||||
export const browseFavoritesPlaylistDetail = query({
|
||||
args: {},
|
||||
handler: async (ctx): Promise<BrowsePlaylistDetail | null> => {
|
||||
@@ -203,6 +209,24 @@ export const browseFavoritesPlaylistDetail = query({
|
||||
},
|
||||
})
|
||||
|
||||
export const browseFavoritesSongsPaginated = query({
|
||||
args: { paginationOpts: paginationOptsValidator },
|
||||
handler: async (ctx, args) => {
|
||||
const summary = await browseFavoritesSummaryHandler(ctx)
|
||||
if (!summary) {
|
||||
return { page: [], isDone: true, continueCursor: "" }
|
||||
}
|
||||
|
||||
const slice = paginateSlice(summary.songIds, args.paginationOpts)
|
||||
const page = await browseSongsFromIds(ctx, slice.page)
|
||||
|
||||
return {
|
||||
...slice,
|
||||
page,
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
export const favoriteSong = mutation({
|
||||
args: { songId: v.id("songs") },
|
||||
handler: async (ctx, { songId }) => {
|
||||
|
||||
+781
-252
File diff suppressed because it is too large.
Load diff
@@ -1,9 +1,17 @@
|
||||
import { getAuthUserId } from "@convex-dev/auth/server"
|
||||
import { paginationOptsValidator } from "convex/server"
|
||||
import { ConvexError, v } from "convex/values"
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
import type { MutationCtx } from "./_generated/server"
|
||||
import { mutation, query } from "./_generated/server"
|
||||
import { browseSongsFromIds } from "./library"
|
||||
import type { QueueSong } from "./types"
|
||||
import {
|
||||
browseSongsFromIds,
|
||||
compareAlbumSongs,
|
||||
getSortedLibrarySongIds,
|
||||
songsSortDirectionValidator,
|
||||
songsSortKeyValidator,
|
||||
} from "./library"
|
||||
|
||||
export type { HistorySong, QueueSong } from "./types"
|
||||
|
||||
@@ -51,6 +59,35 @@ async function recordRecentlyPlayedFromSong(
|
||||
await recordRecentlyPlayed(ctx, userId, song.album)
|
||||
}
|
||||
|
||||
async function recordPlaybackStart(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">,
|
||||
options: {
|
||||
songIds: Id<"songs">[]
|
||||
playlistId?: Id<"playlists">
|
||||
}
|
||||
) {
|
||||
if (options.songIds.length === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
if (options.playlistId) {
|
||||
await recordRecentlyPlayed(ctx, userId, options.playlistId)
|
||||
return
|
||||
}
|
||||
|
||||
await recordRecentlyPlayedFromSong(ctx, userId, options.songIds[0])
|
||||
}
|
||||
|
||||
function shuffleArray<T>(items: T[]): T[] {
|
||||
const next = [...items]
|
||||
for (let i = next.length - 1; i > 0; i--) {
|
||||
const j = Math.floor(Math.random() * (i + 1))
|
||||
;[next[i], next[j]] = [next[j], next[i]]
|
||||
}
|
||||
return next
|
||||
}
|
||||
|
||||
async function requireAuth(ctx: MutationCtx) {
|
||||
const userId = await getAuthUserId(ctx)
|
||||
if (userId === null) {
|
||||
@@ -59,6 +96,54 @@ async function requireAuth(ctx: MutationCtx) {
|
||||
return userId
|
||||
}
|
||||
|
||||
function uniqueSongIds(songIds: Id<"songs">[]) {
|
||||
return [...new Set(songIds)]
|
||||
}
|
||||
|
||||
function haveSameSongCounts(first: Id<"songs">[], second: Id<"songs">[]) {
|
||||
if (first.length !== second.length) {
|
||||
return false
|
||||
}
|
||||
const counts = new Map<Id<"songs">, number>()
|
||||
for (const songId of first) {
|
||||
counts.set(songId, (counts.get(songId) ?? 0) + 1)
|
||||
}
|
||||
for (const songId of second) {
|
||||
const count = counts.get(songId)
|
||||
if (!count) {
|
||||
return false
|
||||
}
|
||||
if (count === 1) {
|
||||
counts.delete(songId)
|
||||
} else {
|
||||
counts.set(songId, count - 1)
|
||||
}
|
||||
}
|
||||
return counts.size === 0
|
||||
}
|
||||
|
||||
function appendToQueueHistory(
|
||||
history: Id<"songs">[],
|
||||
songId: Id<"songs">
|
||||
): Id<"songs">[] {
|
||||
const next = [...history, songId]
|
||||
if (next.length <= MAX_QUEUE_HISTORY) {
|
||||
return next
|
||||
}
|
||||
return next.slice(next.length - MAX_QUEUE_HISTORY)
|
||||
}
|
||||
|
||||
function appendManyToQueueHistory(
|
||||
history: Id<"songs">[],
|
||||
songIds: Id<"songs">[]
|
||||
): Id<"songs">[] {
|
||||
let next = history
|
||||
for (const songId of songIds) {
|
||||
next = appendToQueueHistory(next, songId)
|
||||
}
|
||||
return next
|
||||
}
|
||||
|
||||
async function patchPlayback(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">,
|
||||
@@ -83,6 +168,26 @@ async function patchPlayback(
|
||||
return playbackRevision
|
||||
}
|
||||
|
||||
async function setQueueState(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">,
|
||||
patch: {
|
||||
songQueue: Id<"songs">[]
|
||||
shuffleEnabled?: boolean
|
||||
currentSongProgress?: number
|
||||
resetHistory?: boolean
|
||||
}
|
||||
) {
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: patch.songQueue,
|
||||
currentSongProgress: patch.currentSongProgress ?? 0,
|
||||
...(patch.resetHistory ? { queueHistory: [] } : {}),
|
||||
...(patch.shuffleEnabled !== undefined
|
||||
? { shuffleEnabled: patch.shuffleEnabled }
|
||||
: {}),
|
||||
})
|
||||
}
|
||||
|
||||
export const getPlaybackState = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
@@ -159,6 +264,559 @@ export const recordPlay = mutation({
|
||||
},
|
||||
})
|
||||
|
||||
export const getQueueHistory = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await getAuthUserId(ctx)
|
||||
if (userId === null) {
|
||||
return []
|
||||
}
|
||||
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
return []
|
||||
}
|
||||
|
||||
const songIds = user.queueHistory ?? []
|
||||
const songs = await browseSongsFromIds(ctx, songIds)
|
||||
|
||||
return songs.map((song, index) => ({
|
||||
...song,
|
||||
historyIndex: index,
|
||||
}))
|
||||
},
|
||||
})
|
||||
|
||||
export const getQueuePaginated = query({
|
||||
args: {
|
||||
paginationOpts: paginationOptsValidator,
|
||||
queueVersion: v.string(),
|
||||
},
|
||||
handler: async (ctx, args) => {
|
||||
const userId = await getAuthUserId(ctx)
|
||||
if (userId === null) {
|
||||
return { page: [], isDone: true, continueCursor: "" }
|
||||
}
|
||||
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
return { page: [], isDone: true, continueCursor: "" }
|
||||
}
|
||||
|
||||
const songIds = user.songQueue ?? []
|
||||
const startIndex = args.paginationOpts.cursor
|
||||
? Number.parseInt(args.paginationOpts.cursor, 10)
|
||||
: 0
|
||||
const endIndex = Math.min(
|
||||
startIndex + args.paginationOpts.numItems,
|
||||
songIds.length
|
||||
)
|
||||
const pageIds = songIds.slice(startIndex, endIndex)
|
||||
const songs = await browseSongsFromIds(ctx, pageIds)
|
||||
|
||||
const page: QueueSong[] = songs.map((song, index) => ({
|
||||
...song,
|
||||
queueIndex: startIndex + index,
|
||||
}))
|
||||
|
||||
const isDone = endIndex >= songIds.length
|
||||
|
||||
return {
|
||||
page,
|
||||
isDone,
|
||||
continueCursor: isDone ? "" : String(endIndex),
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
export const playInOrder = mutation({
|
||||
args: {
|
||||
songIds: v.array(v.id("songs")),
|
||||
playlistId: v.optional(v.id("playlists")),
|
||||
},
|
||||
handler: async (ctx, { songIds, playlistId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const queue = uniqueSongIds(songIds)
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: queue,
|
||||
shuffleEnabled: false,
|
||||
resetHistory: true,
|
||||
})
|
||||
await recordPlaybackStart(ctx, userId, { songIds: queue, playlistId })
|
||||
},
|
||||
})
|
||||
|
||||
export const playShuffled = mutation({
|
||||
args: {
|
||||
songIds: v.array(v.id("songs")),
|
||||
playlistId: v.optional(v.id("playlists")),
|
||||
},
|
||||
handler: async (ctx, { songIds, playlistId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const queue = shuffleArray(uniqueSongIds(songIds))
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: queue,
|
||||
shuffleEnabled: true,
|
||||
resetHistory: true,
|
||||
})
|
||||
await recordPlaybackStart(ctx, userId, { songIds: queue, playlistId })
|
||||
},
|
||||
})
|
||||
|
||||
function orderSongsForInsert(
|
||||
songIds: Id<"songs">[],
|
||||
shuffleEnabled: boolean
|
||||
): Id<"songs">[] {
|
||||
return shuffleEnabled ? shuffleArray(songIds) : songIds
|
||||
}
|
||||
|
||||
export const addToQueueNext = mutation({
|
||||
args: { songIds: v.array(v.id("songs")) },
|
||||
handler: async (ctx, { songIds }) => {
|
||||
if (songIds.length === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const toAdd = orderSongsForInsert(songIds, user.shuffleEnabled ?? false)
|
||||
const queue = user.songQueue ?? []
|
||||
|
||||
if (queue.length === 0) {
|
||||
await setQueueState(ctx, userId, { songQueue: toAdd })
|
||||
return
|
||||
}
|
||||
|
||||
const [current, ...rest] = queue
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: [current, ...toAdd, ...rest],
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const addToQueueLast = mutation({
|
||||
args: { songIds: v.array(v.id("songs")) },
|
||||
handler: async (ctx, { songIds }) => {
|
||||
if (songIds.length === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const toAdd = orderSongsForInsert(songIds, user.shuffleEnabled ?? false)
|
||||
const queue = user.songQueue ?? []
|
||||
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: queue.length === 0 ? toAdd : [...queue, ...toAdd],
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playFromSong = mutation({
|
||||
args: {
|
||||
songId: v.id("songs"),
|
||||
songIds: v.array(v.id("songs")),
|
||||
},
|
||||
handler: async (ctx, { songId, songIds }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const index = songIds.indexOf(songId)
|
||||
const rest = user.shuffleEnabled
|
||||
? uniqueSongIds(songIds).filter((id) => id !== songId)
|
||||
: index === -1
|
||||
? []
|
||||
: songIds.slice(index + 1)
|
||||
const queueRest = user.shuffleEnabled ? shuffleArray(rest) : rest
|
||||
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: [songId, ...queueRest],
|
||||
resetHistory: true,
|
||||
})
|
||||
await recordRecentlyPlayedFromSong(ctx, userId, songId)
|
||||
},
|
||||
})
|
||||
|
||||
async function albumSongIds(ctx: MutationCtx, albumId: Id<"albums">) {
|
||||
const songs = await ctx.db
|
||||
.query("songs")
|
||||
.withIndex("by_album", (q) => q.eq("album", albumId))
|
||||
.collect()
|
||||
songs.sort(compareAlbumSongs)
|
||||
return songs.map((song) => song._id)
|
||||
}
|
||||
|
||||
async function orderedArtistSongIds(
|
||||
ctx: MutationCtx,
|
||||
artistId: Id<"artists">
|
||||
) {
|
||||
const songs = await ctx.db
|
||||
.query("songs")
|
||||
.withIndex("by_artist", (q) => q.eq("albumArtist", artistId))
|
||||
.collect()
|
||||
|
||||
const albums = await ctx.db
|
||||
.query("albums")
|
||||
.withIndex("by_artist", (q) => q.eq("artist", artistId))
|
||||
.collect()
|
||||
const albumMap = new Map(albums.map((album) => [album._id, album]))
|
||||
|
||||
songs.sort((a, b) => {
|
||||
const albumA = albumMap.get(a.album)?.name ?? ""
|
||||
const albumB = albumMap.get(b.album)?.name ?? ""
|
||||
if (albumA !== albumB) {
|
||||
return albumA.localeCompare(albumB)
|
||||
}
|
||||
if (a.track !== b.track) {
|
||||
return a.track - b.track
|
||||
}
|
||||
return a.name.localeCompare(b.name)
|
||||
})
|
||||
|
||||
return songs.map((song) => song._id)
|
||||
}
|
||||
|
||||
async function playCollection(
|
||||
ctx: MutationCtx,
|
||||
options: {
|
||||
songIds: Id<"songs">[]
|
||||
shuffled: boolean
|
||||
playlistId?: Id<"playlists">
|
||||
}
|
||||
) {
|
||||
const userId = await requireAuth(ctx)
|
||||
const unique = uniqueSongIds(options.songIds)
|
||||
if (unique.length === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
const queue = options.shuffled ? shuffleArray(unique) : unique
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: queue,
|
||||
shuffleEnabled: options.shuffled,
|
||||
resetHistory: true,
|
||||
})
|
||||
await recordPlaybackStart(ctx, userId, {
|
||||
songIds: queue,
|
||||
playlistId: options.playlistId,
|
||||
})
|
||||
}
|
||||
|
||||
export const playAlbum = mutation({
|
||||
args: { albumId: v.id("albums") },
|
||||
handler: async (ctx, { albumId }) => {
|
||||
await playCollection(ctx, {
|
||||
songIds: await albumSongIds(ctx, albumId),
|
||||
shuffled: false,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playAlbumShuffled = mutation({
|
||||
args: { albumId: v.id("albums") },
|
||||
handler: async (ctx, { albumId }) => {
|
||||
await playCollection(ctx, {
|
||||
songIds: await albumSongIds(ctx, albumId),
|
||||
shuffled: true,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playArtist = mutation({
|
||||
args: { artistId: v.id("artists") },
|
||||
handler: async (ctx, { artistId }) => {
|
||||
await playCollection(ctx, {
|
||||
songIds: await orderedArtistSongIds(ctx, artistId),
|
||||
shuffled: false,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playArtistShuffled = mutation({
|
||||
args: { artistId: v.id("artists") },
|
||||
handler: async (ctx, { artistId }) => {
|
||||
await playCollection(ctx, {
|
||||
songIds: await orderedArtistSongIds(ctx, artistId),
|
||||
shuffled: true,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playPlaylist = mutation({
|
||||
args: { playlistId: v.id("playlists") },
|
||||
handler: async (ctx, { playlistId }) => {
|
||||
const playlist = await ctx.db.get("playlists", playlistId)
|
||||
await playCollection(ctx, {
|
||||
songIds: playlist?.songs ?? [],
|
||||
shuffled: false,
|
||||
playlistId,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playPlaylistShuffled = mutation({
|
||||
args: { playlistId: v.id("playlists") },
|
||||
handler: async (ctx, { playlistId }) => {
|
||||
const playlist = await ctx.db.get("playlists", playlistId)
|
||||
await playCollection(ctx, {
|
||||
songIds: playlist?.songs ?? [],
|
||||
shuffled: true,
|
||||
playlistId,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const playFromLibrarySong = mutation({
|
||||
args: {
|
||||
songId: v.id("songs"),
|
||||
sortKey: songsSortKeyValidator,
|
||||
sortDirection: songsSortDirectionValidator,
|
||||
},
|
||||
handler: async (ctx, { songId, sortKey, sortDirection }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const songIds = await getSortedLibrarySongIds(
|
||||
ctx,
|
||||
sortKey,
|
||||
sortDirection,
|
||||
songId
|
||||
)
|
||||
const index = songIds.indexOf(songId)
|
||||
const rest = user.shuffleEnabled
|
||||
? uniqueSongIds(songIds).filter((id) => id !== songId)
|
||||
: index === -1
|
||||
? []
|
||||
: songIds.slice(index + 1)
|
||||
const queueRest = user.shuffleEnabled ? shuffleArray(rest) : rest
|
||||
|
||||
await setQueueState(ctx, userId, {
|
||||
songQueue: [songId, ...queueRest],
|
||||
resetHistory: true,
|
||||
})
|
||||
await recordRecentlyPlayedFromSong(ctx, userId, songId)
|
||||
},
|
||||
})
|
||||
|
||||
export const toggleShuffle = mutation({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const shuffleEnabled = !(user.shuffleEnabled ?? false)
|
||||
const queue = user.songQueue ?? []
|
||||
|
||||
if (shuffleEnabled && queue.length > 1) {
|
||||
const [current, ...upNext] = queue
|
||||
await patchPlayback(ctx, userId, {
|
||||
shuffleEnabled: true,
|
||||
songQueue: [current, ...shuffleArray(upNext)],
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
await patchPlayback(ctx, userId, { shuffleEnabled })
|
||||
},
|
||||
})
|
||||
|
||||
export const cycleRepeat = mutation({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const current = user.repeatEnabled ?? "none"
|
||||
const next =
|
||||
current === "none" ? "once" : current === "once" ? "always" : "none"
|
||||
|
||||
await patchPlayback(ctx, userId, { repeatEnabled: next })
|
||||
},
|
||||
})
|
||||
|
||||
export const clearQueue = mutation({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: [],
|
||||
queueHistory: [],
|
||||
currentSongProgress: 0,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const reorderQueue = mutation({
|
||||
args: { songIds: v.array(v.id("songs")) },
|
||||
handler: async (ctx, { songIds }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const queue = user.songQueue ?? []
|
||||
if (!haveSameSongCounts(queue, songIds)) {
|
||||
throw new ConvexError("Invalid queue order")
|
||||
}
|
||||
const currentSongChanged = songIds.length > 0 && songIds[0] !== queue[0]
|
||||
const history =
|
||||
currentSongChanged && queue.length > 0
|
||||
? appendToQueueHistory(user.queueHistory ?? [], queue[0])
|
||||
: (user.queueHistory ?? [])
|
||||
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: songIds,
|
||||
queueHistory: history,
|
||||
...(currentSongChanged ? { currentSongProgress: 0 } : {}),
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const skipToQueueIndex = mutation({
|
||||
args: { index: v.number() },
|
||||
handler: async (ctx, { index }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const queue = user.songQueue ?? []
|
||||
if (index < 0 || index >= queue.length || index === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
const skipped = queue.slice(0, index)
|
||||
const history = appendManyToQueueHistory(user.queueHistory ?? [], skipped)
|
||||
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: queue.slice(index),
|
||||
queueHistory: history,
|
||||
currentSongProgress: 0,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const skipNext = mutation({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const queue = user.songQueue ?? []
|
||||
if (queue.length === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
const repeat = user.repeatEnabled ?? "none"
|
||||
|
||||
if (repeat === "once") {
|
||||
await patchPlayback(ctx, userId, { currentSongProgress: 0 })
|
||||
return
|
||||
}
|
||||
|
||||
const [current, ...rest] = queue
|
||||
|
||||
if (repeat === "always") {
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: [...rest, current],
|
||||
currentSongProgress: 0,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if (rest.length === 0) {
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: [current],
|
||||
currentSongProgress: 0,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
const history = appendToQueueHistory(user.queueHistory ?? [], current)
|
||||
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: rest,
|
||||
queueHistory: history,
|
||||
currentSongProgress: 0,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const skipPrevious = mutation({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const queue = user.songQueue ?? []
|
||||
const history = user.queueHistory ?? []
|
||||
|
||||
if (queue.length === 0) {
|
||||
return
|
||||
}
|
||||
|
||||
if (history.length === 0) {
|
||||
await patchPlayback(ctx, userId, { currentSongProgress: 0 })
|
||||
return
|
||||
}
|
||||
|
||||
const [current, ...rest] = queue
|
||||
const previous = history[history.length - 1]
|
||||
const newHistory = history.slice(0, -1)
|
||||
|
||||
await patchPlayback(ctx, userId, {
|
||||
songQueue: [previous, current, ...rest],
|
||||
queueHistory: newHistory,
|
||||
currentSongProgress: 0,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
export const getSongProgress = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
const userId = await getAuthUserId(ctx)
|
||||
if (userId === null) {
|
||||
throw new ConvexError("User not logged in")
|
||||
}
|
||||
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
return user.currentSongProgress ?? 0
|
||||
},
|
||||
})
|
||||
|
||||
export const updateSongProgress = mutation({
|
||||
args: {
|
||||
songId: v.id("songs"),
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { paginationOptsValidator } from "convex/server"
|
||||
import { getAuthUserId } from "@convex-dev/auth/server"
|
||||
import { ConvexError, v } from "convex/values"
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
@@ -10,7 +11,7 @@ import type {
|
||||
PlaylistSummary,
|
||||
SidebarPlaylists,
|
||||
} from "./library"
|
||||
import { browseSongsFromIds, compareAlbumSongs } from "./library"
|
||||
import { browseSongsFromIds, compareAlbumSongs, paginateSlice } from "./library"
|
||||
|
||||
function toPlaylistSummary(
|
||||
playlist: Doc<"playlists">,
|
||||
@@ -108,15 +109,23 @@ async function browsePlaylistSummaryHandler(
|
||||
}
|
||||
}
|
||||
|
||||
export const browsePlaylistDetail = query({
|
||||
export const browsePlaylistSummary = query({
|
||||
args: { id: v.id("playlists") },
|
||||
handler: async (ctx, args) => browsePlaylistSummaryHandler(ctx, args.id),
|
||||
})
|
||||
|
||||
export const browsePlaylistDetail = query({
|
||||
args: { id: v.id("playlists"), includeSongs: v.optional(v.boolean()) },
|
||||
handler: async (ctx, args): Promise<BrowsePlaylistDetail | null> => {
|
||||
const summary = await browsePlaylistSummaryHandler(ctx, args.id)
|
||||
if (!summary) {
|
||||
return null
|
||||
}
|
||||
|
||||
const songs = await browseSongsFromIds(ctx, summary.songIds)
|
||||
const songs =
|
||||
(args.includeSongs ?? true)
|
||||
? await browseSongsFromIds(ctx, summary.songIds)
|
||||
: []
|
||||
|
||||
return {
|
||||
id: summary.id,
|
||||
@@ -130,6 +139,27 @@ export const browsePlaylistDetail = query({
|
||||
},
|
||||
})
|
||||
|
||||
export const browsePlaylistSongsPaginated = query({
|
||||
args: {
|
||||
id: v.id("playlists"),
|
||||
paginationOpts: paginationOptsValidator,
|
||||
},
|
||||
handler: async (ctx, args) => {
|
||||
const playlist = await ctx.db.get("playlists", args.id)
|
||||
if (!playlist) {
|
||||
return { page: [], isDone: true, continueCursor: "" }
|
||||
}
|
||||
|
||||
const slice = paginateSlice(playlist.songs, args.paginationOpts)
|
||||
const page = await browseSongsFromIds(ctx, slice.page)
|
||||
|
||||
return {
|
||||
...slice,
|
||||
page,
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
export const listOwnedPlaylists = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
|
||||
@@ -48,13 +48,18 @@ export default defineSchema({
|
||||
appSettings: defineTable({
|
||||
disableAccountCreation: v.boolean(),
|
||||
}),
|
||||
libraryScanLock: defineTable({
|
||||
token: v.string(),
|
||||
expiresAt: v.number(),
|
||||
}),
|
||||
artists: defineTable({
|
||||
name: v.string(),
|
||||
folder: v.string(),
|
||||
cover: v.nullable(v.string()),
|
||||
})
|
||||
.index("by_name", ["name"])
|
||||
.index("by_folder", ["folder"]),
|
||||
.index("by_folder", ["folder"])
|
||||
.searchIndex("search_name", { searchField: "name" }),
|
||||
albums: defineTable({
|
||||
name: v.string(),
|
||||
folder: v.string(),
|
||||
@@ -66,7 +71,8 @@ export default defineSchema({
|
||||
.index("by_artist", ["artist"])
|
||||
.index("by_name", ["name"])
|
||||
.index("by_folder", ["folder"])
|
||||
.index("by_all", ["artist", "folder"]),
|
||||
.index("by_all", ["artist", "folder"])
|
||||
.searchIndex("search_name", { searchField: "name" }),
|
||||
songs: defineTable({
|
||||
name: v.string(),
|
||||
files: v.record(v.string(), v.string()),
|
||||
@@ -83,7 +89,8 @@ export default defineSchema({
|
||||
.index("by_name", ["name"])
|
||||
.index("by_artist", ["albumArtist"])
|
||||
.index("by_album", ["album"])
|
||||
.index("by_all", ["name", "albumArtist", "album"]),
|
||||
.index("by_all", ["name", "albumArtist", "album"])
|
||||
.searchIndex("search_name", { searchField: "name" }),
|
||||
playlists: defineTable({
|
||||
name: v.string(),
|
||||
owner: v.id("users"),
|
||||
|
||||
@@ -33,14 +33,20 @@ export type BrowseAlbumTrack = {
|
||||
}
|
||||
|
||||
export type BrowseAlbumDetail = BrowseAlbum & {
|
||||
/** `null` when the files have no year tag; clients hide it. */
|
||||
year: number | null
|
||||
genre: string | null
|
||||
/** Empty when unknown; clients hide it. */
|
||||
releaseDate: string
|
||||
hasLossless: boolean
|
||||
hasAtmos: boolean
|
||||
tracks: BrowseAlbumTrack[]
|
||||
}
|
||||
|
||||
export type BrowseAlbumSummary = Omit<BrowseAlbumDetail, "tracks"> & {
|
||||
trackCount: number
|
||||
}
|
||||
|
||||
export type BrowseArtistDetail = {
|
||||
artist: BrowseArtist
|
||||
albums: BrowseAlbum[]
|
||||
|
||||
Reference in new issue
Block a user