Compare commits

..
60 changed files with 1806 additions and 2174 deletions

No files matched your search

+6 -5
View File
@@ -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
View File
@@ -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
@@ -0,0 +1 @@
export { default } from "../library/queue"
@@ -1,8 +1,3 @@
import { SongSwipeRow } from "@/components/song-swipe-row"
import {
useSwipeRowGroup,
type SwipeRowGroup,
} from "@/components/ios-swipe-to-remove-row"
import {
CollectionHero,
useCollectionHeroLayout,
@@ -35,7 +30,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"
@@ -73,7 +68,6 @@ export default function AlbumScreen() {
handleAlbumTrackAction,
isAlbumFavorite: isAlbumFav,
} = useMediaMenuActions()
const swipeGroup = useSwipeRowGroup()
const isFocused = useIsFocused()
const coverUri =
config && typeof id === "string" ? albumCoverUrl(config.serverUrl, id) : ""
@@ -118,7 +112,6 @@ export default function AlbumScreen() {
}
return album ? (
<AlbumTrackRow
swipeGroup={swipeGroup}
track={item.track}
number={item.number}
album={album}
@@ -139,7 +132,6 @@ export default function AlbumScreen() {
palette,
playFromSong,
songIds,
swipeGroup,
]
)
@@ -243,7 +235,6 @@ export default function AlbumScreen() {
}}
/>
<Animated.FlatList
onScrollBeginDrag={swipeGroup.closeOpenRow}
onLayout={onLayout}
{...longListProps}
data={listItems}
@@ -465,7 +456,6 @@ function albumListItemKey(item: AlbumListItem) {
const AlbumTrackRow = memo(function AlbumTrackRow({
track,
swipeGroup,
number,
album,
songIds,
@@ -475,7 +465,6 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
onAction,
}: {
track: BrowseAlbumTrack
swipeGroup: SwipeRowGroup
number: number
album: BrowseAlbumDetail
songIds: Id<"songs">[]
@@ -488,22 +477,8 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
action: MediaAction
) => Promise<void>
}) {
const Row = Platform.OS !== "web" ? SongSwipeRow : Pressable
const { config } = useServerConfig()
return (
<MediaContextMenu
preview={
config
? {
kind: "song",
title: track.title,
artist: album.artist.name,
album: album.title,
artworkUrl: albumCoverUrl(config.serverUrl, album.id),
hasArtwork: album.cover != null,
}
: undefined
}
stationArtistId={album.artist.id}
favorited={favorited}
navigation={{
@@ -519,11 +494,7 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
onAction={(action) => void onAction(track, album, action)}
>
<MusicEntityView kind="song" id={track.id}>
<Row
group={swipeGroup}
backgroundColor={palette.background}
onPlayNext={() => void onAction(track, album, "play-next")}
onAddToQueue={() => void onAction(track, album, "play-last")}
<Pressable
style={styles.trackRow}
onPress={() => void onPlay(track.id as Id<"songs">, songIds)}
>
@@ -564,7 +535,7 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
{formatDuration(track.durationSeconds)}
</PaletteText>
</View>
</Row>
</Pressable>
</MusicEntityView>
</MediaContextMenu>
)
@@ -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"
@@ -141,12 +141,6 @@ const ArtistRow = memo(function ArtistRow({
return (
<MediaContextMenu
preview={{
kind: "artist",
title: artist.name,
artworkUrl: artistCoverUrl(serverUrl, artist.id),
hasArtwork: artist.photo != null,
}}
favorited={favorited}
share={{ type: "artist", artistId: artist.id, title: artist.name }}
onAction={(action) => void onAction(artist, action)}
@@ -166,11 +160,7 @@ const ArtistRow = memo(function ArtistRow({
>
{artist.name}
</Text>
<Ionicons
name="chevron-forward"
size={16}
color={colors.mutedForeground}
/>
<Ionicons name="chevron-forward" size={16} color={colors.mutedForeground} />
</Pressable>
</MediaContextMenu>
)
@@ -39,6 +39,7 @@ import ReanimatedSwipeable from "react-native-gesture-handler/ReanimatedSwipeabl
import { CollectionDivider } from "@/components/collection-list"
import { CoverImage } from "@/components/cover-image"
import {
SwipeToRemoveRow,
useSwipeRowGroup,
type SwipeRowGroup,
} from "@/components/ios-swipe-to-remove-row"
@@ -46,7 +47,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 +315,7 @@ function PlaylistContent({
deletePlaylist,
handlePlaylistDetailAction,
palette.foreground,
palette.background,
palette.isDark,
playlistId,
playlist?.title,
@@ -432,31 +434,28 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
playlistLabel={PLAYLIST_LABEL}
palette={palette}
inset
swipe={
Platform.OS !== "web"
? {
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
}
onPlay={onPlay}
onAction={onAction}
/>
)
if (Platform.OS !== "web" || !removable) {
if (!removable) {
return row
}
if (Platform.OS === "ios") {
return (
<SwipeToRemoveRow
group={swipeGroup}
backgroundColor={palette.background}
actionAccessibilityLabel={`Remove ${song.title} from playlist`}
onRemove={handleRemove}
>
{row}
</SwipeToRemoveRow>
)
}
return (
<ReanimatedSwipeable
friction={2}
+186
View File
@@ -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 },
})
+1 -36
View File
@@ -20,10 +20,6 @@ import { contentBottomInset } from "@/components/player"
import { Button, Input, LoadingView } from "@/components/ui/primitives"
import { useInvalidateAuthSession } from "@/contexts/convex-auth-session"
import { useServerConfig } from "@/contexts/server-config"
import {
setArtworkColorsEnabled,
useArtworkColorsEnabled,
} from "@/lib/artwork-color-preference"
import { initialsFromName } from "@/lib/format"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { changeServer, signOut } from "@/lib/session"
@@ -147,12 +143,7 @@ export default function SettingsScreen() {
})}
</View>
{section === "profile" ? (
<>
<AppearanceSection />
<ProfileSection user={user} />
</>
) : null}
{section === "profile" ? <ProfileSection user={user} /> : null}
{section === "quality" ? <QualitySection user={user} /> : null}
{section === "library" && isAdmin ? <LibrarySection /> : null}
{section === "users" && isAdmin && allUsers ? (
@@ -169,32 +160,6 @@ export default function SettingsScreen() {
)
}
function AppearanceSection() {
const enabled = useArtworkColorsEnabled()
const [saving, setSaving] = useState(false)
return (
<SettingsCard title="Appearance">
<SwitchRow
title="New artwork colors"
subtitle="Use the new color algorithm on this device."
value={enabled ?? false}
disabled={enabled === undefined || saving}
onValueChange={async (checked) => {
setSaving(true)
try {
await setArtworkColorsEnabled(checked)
} catch {
showError("Could not save artwork colors preference.")
} finally {
setSaving(false)
}
}}
/>
</SettingsCard>
)
}
function ProfileSection({ user }: { user: CurrentUser }) {
const colors = useThemeColors()
const updateName = useMutation(api.users.updateProfileName)
@@ -0,0 +1 @@
export { default } from "../home/queue"
@@ -0,0 +1 @@
export { default } from "../home/queue"
+8 -18
View File
@@ -39,12 +39,11 @@ 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,
} from "@/components/now-playing-queue"
import { PlayerArtistMenu } from "@/components/player-artist-menu"
import { PlayerSlider } from "@/components/player-slider"
import { PlayerSymbol } from "@/components/player-symbol"
import { useFavorites } from "@/contexts/favorites"
@@ -545,15 +544,13 @@ function SongMeta({
{ color: colors.foreground },
]}
/>
<PlayerArtistMenu song={song} onAction={handleAction}>
<MarqueeText
text={song.artist.name}
style={[
compact ? styles.compactArtist : styles.artist,
{ color: colors.secondaryForeground },
]}
/>
</PlayerArtistMenu>
<MarqueeText
text={song.artist.name}
style={[
compact ? styles.compactArtist : styles.artist,
{ color: colors.secondaryForeground },
]}
/>
</View>
<Pressable
onPress={() => void toggleSongFavorite(song.id)}
@@ -570,12 +567,6 @@ function SongMeta({
/>
</Pressable>
<MediaActionMenu
share={{
type: "song",
songId: song.id,
albumId: song.album.id,
title: song.title,
}}
stationArtistId={song.artist.id}
favorited={favorited}
navigation={{
@@ -583,7 +574,6 @@ function SongMeta({
album: { id: song.album.id },
}}
includeActions={[
"share",
"play-next",
"play-last",
"shuffle",
@@ -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"
-13
View File
@@ -94,13 +94,6 @@ export const AlbumCard = memo(function AlbumCard({
return (
<MediaContextMenu
preview={{
kind: "album",
title: album.title,
artist: album.artist.name,
artworkUrl: albumCoverUrl(config.serverUrl, album.id),
hasArtwork: album.cover != null,
}}
favorited={isAlbumFavorite(album.id)}
stationArtistId={album.artist.id}
navigation={{ artist: { id: album.artist.id } }}
@@ -156,12 +149,6 @@ export const ArtistCard = memo(function ArtistCard({
return (
<MediaContextMenu
preview={{
kind: "artist",
title: artist.name,
artworkUrl: artistCoverUrl(config.serverUrl, artist.id),
hasArtwork: artist.photo != null,
}}
favorited={isArtistFavorite(artist.id)}
share={{ type: "artist", artistId: artist.id, title: artist.name }}
onAction={(action) => void handleArtistAction(artist, action)}
+4 -119
View File
@@ -4,19 +4,12 @@ import { requireNativeView } from "expo"
import type { ComponentType, ReactNode } from "react"
import {
Platform,
Text,
useWindowDimensions,
View,
type StyleProp,
type ViewProps,
type ViewStyle,
} from "react-native"
import { Ionicons } from "@expo/vector-icons"
import { CoverImage } from "@/components/cover-image"
import { useThemeColors } from "@/lib/theme"
import { useAppNavigation } from "@/lib/app-navigation"
import { useServerConfig } from "@/contexts/server-config"
import type { MediaShareContext } from "@/lib/media-links"
import { shouldShowShare } from "@/lib/media-links"
@@ -39,17 +32,7 @@ export type MediaNavigation = {
album?: { id: string }
}
export type MediaMenuPreview = {
title: string
artist?: string
album?: string
artworkUrl: string
hasArtwork: boolean
kind: "album" | "artist" | "song"
}
export type MediaMenuConfig = {
preview?: MediaMenuPreview
selectedCount?: number
playlistLabel?: string
favorited?: boolean
@@ -106,12 +89,12 @@ const MEDIA_ACTION_ITEMS: {
{
action: "go-artist",
label: () => "Go to Artist",
image: "music.mic",
image: "person",
},
{
action: "go-album",
label: () => "Go to Album",
image: "square.stack",
image: "opticaldisc",
},
{
action: "favorite",
@@ -231,95 +214,10 @@ function MediaMenuBase({
const NativeContextMenuView =
Platform.OS === "ios"
? requireNativeView<
ViewProps & {
disableForceFlatten?: boolean
children: ReactNode
onPreviewTappedAnimationCompleted?: () => void
}
ViewProps & { disableForceFlatten?: boolean; children: ReactNode }
>("ExpoRouterNativeLinkPreview", "NativeLinkPreviewView")
: null
const NativeContextMenuPreview =
Platform.OS === "ios"
? requireNativeView<
ViewProps & {
preferredContentSize: { width: number; height: number }
children: ReactNode
}
>("ExpoRouterNativeLinkPreview", "NativeLinkPreviewContentView")
: null
function MediaPreview({ preview }: { preview: MediaMenuPreview }) {
const colors = useThemeColors()
const { width: windowWidth, fontScale } = useWindowDimensions()
if (!NativeContextMenuPreview) return null
const width = Math.min(360, windowWidth - 32)
const height = Math.max(124, 32 + 76 * fontScale)
const isArtist = preview.kind === "artist"
return (
// Match Expo Router's preview wrapper: UIKit mounts this separately, but
// Yoga must also keep it out of the trigger's normal layout.
<NativeContextMenuPreview
preferredContentSize={{ width, height }}
style={{ position: "absolute", top: 0, left: 0 }}
>
<View
style={{
width,
height,
padding: 16,
flexDirection: "row",
alignItems: "center",
gap: 16,
backgroundColor: colors.card,
}}
>
<CoverImage
uri={preview.artworkUrl}
hasCover={preview.hasArtwork}
style={{ width: 88, height: 88, borderRadius: isArtist ? 44 : 12 }}
/>
<View style={{ flex: 1, gap: 2 }}>
<Text
numberOfLines={2}
style={{
color: colors.foreground,
fontSize: 17,
fontWeight: "600",
}}
>
{preview.title}
</Text>
{preview.artist ? (
<Text
numberOfLines={1}
style={{ color: colors.mutedForeground, fontSize: 15 }}
>
{preview.artist}
</Text>
) : null}
{preview.album ? (
<Text
numberOfLines={1}
style={{ color: colors.mutedForeground, fontSize: 14 }}
>
{preview.album}
</Text>
) : null}
</View>
{preview.kind !== "song" ? (
<Ionicons
name="chevron-forward"
size={20}
color={colors.mutedForeground}
/>
) : null}
</View>
</NativeContextMenuPreview>
)
}
const NativeContextMenuAction: ComponentType<{
identifier: string
title: string
@@ -335,13 +233,11 @@ const NativeContextMenuAction: ComponentType<{
function NativeMediaContextMenu({
children,
preview,
onAction,
share,
...actionConfig
}: MediaMenuWrapperProps) {
const { config } = useServerConfig()
const { push } = useAppNavigation()
if (!NativeContextMenuView || !NativeContextMenuAction) {
return children
@@ -356,21 +252,10 @@ function NativeMediaContextMenu({
}
return (
<NativeContextMenuView
style={{ display: "contents" }}
disableForceFlatten
onPreviewTappedAnimationCompleted={() => {
if (share?.type === "artist") push(`/artist/${share.artistId}`)
else if (share?.type === "album" || share?.type === "song")
push(`/album/${share.albumId}`)
}}
>
<NativeContextMenuView style={{ display: "contents" }} disableForceFlatten>
{/* The native menu retains its first trigger. Keep that view mounted when
focus changes replace the Siri entity wrapper inside it. */}
<View collapsable={false}>{children}</View>
{preview && (actionConfig.selectedCount ?? 1) === 1 ? (
<MediaPreview preview={preview} />
) : null}
{buildMediaMenuActions({ ...actionConfig, share }).map((action) => (
<NativeContextMenuAction
key={action.id}
-45
View File
@@ -1,45 +0,0 @@
import type { MenuComponentProps } from "@expo/ui/community/menu"
import { Button, Host, Menu, RNHostView } from "@expo/ui/swift-ui"
import { disabled, menuOrder } from "@expo/ui/swift-ui/modifiers"
// SwiftUI's automatic order reverses menus that open upward in the player.
// Keep the same top-to-bottom order as the UIKit long-press menus.
export function MenuView({
actions,
children,
style,
testID,
onPressAction,
}: MenuComponentProps) {
return (
<Host matchContents style={style} testID={testID} ignoreSafeArea="all">
<Menu
modifiers={[menuOrder("fixed")]}
label={
<RNHostView matchContents>
<>{children}</>
</RNHostView>
}
>
{actions
.filter((action) => !action.attributes?.hidden)
.map((action) => (
<Button
key={action.id ?? action.title}
label={action.title}
systemImage={
typeof action.image === "string" ? action.image : undefined
}
role={action.attributes?.destructive ? "destructive" : undefined}
modifiers={[disabled(action.attributes?.disabled ?? false)]}
onPress={() =>
onPressAction?.({
nativeEvent: { event: action.id ?? action.title },
})
}
/>
))}
</Menu>
</Host>
)
}
@@ -1,56 +0,0 @@
import { useState, type ReactNode } from "react"
import { StyleSheet, View } from "react-native"
import {
MediaActionMenu,
type MediaAction,
} from "@/components/media-context-menu"
import type { BrowseSong } from "@otunes/convex/types"
export function PlayerArtistMenu({
song,
onAction,
children,
}: {
song: BrowseSong
onAction: (action: MediaAction) => void
children: ReactNode
}) {
const [size, setSize] = useState({ width: 0, height: 0 })
return (
<View
style={styles.container}
onLayout={({ nativeEvent: { layout } }) =>
setSize({ width: layout.width, height: layout.height })
}
>
<View
pointerEvents="none"
accessibilityElementsHidden
importantForAccessibility="no-hide-descendants"
>
{children}
</View>
{size.width > 0 ? (
<MediaActionMenu
style={StyleSheet.absoluteFill}
includeActions={["go-album", "go-artist"]}
onAction={onAction}
>
<View
style={size}
accessible
accessibilityRole="button"
accessibilityLabel={song.artist.name}
accessibilityHint="Opens album and artist options"
/>
</MediaActionMenu>
) : null}
</View>
)
}
const styles = StyleSheet.create({
container: { overflow: "hidden" },
})
+8 -60
View File
@@ -1,5 +1,3 @@
import { SongSwipeRow } from "@/components/song-swipe-row"
import type { SwipeRowGroup } from "@/components/ios-swipe-to-remove-row"
import { PaletteText } from "@/components/palette-text"
import { MusicEntityView } from "@/components/music-entity-view"
import { collectionInset } from "@/components/collection-list"
@@ -24,8 +22,6 @@ import {
type MediaMenuConfig,
} from "@/components/media-context-menu"
function consumeLongPress() {}
export const SongRow = memo(function SongRow({
song,
onPress,
@@ -33,7 +29,6 @@ export const SongRow = memo(function SongRow({
trailing,
palette,
inset = false,
swipe,
}: {
song: BrowseSong
onPress?: () => void
@@ -42,13 +37,6 @@ export const SongRow = memo(function SongRow({
}
trailing?: React.ReactNode
palette?: Pick<CoverPalette, "foreground" | "secondaryForeground" | "divider">
swipe?: {
group: SwipeRowGroup
onPlayNext: () => void
onAddToQueue: () => void
onRemove?: () => void
backgroundColor: string
}
/** Album/playlist layout: the divider starts at the title, not the artwork. */
inset?: boolean
}) {
@@ -89,8 +77,13 @@ export const SongRow = memo(function SongRow({
</>
)
const rowContent = (
<>
const row = (
<Pressable
style={
inset ? styles.insetRow : [styles.row, { borderBottomColor: divider }]
}
onPress={onPress}
>
<CoverImage
uri={albumCoverUrl(config.serverUrl, song.album.id)}
hasCover={song.album.cover != null}
@@ -103,33 +96,8 @@ export const SongRow = memo(function SongRow({
) : (
content
)}
</>
</Pressable>
)
const rowStyle = inset
? styles.insetRow
: [styles.row, { borderBottomColor: divider }]
const row =
swipe && Platform.OS !== "web" ? (
<SongSwipeRow
group={swipe.group}
onPlayNext={swipe.onPlayNext}
onAddToQueue={swipe.onAddToQueue}
onRemove={swipe.onRemove}
backgroundColor={swipe.backgroundColor}
onPress={onPress}
style={rowStyle}
>
{rowContent}
</SongSwipeRow>
) : (
<Pressable
style={rowStyle}
onPress={onPress}
onLongPress={contextMenu ? consumeLongPress : undefined}
>
{rowContent}
</Pressable>
)
if (!contextMenu) {
return (
@@ -159,7 +127,6 @@ export const SongListRow = memo(function SongListRow({
playlistLabel,
palette,
inset,
swipe,
onPlay,
onAction,
}: {
@@ -168,17 +135,9 @@ export const SongListRow = memo(function SongListRow({
playlistLabel?: string
palette?: Pick<CoverPalette, "foreground" | "secondaryForeground" | "divider">
inset?: boolean
swipe?: {
group: SwipeRowGroup
onPlayNext: () => void
onAddToQueue: () => void
onRemove?: () => void
backgroundColor: string
}
onPlay: (song: BrowseSong) => void
onAction: (song: BrowseSong, action: MediaAction) => void
}) {
const { config } = useServerConfig()
const handlePress = useCallback(() => onPlay(song), [onPlay, song])
return (
@@ -186,19 +145,8 @@ export const SongListRow = memo(function SongListRow({
song={song}
palette={palette}
inset={inset}
swipe={swipe}
onPress={handlePress}
contextMenu={{
preview: config
? {
kind: "song",
title: song.title,
artist: song.artist.name,
album: song.album.title,
artworkUrl: albumCoverUrl(config.serverUrl, song.album.id),
hasArtwork: song.album.cover != null,
}
: undefined,
stationArtistId: song.artist.id,
favorited,
playlistLabel,
-461
View File
@@ -1,461 +0,0 @@
import { Ionicons } from "@expo/vector-icons"
import * as Haptics from "expo-haptics"
import { SymbolView } from "expo-symbols"
import {
useCallback,
useEffect,
useMemo,
useState,
type ReactNode,
} from "react"
import {
Platform,
Pressable,
StyleSheet,
type StyleProp,
type ViewStyle,
} from "react-native"
import { Gesture, GestureDetector } from "react-native-gesture-handler"
import Animated, {
type SharedValue,
cancelAnimation,
Extrapolation,
interpolate,
useAnimatedStyle,
useSharedValue,
withSpring,
} from "react-native-reanimated"
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() {
void Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium)
}
/** A tap competes with the swipe so dragging a moving row never starts playback. */
export function SongSwipeRow({
children,
style,
backgroundColor,
group,
onPress,
onPlayNext,
onAddToQueue,
onRemove,
}: {
children: ReactNode
style?: StyleProp<ViewStyle>
backgroundColor: string
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)
const height = useSharedValue(0)
const committed = useSharedValue(false)
const commitProgress = useSharedValue(0)
const [open, setOpen] = useState<-1 | 0 | 1>(0)
const close = useCallback(() => {
x.value = withSpring(0, SPRING)
committed.value = false
commitProgress.value = withSpring(0, SPRING)
setOpen(0)
group.clear(close)
}, [commitProgress, committed, group, x])
useEffect(() => () => group.clear(close), [close, group])
const begin = useCallback(() => group.setOpen(close), [close, group])
const settle = useCallback(
(side: -1 | 0 | 1) => {
setOpen(side)
if (!side) group.clear(close)
},
[close, group]
)
const activate = useCallback(
(side: number) => {
close()
if (side > 0) onAddToQueue()
// Download is intentionally a placeholder.
},
[close, onAddToQueue]
)
const tapRow = useCallback(() => {
if (open) close()
else onPress?.()
}, [close, onPress, open])
const gesture = useMemo(() => {
const pan = Gesture.Pan()
// Leave the screen's leading edge available for native back navigation.
.hitSlop({ left: -24 })
.activeOffsetX([-10, 10])
.failOffsetY([-10, 10])
.onStart(() => {
cancelAnimation(x)
startX.value = x.value
scheduleOnRN(begin)
})
.onUpdate((event) => {
x.value = Math.max(
-width.value,
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
)
if (commit !== committed.value) {
committed.value = commit
commitProgress.value = withSpring(commit ? 1 : 0, SPRING)
scheduleOnRN(impact)
}
})
.onEnd((event) => {
const side = x.value > 0 ? 1 : -1
if (committed.value) {
x.value = withSpring(0, SPRING)
scheduleOnRN(activate, side)
return
}
const projected = x.value + event.velocityX * 0.12
const target =
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,
}
)
scheduleOnRN(settle, target)
})
.onFinalize((_event, success) => {
if (!success) {
x.value = withSpring(0, SPRING)
scheduleOnRN(close)
}
})
const tap = Gesture.Tap()
.maxDistance(10)
.maxDuration(500)
.onEnd((_event, success) => {
if (success) scheduleOnRN(tapRow)
})
return Gesture.Exclusive(pan, tap)
}, [
activate,
hasRemove,
begin,
close,
commitProgress,
committed,
settle,
startX,
tapRow,
width,
x,
])
const rowStyle = useAnimatedStyle(() => ({
transform: [{ translateX: x.value }],
borderRadius: IS_ANDROID
? 0
: interpolate(
Math.abs(x.value),
[0, 40],
[0, height.value / 2],
Extrapolation.CLAMP
),
}))
const fillStyle = useAnimatedStyle(() => ({
opacity: interpolate(
Math.abs(x.value),
[0, 40],
[0, 1],
Extrapolation.CLAMP
),
}))
return (
<Animated.View
style={styles.container}
onLayout={(event) => {
width.value = event.nativeEvent.layout.width
height.value = event.nativeEvent.layout.height
}}
>
<SwipeAction
side={1}
x={x}
height={height}
progress={commitProgress}
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}
open={open === -1}
onPress={() => activate(-1)}
/>
<GestureDetector gesture={gesture}>
<Animated.View
accessible
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()
}
}}
style={[styles.row, { backgroundColor }, rowStyle]}
>
<Animated.View
pointerEvents="none"
style={[StyleSheet.absoluteFill, styles.fill, fillStyle]}
/>
<Animated.View style={style}>{children}</Animated.View>
</Animated.View>
</GestureDetector>
</Animated.View>
)
}
function SwipeAction({
side,
secondary = false,
paired = side > 0,
remove = false,
x,
height,
progress,
open,
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 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 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]
)
)
)
const pillWidth =
resting + (Math.max(0, revealed - 12) - resting) * progress.value
const restingHeight = interpolate(
pillWidth,
[0, 24, 62, 140, 200],
[0, 0.3, 0.77, 0.82, 0.86].map((ratio) => ratio * height.value),
Extrapolation.CLAMP
)
const pillHeight =
restingHeight +
(Math.max(0, height.value - 12) - restingHeight) * progress.value
return {
width: pillWidth,
height: pillHeight,
borderRadius: pillHeight / 2,
}
})
const iconStyle = useAnimatedStyle(() => ({
transform: [
{
scale: interpolate(
x.value * side,
[24, 64],
[0, 1],
Extrapolation.CLAMP
),
},
],
}))
return (
<Animated.View
pointerEvents={open ? "auto" : "none"}
accessibilityElementsHidden={!open}
importantForAccessibility={open ? "auto" : "no-hide-descendants"}
style={[
styles.action,
side > 0 ? styles.leading : styles.trailing,
actionStyle,
]}
>
<Pressable
accessibilityRole="button"
accessibilityLabel={
remove
? "Remove from Playlist"
: side > 0
? secondary
? "Play Next"
: "Add to Queue"
: "Download"
}
onPress={onPress}
style={styles.actionButton}
>
<Animated.View
style={[
styles.pill,
{
backgroundColor: remove
? "#d32f2f"
: side > 0
? secondary
? "#6b5bff"
: "#f29943"
: "#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"
/>
)}
</Animated.View>
</Animated.View>
</Pressable>
</Animated.View>
)
}
const styles = StyleSheet.create({
container: { overflow: "hidden" },
row: { overflow: "hidden" },
fill: { backgroundColor: "rgba(128,128,128,0.16)" },
action: { position: "absolute", top: 0, bottom: 0 },
leading: { left: 0 },
trailing: { right: 0 },
actionButton: { flex: 1, alignItems: "center", justifyContent: "center" },
pill: { alignItems: "center", justifyContent: "center", overflow: "hidden" },
})
@@ -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"
+6 -8
View File
@@ -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
}
+3 -11
View File
@@ -376,8 +376,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
const handlePlaylistStatusUpdate = useCallback(
(status: AudioPlaylistStatus) => {
// iOS may remove the finished item before delivering its final status.
if (!status.isLoaded && !status.didJustFinish) return
if (!status.isLoaded) return
const state = storeRef.current.getState()
if (loadedSongIdsRef.current[status.currentIndex] !== state.queue[0]) {
return
@@ -428,14 +427,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
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.
ignoreTrackChangeRef.current = true
playlist.skipTo(status.currentIndex)
scheduleTrackChangeHandling()
}
void playlistRef.current?.seekTo(0)
currentTimeRef.current = 0
setCurrentTime(0)
return
@@ -451,7 +443,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
playlist?.play()
}
},
[scheduleTrackChangeHandling]
[]
)
const handleTrackChanged = useCallback(
-142
View File
@@ -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)
}
+166 -34
View File
@@ -1,47 +1,179 @@
import {
createCoverPaletteSource,
type CoverPaletteResult,
} from "@/hooks/cover-palette-source"
import {
prefetchLegacyCoverPalette,
useLegacyCoverPalette,
} from "@/hooks/use-legacy-cover-palette"
import {
loadArtworkColorsEnabled,
useArtworkColorsEnabled,
} from "@/lib/artwork-color-preference"
import { extractCoverSwatches } from "@/lib/artwork-colors"
import { deriveCoverPalette, type CoverSwatches } from "@/lib/cover-palette"
import { useEffect, useMemo, useState } from "react"
import { getColors, type ImageColorsResult } from "react-native-image-colors"
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
/** 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)
// 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
)
}
function toSwatches(result: ImageColorsResult): CoverSwatches | null {
if (result.platform === "ios") {
const text = present([result.primary, result.secondary, result.detail])
return result.background.toLowerCase() === MISSING
? null
: { background: result.background, text, accent: text }
}
const background = present([result.dominant, result.muted])[0]
if (!background) return null
return {
background,
text: present([
result.lightVibrant,
result.lightMuted,
result.darkVibrant,
result.darkMuted,
result.vibrant,
result.muted,
]),
accent: present([
result.vibrant,
result.lightVibrant,
result.darkVibrant,
result.muted,
]),
}
}
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.
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 function prefetchCoverPalette(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, 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(
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, isDark)
: null
return fromArt ?? themeCoverPalette(theme, isDark)
}, [hasCover, isDark, swatches, theme])
return {
palette,
settled:
!key || hasCover === false || swatches !== undefined || waitedKey === key,
}
return enabled ? current : legacy
}
@@ -1,67 +0,0 @@
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"
// image-colors substitutes this for swatches it couldn't find.
const MISSING = "#010203"
function present(colors: (string | undefined)[]) {
return colors.filter(
(color): color is string => !!color && color.toLowerCase() !== MISSING
)
}
function toSwatches(result: ImageColorsResult): CoverSwatches | null {
if (result.platform === "ios") {
const text = present([result.primary, result.secondary, result.detail])
return result.background.toLowerCase() === MISSING
? null
: { background: result.background, text, accent: text }
}
const background = present([result.dominant, result.muted])[0]
if (!background) return null
return {
background,
text: present([
result.lightVibrant,
result.lightMuted,
result.darkVibrant,
result.darkMuted,
result.vibrant,
result.muted,
]),
accent: present([
result.vibrant,
result.lightVibrant,
result.darkVibrant,
result.muted,
]),
}
}
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,
// Discard the background-only entries written by the tablet palette experiment.
isValidCache: (cached) =>
Array.isArray(cached.text) && Array.isArray(cached.accent),
})
/** Warm visible artwork colors before a detail page is pushed. */
export const prefetchLegacyCoverPalette = legacy.prefetch
/** `react-native-image-colors` pipeline used when new artwork colors are off. */
export const useLegacyCoverPalette = legacy.usePalette
@@ -1,57 +0,0 @@
import AsyncStorage from "@react-native-async-storage/async-storage"
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 loading: Promise<void> | undefined
function notify() {
for (const listener of listeners) listener()
}
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
notify()
}))
}
void load()
function subscribe(listener: () => void) {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
}
/**
* Device preference, kept outside account data and the disposable query cache.
* `undefined` until it has loaded.
*/
export function useArtworkColorsEnabled() {
return useSyncExternalStore(
subscribe,
() => enabled,
() => undefined
)
}
/** Resolves with the preference once it has loaded. */
export async function loadArtworkColorsEnabled() {
await load()
return enabled ?? true
}
export async function setArtworkColorsEnabled(value: boolean) {
await load()
await AsyncStorage.setItem(STORAGE_KEY, String(value))
enabled = value
notify()
}
-11
View File
@@ -1,11 +0,0 @@
import { requireNativeModule } from "expo"
import { swatchesFromHistogram, type ColorBin } from "./color-histogram"
const native = requireNativeModule<{
histogram(uri: string): Promise<ColorBin[]>
}>("ArtworkColors")
export async function extractCoverSwatches(uri: string) {
return swatchesFromHistogram(await native.histogram(uri))
}
-29
View File
@@ -1,29 +0,0 @@
import { getColors } from "react-native-image-colors"
import type { CoverSwatches } from "./cover-palette"
const MISSING = "#010203"
/** Android and web retain their platform quantizers; iOS uses the sRGB histogram. */
export async function extractCoverSwatches(
uri: string
): Promise<CoverSwatches | null> {
const result = await getColors(uri, {
fallback: MISSING,
cache: true,
key: uri,
quality: "low",
pixelSpacing: 4,
})
if (result.platform === "ios") return null
const background = [result.dominant, result.muted].find(
(color) => color && color.toLowerCase() !== MISSING
)
if (!background) return null
return {
background,
...(result.platform === "android" &&
result.average.toLowerCase() !== MISSING
? { average: result.average }
: {}),
}
}
-55
View File
@@ -1,55 +0,0 @@
const { test } = require("node:test")
const assert = require("node:assert/strict")
const fs = require("node:fs")
const ts = require("typescript")
const compiled = ts.transpileModule(
fs.readFileSync(`${__dirname}/color-histogram.ts`, "utf8"),
{
compilerOptions: {
module: ts.ModuleKind.CommonJS,
target: ts.ScriptTarget.ES2022,
},
}
).outputText
const loaded = { exports: {} }
new Function("exports", compiled)(loaded.exports)
const { swatchesFromHistogram } = loaded.exports
test("a noisy background outranks a smaller flat logo, independent of bin order", () => {
const background = Array.from({ length: 30 }, (_, i) => [
30 + i,
110 + i,
30 + i,
100,
])
const bins = [...background, [240, 10, 10, 500]]
const palette = swatchesFromHistogram(bins)
assert.equal(palette.background, "#2d7d2d")
assert.ok(palette.dominantFraction > 0.85)
assert.deepEqual(palette, swatchesFromHistogram([...bins].reverse()))
})
test("dominant black stays black beside white and a saturated accent", () => {
const palette = swatchesFromHistogram([
[0, 0, 0, 60],
[255, 255, 255, 30],
[140, 200, 50, 10],
])
assert.equal(palette.background, "#000000")
assert.equal(palette.darkFraction, 0.6)
assert.equal(palette.dominantFraction, 0.6)
})
test("empty and invalid histograms cannot produce NaN colors", () => {
assert.equal(swatchesFromHistogram([]), null)
assert.equal(
swatchesFromHistogram([
[NaN, 0, 0, 1],
[256, 0, 0, 1],
[0, 0, 0, 0],
]),
null
)
assert.equal(swatchesFromHistogram([[80, 100, 120, 4]]).background, "#506478")
})
-162
View File
@@ -1,162 +0,0 @@
import type { CoverSwatches } from "./cover-palette"
type Rgb = [number, number, number]
export type ColorBin = [red: number, green: number, blue: number, count: number]
type Cluster = { rgb: Rgb; lab: Rgb; count: number }
function lab([r, g, b]: Rgb): Rgb {
const linear = (v: number) =>
v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4
const red = linear(r / 255)
const green = linear(g / 255)
const blue = linear(b / 255)
const l = Math.cbrt(
0.4122214708 * red + 0.5363325363 * green + 0.0514459929 * blue
)
const m = Math.cbrt(
0.2119034982 * red + 0.6806995451 * green + 0.1073969566 * blue
)
const s = Math.cbrt(
0.0883024619 * red + 0.2817188376 * green + 0.6299787005 * blue
)
return [
0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
]
}
function distance(a: Rgb, b: Rgb) {
return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 + (a[2] - b[2]) ** 2
}
function hex(rgb: Rgb) {
return `#${rgb.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`
}
/** Group nearby colors by perceived distance, retaining black and white regions. */
export function swatchesFromHistogram(bins: ColorBin[]): CoverSwatches | null {
const samples: Cluster[] = bins
.filter(
(bin) =>
bin.length === 4 &&
bin.every(Number.isFinite) &&
bin[3] > 0 &&
bin.slice(0, 3).every((v) => v >= 0 && v <= 255)
)
.map<Cluster>(([r, g, b, count]) => ({
rgb: [r, g, b],
lab: lab([r, g, b]),
count,
}))
.sort(
(a, b) =>
b.count - a.count ||
a.rgb[0] - b.rgb[0] ||
a.rgb[1] - b.rgb[1] ||
a.rgb[2] - b.rgb[2]
)
if (!samples.length) return null
const centers = [samples[0].lab]
// Deterministic weighted seeding avoids random palette changes between launches.
while (centers.length < Math.min(8, samples.length)) {
let candidate = samples[0]
let best = 0
for (const sample of samples) {
const score =
Math.min(...centers.map((center) => distance(sample.lab, center))) *
sample.count
if (score > best) {
candidate = sample
best = score
}
}
if (best === 0) break
centers.push(candidate.lab)
}
let clusters: Cluster[] = []
for (let iteration = 0; iteration < 12; iteration++) {
clusters = centers.map(() => ({ rgb: [0, 0, 0], lab: [0, 0, 0], count: 0 }))
for (const sample of samples) {
let nearest = 0
for (let index = 1; index < centers.length; index++) {
if (
distance(sample.lab, centers[index]) <
distance(sample.lab, centers[nearest])
)
nearest = index
}
const cluster = clusters[nearest]
cluster.count += sample.count
for (let channel = 0; channel < 3; channel++) {
cluster.rgb[channel] += sample.rgb[channel] * sample.count
cluster.lab[channel] += sample.lab[channel] * sample.count
}
}
let movement = 0
clusters.forEach((cluster, index) => {
if (!cluster.count) return
for (let channel = 0; channel < 3; channel++) {
cluster.rgb[channel] /= cluster.count
cluster.lab[channel] /= cluster.count
}
movement += distance(centers[index], cluster.lab)
centers[index] = cluster.lab
})
if (movement < 0.000001) break
}
// K-means can divide a textured region across several centers. Combine those
// centers before ranking coverage so a small flat logo cannot outrank it.
clusters = clusters.filter((cluster) => cluster.count > 0)
while (clusters.length > 1) {
let pair: [number, number] | undefined
let closest = 0.06 ** 2
for (let a = 0; a < clusters.length; a++) {
for (let b = a + 1; b < clusters.length; b++) {
const separation = distance(clusters[a].lab, clusters[b].lab)
if (separation < closest) {
closest = separation
pair = [a, b]
}
}
}
if (!pair) break
const [a, b] = pair
const first = clusters[a]
const second = clusters[b]
const count = first.count + second.count
for (let channel = 0; channel < 3; channel++) {
first.rgb[channel] =
(first.rgb[channel] * first.count +
second.rgb[channel] * second.count) /
count
first.lab[channel] =
(first.lab[channel] * first.count +
second.lab[channel] * second.count) /
count
}
first.count = count
clusters.splice(b, 1)
}
const total = samples.reduce((sum, sample) => sum + sample.count, 0)
const average: Rgb = [0, 0, 0]
for (const sample of samples) {
for (let channel = 0; channel < 3; channel++)
average[channel] += (sample.rgb[channel] * sample.count) / total
}
clusters.sort((a, b) => b.count - a.count)
return {
background: hex(clusters[0].rgb),
average: hex(average),
dominantFraction: clusters[0].count / total,
darkFraction:
samples.reduce(
(sum, sample) => sum + (sample.lab[0] < 0.3 ? sample.count : 0),
0
) / total,
}
}
-32
View File
@@ -1,32 +0,0 @@
type Color = [number, number, number]
/** Convert sRGB byte values to Oklab without quantizing intermediate colors. */
export function toOklab(rgb: Color): Color {
const [r, g, b] = rgb.map((byte) => {
const v = byte / 255
return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4
})
const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b)
const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b)
const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b)
return [
0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
]
}
/** Map an Oklab color back into the display's sRGB gamut. */
export function fromOklab([L, a, b]: Color): Color {
const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3
const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3
const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3
return [
4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
].map((v) => {
const encoded = v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055
return Math.round(Math.max(0, Math.min(1, encoded)) * 255)
}) as Color
}
-50
View File
@@ -1,50 +0,0 @@
// Measurement targets belong here and in the fixture, never in palette derivation.
const fs = require("node:fs")
const ts = require("typescript")
const references = require("./cover-palette.references.json")
function load(name) {
const exports = {}
const code = ts.transpileModule(
fs.readFileSync(`${__dirname}/${name}.ts`, "utf8"),
{
compilerOptions: {
module: ts.ModuleKind.CommonJS,
target: ts.ScriptTarget.ES2022,
},
}
).outputText
new Function("exports", "require", code)(exports, (name) =>
load(name.replace("./", ""))
)
return exports
}
const { deriveCoverPalette } = load("cover-palette")
const rgb = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16))
const measurements = references.map(
({ label, swatches, expectedBackground }) => {
const actual = deriveCoverPalette(swatches).background
const errors = rgb(actual).map((v, i) =>
Math.abs(v - rgb(expectedBackground)[i])
)
return {
label,
expectedBackground,
actual,
maxChannelError: Math.max(...errors),
squaredError: errors.reduce((s, v) => s + v * v, 0),
}
}
)
console.table(measurements.map(({ squaredError, ...row }) => row))
console.log(
"RGB RMSE:",
Math.sqrt(
measurements.reduce((s, r) => s + r.squaredError, 0) /
(measurements.length * 3)
)
)
if (
process.argv.includes("--exact") &&
measurements.some((row) => row.maxChannelError !== 0)
)
process.exitCode = 1
@@ -1,92 +0,0 @@
[
{
"label": "wicked-soundtrack",
"swatches": {
"background": "#4f4e33",
"average": "#74664d",
"dominantFraction": 0.184814453125,
"darkFraction": 0.195556640625
},
"expectedBackground": "#1a1c0e"
},
{
"label": "wicked-broadway",
"swatches": {
"background": "#030605",
"average": "#74786c",
"dominantFraction": 0.423828125,
"darkFraction": 0.43798828125
},
"expectedBackground": "#111111"
},
{
"label": "prince-of-egypt",
"swatches": {
"background": "#16101f",
"average": "#584546",
"dominantFraction": 0.585693359375,
"darkFraction": 0.587158203125
},
"expectedBackground": "#191718"
},
{
"label": "civilization-vi",
"swatches": {
"background": "#ccaf90",
"average": "#b79e80",
"dominantFraction": 0.20703125,
"darkFraction": 0.001220703125
},
"expectedBackground": "#3f280c"
},
{
"label": "ramblin-rover",
"swatches": {
"background": "#457522",
"average": "#548133",
"dominantFraction": 0.7802734375,
"darkFraction": 0
},
"expectedBackground": "#0e3900"
},
{
"label": "cavalry",
"swatches": {
"background": "#0d131f",
"average": "#404954",
"dominantFraction": 0.317138671875,
"darkFraction": 0.38623046875
},
"expectedBackground": "#151d2f"
},
{
"label": "city-of-angels",
"swatches": {
"background": "#1895cb",
"average": "#6c7c8b",
"dominantFraction": 0.241943359375,
"darkFraction": 0.075927734375
},
"expectedBackground": "#003262"
},
{
"label": "we-the-kings",
"swatches": {
"background": "#ab3a33",
"average": "#923b32",
"dominantFraction": 0.577880859375,
"darkFraction": 0.16552734375
},
"expectedBackground": "#52170d"
},
{
"label": "counter-strike-2",
"swatches": {
"background": "#060404",
"average": "#786757",
"dominantFraction": 0.35693359375,
"darkFraction": 0.390625
},
"expectedBackground": "#251211"
}
]
-54
View File
@@ -1,54 +0,0 @@
const { test } = require("node:test")
const assert = require("node:assert/strict")
const fs = require("node:fs")
const ts = require("typescript")
function load(name) {
const exports = {}
new Function(
"exports",
"require",
ts.transpileModule(fs.readFileSync(`${__dirname}/${name}.ts`, "utf8"), {
compilerOptions: {
module: ts.ModuleKind.CommonJS,
target: ts.ScriptTarget.ES2022,
},
}).outputText
)(exports, (name) => load(name.replace("./", "")))
return exports
}
const { deriveCoverPalette } = load("cover-palette")
const { toOklab, fromOklab } = load("color-space")
test("sRGB and Oklab conversions round trip across the display gamut", () => {
for (const r of [0, 16, 64, 128, 192, 255])
for (const g of [0, 16, 64, 128, 192, 255])
for (const b of [0, 16, 64, 128, 192, 255])
assert.deepEqual(fromOklab(toOklab([r, g, b])), [r, g, b])
})
test("near-black neutral artwork does not amplify arbitrary channel noise", () => {
for (const background of ["#000000", "#030605", "#050303"]) {
const palette = deriveCoverPalette({ background, average: "#747474" })
assert.equal(palette.background, "#111111")
assert.equal(palette.foreground, "#FFFFFF")
}
})
test("a conflicting shadow hue is muted while coherent dark blue retains its color", () => {
const shadow = deriveCoverPalette({
background: "#16101f",
average: "#584546",
dominantFraction: 0.59,
darkFraction: 0.59,
})
const blue = deriveCoverPalette({
background: "#0d131f",
average: "#404954",
dominantFraction: 0.32,
darkFraction: 0.39,
})
const rgb = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16))
const shadowRgb = rgb(shadow.background),
blueRgb = rgb(blue.background)
assert.ok(Math.max(...shadowRgb) - Math.min(...shadowRgb) <= 4)
assert.ok(blueRgb[2] - blueRgb[0] > 15)
assert.equal(deriveCoverPalette({ background: "invalid" }), null)
})
+237 -74
View File
@@ -1,5 +1,4 @@
import type { ThemeColors } from "@/lib/theme"
import { toOklab, fromOklab } from "./color-space"
/**
* Colors for a screen tinted by its cover art, modeled on Apple Music's
@@ -18,20 +17,33 @@ export type CoverPalette = {
isDark: boolean
}
/** Artwork measurements, cached before deriving the screen palette. */
/**
* Raw colors sampled from the art. `background` is the color the art bleeds
* into; `text` is ordered by preference and `accent` holds candidates for the
* Play button.
*/
export type CoverSwatches = {
background: string
average?: string
dominantFraction?: number
darkFraction?: number
text: string[]
accent: string[]
}
type Rgb = [number, number, number]
// Best effort: `legibleBackground` only guarantees that white or black reaches
// 7:1, so on some backgrounds primary text settles for pure white or black.
const PRIMARY_MIN_CONTRAST = 10
const SECONDARY_MIN_CONTRAST = 4.5
const SECONDARY_TO_PRIMARY_CONTRAST = 0.62
const ACCENT_MIN_CONTRAST = 3
const ACCENT_MIN_CHROMA = 0.05
const ACCENT_MAX_LIGHTNESS_SHIFT = 0.25
// Backgrounds between these luminances can't reach 7:1 with white or black.
const DARK_BACKGROUND_MAX_LUMINANCE = 0.095
const LIGHT_BACKGROUND_MIN_LUMINANCE = 0.31
export function themeCoverPalette(
theme: ThemeColors,
isDark: boolean
): CoverPalette {
type Rgb = [number, number, number]
type Oklch = { l: number; c: number; h: number }
export function themeCoverPalette(theme: ThemeColors, isDark: boolean): CoverPalette {
return {
background: theme.background,
foreground: theme.foreground,
@@ -45,89 +57,240 @@ export function themeCoverPalette(
}
}
/** Dark artwork canvas derived from region coverage and perceptual color. */
export function deriveCoverPalette(
swatches: CoverSwatches
swatches: CoverSwatches,
schemeIsDark: boolean
): CoverPalette | null {
const source = parseHex(swatches.background)
if (!source) return null
const average = swatches.average
? (parseHex(swatches.average) ?? source)
: source
const [lightness, a, b] = toOklab(source)
const [, averageA, averageB] = toOklab(average)
const chroma = Math.hypot(a, b)
const averageChroma = Math.hypot(averageA, averageB)
const shadow = clamp((0.4 - lightness) / 0.3)
const coverage = clamp(swatches.dominantFraction ?? 1)
const darkCoverage = clamp(swatches.darkFraction ?? 0)
// Luminance alone makes bright, muted artwork too light and dark blue art
// almost black. Chroma and a bounded shadow lift retain both kinds of cover.
let canvasLightness = Math.max(
0.17,
Math.min(0.4, 0.11 + 0.21 * lightness + 0.58 * chroma + 0.08 * shadow)
const background = legibleBackground(source, schemeIsDark)
const lightText = prefersLightText(background)
const parsedText = swatches.text
.map(parseHex)
.filter((color): color is Rgb => color !== null)
const backgroundLuminance = luminance(background)
const sameSideText = parsedText.filter((color) =>
lightText
? luminance(color) > backgroundLuminance
: luminance(color) < backgroundLuminance
)
let canvasChroma = Math.min(chroma * (1 + shadow), canvasLightness * 0.39)
const textCandidates = sameSideText.length > 0 ? sameSideText : parsedText
const fallbackText: Rgb = lightText ? [255, 255, 255] : [0, 0, 0]
// A dark region whose hue conflicts with the whole image is often a shadow,
// rather than a reliable saturated background. Do not amplify that tint.
const disagreement = Math.max(
0,
1 -
(a * averageA + b * averageB) / Math.max(chroma * averageChroma, 1e-8) -
0.3
const foreground = withMinContrast(
textCandidates[0] ?? fallbackText,
background,
PRIMARY_MIN_CONTRAST
)
canvasChroma *= Math.exp(-20 * shadow * disagreement)
canvasChroma *= Math.max(
0,
1 - 2.5 * darkCoverage * (1 - coverage) * (1 - shadow)
const primaryContrast = contrastRatio(foreground, background)
const secondaryTarget = Math.max(
SECONDARY_MIN_CONTRAST,
primaryContrast * SECONDARY_TO_PRIMARY_CONTRAST
)
const secondaryForeground = softenTo(
withMinContrast(
textCandidates[1] ?? foreground,
background,
SECONDARY_MIN_CONTRAST
),
background,
secondaryTarget
)
// Near-black RGB values carry unstable hue. Use the image's overall chroma
// to distinguish neutral artwork from a dark region in a colorful image.
const neutral = shadow * clamp((0.02 - chroma) / 0.02)
canvasChroma =
canvasChroma * (1 - neutral) +
Math.max(0, averageChroma - 0.02) * 3.5 * neutral
canvasLightness =
canvasLightness * (1 - neutral) +
(0.177 + Math.max(0, averageChroma - 0.02) * 2) * neutral
if (chroma < 0.01 && averageChroma < 0.025) {
canvasLightness = toOklab([17, 17, 17])[0]
canvasChroma = 0
}
const direction = chroma > 0 ? canvasChroma / chroma : 0
const background = fromOklab([canvasLightness, a * direction, b * direction])
const mixWhite = (amount: number) =>
toHex(
background.map((channel) =>
Math.round(channel + (255 - channel) * amount)
) as Rgb
)
const accent = pickAccent(swatches.accent, background) ?? foreground
const accentForeground: Rgb = prefersLightText(accent)
? [255, 255, 255]
: [0, 0, 0]
return {
background: toHex(background),
foreground: "#FFFFFF",
secondaryForeground: mixWhite(0.55),
accent: "#FFFFFF",
accentForeground: toHex(background),
accentText: "#FFFFFF",
surface: mixWhite(0.08),
divider: mixWhite(0.12),
isDark: true,
foreground: toHex(foreground),
secondaryForeground: toHex(secondaryForeground),
accent: toHex(accent),
accentForeground: toHex(accentForeground),
accentText: toHex(withMinContrast(accent, background, SECONDARY_MIN_CONTRAST)),
surface: toHex(mix(foreground, background, lightText ? 0.16 : 0.1)),
divider: toHex(mix(foreground, background, lightText ? 0.2 : 0.14)),
isDark: lightText,
}
}
function clamp(value: number) {
return Math.max(0, Math.min(1, value))
function legibleBackground(color: Rgb, schemeIsDark: boolean): Rgb {
const lch = toOklch(color)
// Keep the art's hue but avoid a glaring page in dark mode or a murky one in
// light mode.
const clamped = schemeIsDark
? withLightness(color, Math.min(lch.l, 0.86))
: withLightness(color, Math.max(lch.l, 0.2))
const y = luminance(clamped)
if (y <= DARK_BACKGROUND_MAX_LUMINANCE || y >= LIGHT_BACKGROUND_MIN_LUMINANCE) {
return clamped
}
const pivot = schemeIsDark ? 0.28 : 0.14
return y < pivot
? withLuminance(clamped, DARK_BACKGROUND_MAX_LUMINANCE)
: withLuminance(clamped, LIGHT_BACKGROUND_MIN_LUMINANCE)
}
function parseHex(hex: string): Rgb | null {
if (!/^#[0-9a-f]{6}$/i.test(hex)) return null
const value = parseInt(hex.slice(1), 16)
function pickAccent(candidates: string[], background: Rgb): Rgb | null {
let best: Rgb | null = null
let bestChroma = ACCENT_MIN_CHROMA
for (const hex of candidates) {
const color = parseHex(hex)
if (!color) continue
const adjusted = withMinContrast(color, background, ACCENT_MIN_CONTRAST)
const before = toOklch(color)
const after = toOklch(adjusted)
// A color pushed far from its own lightness (yellow turned olive) no
// longer reads as coming from the art.
if (Math.abs(after.l - before.l) > ACCENT_MAX_LIGHTNESS_SHIFT) continue
if (after.c > bestChroma) {
best = adjusted
bestChroma = after.c
}
}
return best
}
function prefersLightText(background: Rgb) {
return contrastRatio([255, 255, 255], background) >= contrastRatio([0, 0, 0], background)
}
/** Moves `color`'s lightness away from `background` until it reaches `min`. */
function withMinContrast(color: Rgb, background: Rgb, min: number): Rgb {
if (contrastRatio(color, background) >= min) return color
const lighten = prefersLightText(background)
const start = toOklch(color).l
const extreme = lighten ? 1 : 0
if (contrastRatio(withLightness(color, extreme), background) < min) {
return lighten ? [255, 255, 255] : [0, 0, 0]
}
let near = start
let far = extreme
for (let i = 0; i < 16; i++) {
const mid = (near + far) / 2
if (contrastRatio(withLightness(color, mid), background) >= min) {
far = mid
} else {
near = mid
}
}
return withLightness(color, far)
}
/** Blends `color` toward `background` until its contrast drops to `max`. */
function softenTo(color: Rgb, background: Rgb, max: number): Rgb {
if (contrastRatio(color, background) <= max) return color
let keep = 0
let blend = 1
for (let i = 0; i < 16; i++) {
const mid = (keep + blend) / 2
if (contrastRatio(mix(color, background, mid), background) >= max) {
blend = mid
} else {
keep = mid
}
}
return mix(color, background, blend)
}
function withLuminance(color: Rgb, target: number): Rgb {
let low = 0
let high = 1
for (let i = 0; i < 16; i++) {
const mid = (low + high) / 2
if (luminance(withLightness(color, mid)) < target) {
low = mid
} else {
high = mid
}
}
return withLightness(color, target <= DARK_BACKGROUND_MAX_LUMINANCE ? low : high)
}
/** `amount` of `color` over `base`. */
function mix(color: Rgb, base: Rgb, amount: number): Rgb {
return [0, 1, 2].map((i) =>
Math.round(base[i] + (color[i] - base[i]) * amount)
) as Rgb
}
function contrastRatio(a: Rgb, b: Rgb) {
const la = luminance(a)
const lb = luminance(b)
return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05)
}
function luminance([r, g, b]: Rgb) {
return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b)
}
function toLinear(channel: number) {
const c = channel / 255
return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4
}
function fromLinear(value: number) {
const c = value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055
return c * 255
}
function toOklch(color: Rgb): Oklch {
const [r, g, b] = color.map(toLinear)
const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b)
const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b)
const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b)
const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s
const A = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s
const B = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
return { l: L, c: Math.hypot(A, B), h: Math.atan2(B, A) }
}
function oklchToLinear({ l: L, c, h }: Oklch): Rgb {
const A = c * Math.cos(h)
const B = c * Math.sin(h)
const l = (L + 0.3963377774 * A + 0.2158037573 * B) ** 3
const m = (L - 0.1055613458 * A - 0.0638541728 * B) ** 3
const s = (L - 0.0894841775 * A - 1.291485548 * B) ** 3
return [
4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
]
}
/** Sets OKLCH lightness, reducing chroma as needed to stay within sRGB. */
function withLightness(color: Rgb, lightness: number): Rgb {
const lch = toOklch(color)
const l = Math.min(1, Math.max(0, lightness))
let c = lch.c
let linear = oklchToLinear({ l, c, h: lch.h })
for (let i = 0; i < 12 && !inGamut(linear); i++) {
c *= 0.8
linear = oklchToLinear({ l, c, h: lch.h })
}
return linear.map((value) =>
Math.round(Math.min(255, Math.max(0, fromLinear(value))))
) as Rgb
}
function inGamut(linear: Rgb) {
return linear.every((value) => value >= -0.0005 && value <= 1.0005)
}
function parseHex(hex: string | undefined): Rgb | null {
if (!hex) return null
const match = /^#?([0-9a-f]{6})/i.exec(hex.trim())
if (!match) return null
const value = parseInt(match[1], 16)
return [(value >> 16) & 255, (value >> 8) & 255, value & 255]
}
function toHex(color: Rgb) {
return `#${color.map((channel) => channel.toString(16).padStart(2, "0")).join("")}`
return `#${color.map((c) => c.toString(16).padStart(2, "0")).join("")}`
}
-266
View File
@@ -1,266 +0,0 @@
// Palette algorithm used before the dominant-region artwork extraction.
import type { CoverPalette } from "@/lib/cover-palette"
/**
* Raw colors sampled from the art. `background` is the color the art bleeds
* into; `text` is ordered by preference and `accent` holds candidates for the
* Play button.
*/
export type LegacyCoverSwatches = {
background: string
text: string[]
accent: string[]
}
// Best effort: `legibleBackground` only guarantees that white or black reaches
// 7:1, so on some backgrounds primary text settles for pure white or black.
const PRIMARY_MIN_CONTRAST = 10
const SECONDARY_MIN_CONTRAST = 4.5
const SECONDARY_TO_PRIMARY_CONTRAST = 0.62
const ACCENT_MIN_CONTRAST = 3
const ACCENT_MIN_CHROMA = 0.05
const ACCENT_MAX_LIGHTNESS_SHIFT = 0.25
// Backgrounds between these luminances can't reach 7:1 with white or black.
const DARK_BACKGROUND_MAX_LUMINANCE = 0.095
const LIGHT_BACKGROUND_MIN_LUMINANCE = 0.31
type Rgb = [number, number, number]
type Oklch = { l: number; c: number; h: number }
export function deriveCoverPalette(
swatches: LegacyCoverSwatches,
schemeIsDark: boolean
): CoverPalette | null {
const source = parseHex(swatches.background)
if (!source) return null
const background = legibleBackground(source, schemeIsDark)
const lightText = prefersLightText(background)
const parsedText = swatches.text
.map(parseHex)
.filter((color): color is Rgb => color !== null)
const backgroundLuminance = luminance(background)
const sameSideText = parsedText.filter((color) =>
lightText
? luminance(color) > backgroundLuminance
: luminance(color) < backgroundLuminance
)
const textCandidates = sameSideText.length > 0 ? sameSideText : parsedText
const fallbackText: Rgb = lightText ? [255, 255, 255] : [0, 0, 0]
const foreground = withMinContrast(
textCandidates[0] ?? fallbackText,
background,
PRIMARY_MIN_CONTRAST
)
const primaryContrast = contrastRatio(foreground, background)
const secondaryTarget = Math.max(
SECONDARY_MIN_CONTRAST,
primaryContrast * SECONDARY_TO_PRIMARY_CONTRAST
)
const secondaryForeground = softenTo(
withMinContrast(
textCandidates[1] ?? foreground,
background,
SECONDARY_MIN_CONTRAST
),
background,
secondaryTarget
)
const accent = pickAccent(swatches.accent, background) ?? foreground
const accentForeground: Rgb = prefersLightText(accent)
? [255, 255, 255]
: [0, 0, 0]
return {
background: toHex(background),
foreground: toHex(foreground),
secondaryForeground: toHex(secondaryForeground),
accent: toHex(accent),
accentForeground: toHex(accentForeground),
accentText: toHex(withMinContrast(accent, background, SECONDARY_MIN_CONTRAST)),
surface: toHex(mix(foreground, background, lightText ? 0.16 : 0.1)),
divider: toHex(mix(foreground, background, lightText ? 0.2 : 0.14)),
isDark: lightText,
}
}
function legibleBackground(color: Rgb, schemeIsDark: boolean): Rgb {
const lch = toOklch(color)
// Keep the art's hue but avoid a glaring page in dark mode or a murky one in
// light mode.
const clamped = schemeIsDark
? withLightness(color, Math.min(lch.l, 0.86))
: withLightness(color, Math.max(lch.l, 0.2))
const y = luminance(clamped)
if (y <= DARK_BACKGROUND_MAX_LUMINANCE || y >= LIGHT_BACKGROUND_MIN_LUMINANCE) {
return clamped
}
const pivot = schemeIsDark ? 0.28 : 0.14
return y < pivot
? withLuminance(clamped, DARK_BACKGROUND_MAX_LUMINANCE)
: withLuminance(clamped, LIGHT_BACKGROUND_MIN_LUMINANCE)
}
function pickAccent(candidates: string[], background: Rgb): Rgb | null {
let best: Rgb | null = null
let bestChroma = ACCENT_MIN_CHROMA
for (const hex of candidates) {
const color = parseHex(hex)
if (!color) continue
const adjusted = withMinContrast(color, background, ACCENT_MIN_CONTRAST)
const before = toOklch(color)
const after = toOklch(adjusted)
// A color pushed far from its own lightness (yellow turned olive) no
// longer reads as coming from the art.
if (Math.abs(after.l - before.l) > ACCENT_MAX_LIGHTNESS_SHIFT) continue
if (after.c > bestChroma) {
best = adjusted
bestChroma = after.c
}
}
return best
}
function prefersLightText(background: Rgb) {
return contrastRatio([255, 255, 255], background) >= contrastRatio([0, 0, 0], background)
}
/** Moves `color`'s lightness away from `background` until it reaches `min`. */
function withMinContrast(color: Rgb, background: Rgb, min: number): Rgb {
if (contrastRatio(color, background) >= min) return color
const lighten = prefersLightText(background)
const start = toOklch(color).l
const extreme = lighten ? 1 : 0
if (contrastRatio(withLightness(color, extreme), background) < min) {
return lighten ? [255, 255, 255] : [0, 0, 0]
}
let near = start
let far = extreme
for (let i = 0; i < 16; i++) {
const mid = (near + far) / 2
if (contrastRatio(withLightness(color, mid), background) >= min) {
far = mid
} else {
near = mid
}
}
return withLightness(color, far)
}
/** Blends `color` toward `background` until its contrast drops to `max`. */
function softenTo(color: Rgb, background: Rgb, max: number): Rgb {
if (contrastRatio(color, background) <= max) return color
let keep = 0
let blend = 1
for (let i = 0; i < 16; i++) {
const mid = (keep + blend) / 2
if (contrastRatio(mix(color, background, mid), background) >= max) {
blend = mid
} else {
keep = mid
}
}
return mix(color, background, blend)
}
function withLuminance(color: Rgb, target: number): Rgb {
let low = 0
let high = 1
for (let i = 0; i < 16; i++) {
const mid = (low + high) / 2
if (luminance(withLightness(color, mid)) < target) {
low = mid
} else {
high = mid
}
}
return withLightness(color, target <= DARK_BACKGROUND_MAX_LUMINANCE ? low : high)
}
/** `amount` of `color` over `base`. */
function mix(color: Rgb, base: Rgb, amount: number): Rgb {
return [0, 1, 2].map((i) =>
Math.round(base[i] + (color[i] - base[i]) * amount)
) as Rgb
}
function contrastRatio(a: Rgb, b: Rgb) {
const la = luminance(a)
const lb = luminance(b)
return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05)
}
function luminance([r, g, b]: Rgb) {
return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b)
}
function toLinear(channel: number) {
const c = channel / 255
return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4
}
function fromLinear(value: number) {
const c = value <= 0.0031308 ? value * 12.92 : 1.055 * value ** (1 / 2.4) - 0.055
return c * 255
}
function toOklch(color: Rgb): Oklch {
const [r, g, b] = color.map(toLinear)
const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b)
const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b)
const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b)
const L = 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s
const A = 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s
const B = 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
return { l: L, c: Math.hypot(A, B), h: Math.atan2(B, A) }
}
function oklchToLinear({ l: L, c, h }: Oklch): Rgb {
const A = c * Math.cos(h)
const B = c * Math.sin(h)
const l = (L + 0.3963377774 * A + 0.2158037573 * B) ** 3
const m = (L - 0.1055613458 * A - 0.0638541728 * B) ** 3
const s = (L - 0.0894841775 * A - 1.291485548 * B) ** 3
return [
4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s,
]
}
/** Sets OKLCH lightness, reducing chroma as needed to stay within sRGB. */
function withLightness(color: Rgb, lightness: number): Rgb {
const lch = toOklch(color)
const l = Math.min(1, Math.max(0, lightness))
let c = lch.c
let linear = oklchToLinear({ l, c, h: lch.h })
for (let i = 0; i < 12 && !inGamut(linear); i++) {
c *= 0.8
linear = oklchToLinear({ l, c, h: lch.h })
}
return linear.map((value) =>
Math.round(Math.min(255, Math.max(0, fromLinear(value))))
) as Rgb
}
function inGamut(linear: Rgb) {
return linear.every((value) => value >= -0.0005 && value <= 1.0005)
}
function parseHex(hex: string | undefined): Rgb | null {
if (!hex) return null
const match = /^#?([0-9a-f]{6})/i.exec(hex.trim())
if (!match) return null
const value = parseInt(match[1], 16)
return [(value >> 16) & 255, (value >> 8) & 255, value & 255]
}
function toHex(color: Rgb) {
return `#${color.map((c) => c.toString(16).padStart(2, "0")).join("")}`
}
@@ -1,4 +0,0 @@
{
"platforms": ["apple"],
"apple": { "modules": ["ArtworkColorsModule"] }
}
@@ -1,17 +0,0 @@
Pod::Spec.new do |s|
s.name = 'ArtworkColors'
s.version = '1.0.0'
s.summary = 'Artwork color sampling for oTunes'
s.description = s.summary
s.license = { :type => 'MIT' }
s.author = 'oTunes'
s.homepage = 'https://otunes.abunchofknowitalls.com'
s.platforms = { :ios => '16.4' }
s.swift_version = '5.9'
s.source = { :git => '' }
s.static_framework = true
s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
s.dependency 'ExpoModulesCore'
s.frameworks = 'ImageIO', 'CoreGraphics'
s.source_files = '**/*.swift'
end
@@ -1,65 +0,0 @@
import ExpoModulesCore
import CoreGraphics
import ImageIO
public final class ArtworkColorsModule: Module {
public func definition() -> ModuleDefinition {
Name("ArtworkColors")
AsyncFunction("histogram") { (uri: URL) async throws -> [[Int]] in
let (data, response) = try await URLSession.shared.data(from: uri)
if let response = response as? HTTPURLResponse, !(200..<300).contains(response.statusCode) {
throw ArtworkColorError.invalidImage
}
return try Self.histogram(data: data)
}
}
/// Sample in sRGB so Display P3 artwork and ordinary JPEGs share one color space.
static func histogram(data: Data) throws -> [[Int]] {
guard let source = CGImageSourceCreateWithData(data as CFData, nil),
let image = CGImageSourceCreateThumbnailAtIndex(source, 0, [
kCGImageSourceCreateThumbnailFromImageAlways: true,
kCGImageSourceCreateThumbnailWithTransform: true,
kCGImageSourceThumbnailMaxPixelSize: 64,
] as CFDictionary),
let space = CGColorSpace(name: CGColorSpace.sRGB)
else { throw ArtworkColorError.invalidImage }
let width = image.width
let height = image.height
var pixels = [UInt8](repeating: 0, count: width * height * 4)
var bins = [[Int]](repeating: [0, 0, 0, 0], count: 512)
try pixels.withUnsafeMutableBytes { buffer in
guard let context = CGContext(
data: buffer.baseAddress, width: width, height: height,
bitsPerComponent: 8, bytesPerRow: width * 4, space: space,
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue | CGBitmapInfo.byteOrder32Big.rawValue
) else { throw ArtworkColorError.invalidImage }
context.interpolationQuality = .high
context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
}
for offset in stride(from: 0, to: pixels.count, by: 4) {
let alpha = Int(pixels[offset + 3])
guard alpha >= 128 else { continue }
// Ignore transparent pixels and undo premultiplication for the rest.
let r = min(255, Int(pixels[offset]) * 255 / alpha)
let g = min(255, Int(pixels[offset + 1]) * 255 / alpha)
let b = min(255, Int(pixels[offset + 2]) * 255 / alpha)
let key = (r >> 5) * 64 + (g >> 5) * 8 + (b >> 5)
bins[key][0] += r
bins[key][1] += g
bins[key][2] += b
bins[key][3] += 1
}
// Keep each bin's actual mean rather than its quantized center.
return bins.filter { $0[3] > 0 }.map { bin in
[bin[0] / bin[3], bin[1] / bin[3], bin[2] / bin[3], bin[3]]
}
}
}
private enum ArtworkColorError: Error {
case invalidImage
}
+6 -1
View File
@@ -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[] = []
+8 -5
View File
@@ -3,15 +3,15 @@
import * as React from "react"
import Link from "next/link"
import {
GalleryVerticalEnd,
Disc3,
ListEnd,
ListPlus,
ListStart,
MicVocal,
MoreHorizontal,
Share2,
Shuffle,
Star,
User,
} from "lucide-react"
import { Button } from "@/components/ui/button"
@@ -22,7 +22,10 @@ import {
DropdownMenuSeparator,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import { copyMediaShareLink, type MediaShareContext } from "@/lib/media-links"
import {
copyMediaShareLink,
type MediaShareContext,
} from "@/lib/media-links"
import { cn } from "@/lib/utils"
export type MediaContextAction =
@@ -138,7 +141,7 @@ export function MediaContextMenuItems({
<DropdownMenuItem asChild className="justify-between">
<Link href={`/artist/${artist.id}`}>
Go to Artist
<MicVocal />
<User />
</Link>
</DropdownMenuItem>
) : null}
@@ -146,7 +149,7 @@ export function MediaContextMenuItems({
<DropdownMenuItem asChild className="justify-between">
<Link href={`/album/${album.id}`}>
Go to Album
<GalleryVerticalEnd />
<Disc3 />
</Link>
</DropdownMenuItem>
) : null}
@@ -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)
+7 -1
View File
@@ -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 {
+6 -1
View File
@@ -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,
+6 -1
View File
@@ -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)[]
+6 -1
View File
@@ -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,
+15
View File
@@ -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");
+7 -1
View File
@@ -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"
+19
View File
@@ -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
-7
View File
@@ -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")}`
}
+14 -6
View File
@@ -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 })
}
+4 -4
View File
@@ -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,
+30
View File
@@ -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
View File
@@ -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
) &
+7
View File
@@ -578,6 +578,13 @@ export const updateLibrary = action({
},
})
export const cleanupHlsStreams = internalAction({
args: {},
handler: async () => {
return await cleanHlsStreamsOlderThan(HLS_MAX_IDLE_MS)
},
})
export const adminCleanupHlsStreams = action({
args: {},
handler: async (ctx) => {
+25 -1
View File
@@ -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 }) => {
+290 -1
View File
@@ -8,6 +8,7 @@ import type { PaginationOptions, PaginationResult } from "convex/server"
import type {
BrowseAlbum,
BrowseAlbumDetail,
BrowseAlbumSummary,
BrowseAlbumTrack,
BrowseArtist,
BrowseArtistDetail,
@@ -25,6 +26,7 @@ import type {
export type {
BrowseAlbum,
BrowseAlbumDetail,
BrowseAlbumSummary,
BrowseAlbumTrack,
BrowseArtist,
BrowseArtistDetail,
@@ -222,7 +224,7 @@ export const browseArtists = query({
},
})
function paginateSlice<T>(
export function paginateSlice<T>(
items: T[],
paginationOpts: PaginationOptions
): PaginationResult<T> {
@@ -278,6 +280,27 @@ export const browseAlbumsPaginated = query({
},
})
export const browseSongs = query({
args: {},
handler: async (ctx) => {
const artistMap = await loadArtistMap(ctx)
const albums = await ctx.db.query("albums").collect()
const albumMap = new Map(albums.map((album) => [album._id, album]))
const songs = await ctx.db.query("songs").collect()
return songs
.flatMap((song) => {
const album = albumMap.get(song.album)
const albumArtist = artistMap.get(song.albumArtist)
if (!album || !albumArtist) {
return []
}
return [toBrowseSong(song, album, albumArtist)]
})
.sort((a, b) => a.title.localeCompare(b.title))
},
})
export const songsSortKeyValidator = v.union(
v.literal("title"),
v.literal("artist"),
@@ -522,6 +545,72 @@ export const browseAlbumDetail = query({
},
})
async function browseAlbumSummaryHandler(
ctx: QueryCtx,
albumId: Id<"albums">
): Promise<BrowseAlbumSummary | null> {
const album = await ctx.db.get("albums", albumId)
if (!album) {
return null
}
const artist = await ctx.db.get("artists", album.artist)
if (!artist) {
return null
}
const songs = await ctx.db
.query("songs")
.withIndex("by_album", (q) => q.eq("album", albumId))
.collect()
songs.sort(compareAlbumSongs)
const primarySong = songs[0]
return {
...toBrowseAlbum(album, artist),
year: primarySong?.year ?? null,
genre: primarySong?.genres[0] ?? null,
releaseDate: album.date,
hasLossless: songs.some((song) => "lossless" in song.files),
hasAtmos: songs.some((song) => "atmos" in song.files),
trackCount: songs.length,
}
}
export const browseAlbumSummary = query({
args: { id: v.id("albums") },
handler: async (ctx, args) => browseAlbumSummaryHandler(ctx, args.id),
})
export const browseAlbumTracksPaginated = query({
args: {
albumId: v.id("albums"),
paginationOpts: paginationOptsValidator,
},
handler: async (ctx, args) => {
const album = await ctx.db.get("albums", args.albumId)
if (!album) {
return { page: [], isDone: true, continueCursor: "" }
}
const artist = await ctx.db.get("artists", album.artist)
if (!artist) {
return { page: [], isDone: true, continueCursor: "" }
}
const songs = await ctx.db
.query("songs")
.withIndex("by_album", (q) => q.eq("album", args.albumId))
.collect()
songs.sort(compareAlbumSongs)
const tracks = songs.map((song) => toBrowseAlbumTrack(song, artist.name))
return paginateSlice(tracks, args.paginationOpts)
},
})
export const browseArtistDetail = query({
args: { id: v.id("artists") },
handler: async (ctx, args) => {
@@ -819,6 +908,16 @@ export const getAlbums = internalQuery({
},
})
export const getAlbumsInArtist = internalQuery({
args: { artistID: v.id("artists") },
handler: async (ctx, args) => {
return await ctx.db
.query("albums")
.withIndex("by_artist", (q) => q.eq("artist", args.artistID))
.collect()
},
})
export const getSongs = internalQuery({
args: {},
handler: async (ctx) => {
@@ -826,6 +925,26 @@ export const getSongs = internalQuery({
},
})
export const getSongsInArtist = internalQuery({
args: { artistID: v.id("artists") },
handler: async (ctx, args) => {
return await ctx.db
.query("songs")
.withIndex("by_artist", (q) => q.eq("albumArtist", args.artistID))
.collect()
},
})
export const getSongsInAlbum = internalQuery({
args: { albumID: v.id("albums") },
handler: async (ctx, args) => {
return await ctx.db
.query("songs")
.withIndex("by_album", (q) => q.eq("album", args.albumID))
.collect()
},
})
export const getArtist = query({
args: { id: v.id("artists") },
handler: async (ctx, args) => {
@@ -833,6 +952,16 @@ export const getArtist = query({
},
})
export const getArtistByName = internalQuery({
args: { name: v.string() },
handler: async (ctx, args) => {
return await ctx.db
.query("artists")
.withIndex("by_name", (q) => q.eq("name", args.name))
.first()
},
})
export const getAlbum = query({
args: { id: v.id("albums") },
handler: async (ctx, args) => {
@@ -840,6 +969,28 @@ export const getAlbum = query({
},
})
export const getAlbumByName = internalQuery({
args: { name: v.string() },
handler: async (ctx, args) => {
return await ctx.db
.query("albums")
.withIndex("by_name", (q) => q.eq("name", args.name))
.first()
},
})
export const getAlbumByAll = internalQuery({
args: { folder: v.string(), artist: v.id("artists") },
handler: async (ctx, args) => {
return await ctx.db
.query("albums")
.withIndex("by_all", (q) =>
q.eq("artist", args.artist).eq("folder", args.folder)
)
.first()
},
})
export const getPlaylist = query({
args: { id: v.id("playlists") },
handler: async (ctx, args) => {
@@ -1024,6 +1175,49 @@ export const intentCatalogPage = query({
},
})
export const getSongByName = internalQuery({
args: { name: v.string() },
handler: async (ctx, args) => {
return await ctx.db
.query("songs")
.withIndex("by_name", (q) => q.eq("name", args.name))
.first()
},
})
export const getSongByAll = internalQuery({
args: {
name: v.string(),
albumArtist: v.id("artists"),
album: v.id("albums"),
},
handler: async (ctx, args) => {
return await ctx.db
.query("songs")
.withIndex("by_all", (q) =>
q
.eq("name", args.name)
.eq("albumArtist", args.albumArtist)
.eq("album", args.album)
)
.first()
},
})
export const createArtist = internalMutation({
args: { name: v.string(), folder: v.string(), cover: v.nullable(v.string()) },
handler: async (ctx, args) => {
const existing = await ctx.db
.query("artists")
.withIndex("by_folder", (q) => q.eq("folder", args.folder))
.first()
if (existing) {
return existing._id
}
return await ctx.db.insert("artists", args)
},
})
export const createArtists = internalMutation({
args: {
artists: v.array(
@@ -1048,6 +1242,29 @@ export const createArtists = internalMutation({
},
})
export const createAlbum = internalMutation({
args: {
name: v.string(),
folder: v.string(),
cover: v.nullable(v.string()),
year: v.number(),
date: v.string(),
artist: v.id("artists"),
},
handler: async (ctx, args) => {
const existing = await ctx.db
.query("albums")
.withIndex("by_all", (q) =>
q.eq("artist", args.artist).eq("folder", args.folder)
)
.first()
if (existing) {
return existing._id
}
return await ctx.db.insert("albums", args)
},
})
export const createAlbums = internalMutation({
args: {
albums: v.array(
@@ -1077,6 +1294,50 @@ export const createAlbums = internalMutation({
},
})
export const updateAlbumName = internalMutation({
args: {
id: v.id("albums"),
newName: v.string(),
},
handler: async (ctx, args) => {
return await ctx.db.patch("albums", args.id, { name: args.newName })
},
})
export const createSong = internalMutation({
args: {
name: v.string(),
files: v.record(v.string(), v.string()),
album: v.id("albums"),
artist: v.union(v.string(), v.array(v.string())),
albumArtist: v.id("artists"),
length: v.number(),
diskNumber: v.nullable(v.number()),
track: v.number(),
year: v.number(),
date: v.string(),
genres: v.array(v.string()),
},
handler: async (ctx, args) => {
const existing = await ctx.db
.query("songs")
.withIndex("by_all", (q) =>
q
.eq("name", args.name)
.eq("albumArtist", args.albumArtist)
.eq("album", args.album)
)
.first()
if (existing) {
await ctx.db.patch(existing._id, {
files: { ...existing.files, ...args.files },
})
return existing._id
}
return await ctx.db.insert("songs", args)
},
})
export const createSongs = internalMutation({
args: {
songs: v.array(
@@ -1224,6 +1485,13 @@ export const purgeArtistsFromUsers = internalMutation({
},
})
export const removeArtist = internalMutation({
args: { id: v.id("artists") },
handler: async (ctx, args) => {
return await ctx.db.delete("artists", args.id)
},
})
export const removeArtists = internalMutation({
args: { ids: v.array(v.id("artists")) },
handler: async (ctx, args) => {
@@ -1233,6 +1501,13 @@ export const removeArtists = internalMutation({
},
})
export const removeAlbum = internalMutation({
args: { id: v.id("albums") },
handler: async (ctx, args) => {
return await ctx.db.delete("albums", args.id)
},
})
export const removeAlbums = internalMutation({
args: { ids: v.array(v.id("albums")) },
handler: async (ctx, args) => {
@@ -1242,6 +1517,20 @@ export const removeAlbums = internalMutation({
},
})
export const removeSong = internalMutation({
args: { id: v.id("songs") },
handler: async (ctx, args) => {
return await ctx.db.delete("songs", args.id)
},
})
export const changeFilesForSong = internalMutation({
args: { id: v.id("songs"), files: v.record(v.string(), v.string()) },
handler: async (ctx, args) => {
return await ctx.db.patch("songs", args.id, { files: args.files })
},
})
export const changeFilesForSongs = internalMutation({
args: {
songs: v.array(
+654 -1
View File
@@ -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,554 @@ 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)
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"),
+33 -3
View File
@@ -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) => {
+4
View File
@@ -41,6 +41,10 @@ export type BrowseAlbumDetail = BrowseAlbum & {
tracks: BrowseAlbumTrack[]
}
export type BrowseAlbumSummary = Omit<BrowseAlbumDetail, "tracks"> & {
trackCount: number
}
export type BrowseArtistDetail = {
artist: BrowseArtist
albums: BrowseAlbum[]