Compare commits

...
15 changed files with 1390 additions and 344 deletions

No files matched your search

@@ -16,17 +16,18 @@ export default function HomeLayout() {
screenOptions={({ route }) => ({
...baseOptions,
title: tabStackScreenTitles[route.name] ?? "Home",
headerRight: route.name === "settings" ? undefined : () => <ProfileHeaderButton />,
headerRight:
route.name === "index" ? () => <ProfileHeaderButton /> : undefined,
unstable_headerRightItems:
route.name === "settings"
? undefined
: () => [
route.name === "index"
? () => [
{
type: "custom",
element: <ProfileHeaderButton />,
hidesSharedBackground: true,
},
],
]
: undefined,
})}
/>
)
+205 -99
View File
@@ -1,8 +1,14 @@
import { Stack, useLocalSearchParams } from "expo-router"
import { memo, useEffect, useMemo } from "react"
import { Stack, useIsFocused, useLocalSearchParams } from "expo-router"
import { StatusBar } from "expo-status-bar"
import { memo, useCallback, useEffect, useMemo } from "react"
import { FlatList, Pressable, StyleSheet, Text, View } from "react-native"
import { Ionicons } from "@expo/vector-icons"
import {
CollectionDivider,
collectionInset,
DiscHeader,
} from "@/components/collection-list"
import { CoverImage } from "@/components/cover-image"
import {
@@ -17,11 +23,12 @@ import { useFavorites } from "@/contexts/favorites"
import { usePlaybackActions } from "@/contexts/playback"
import { useServerConfig } from "@/contexts/server-config"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useCoverBackgroundColor } from "@/hooks/use-cover-background-color"
import { useCoverPalette } from "@/hooks/use-cover-palette"
import { useMediaMenuActions } from "@/hooks/use-media-menu-actions"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseAlbumDetail, BrowseAlbumTrack } from "@otunes/convex/types"
import type { CoverPalette } from "@/lib/cover-palette"
import { formatDuration, formatMetadata } from "@/lib/format"
import { useAppNavigation } from "@/lib/app-navigation"
import { longListProps } from "@/lib/list"
@@ -46,12 +53,16 @@ export default function AlbumScreen() {
handleAlbumTrackAction,
isAlbumFavorite: isAlbumFav,
} = useMediaMenuActions()
const isFocused = useIsFocused()
const coverUri =
config && album ? albumCoverUrl(config.serverUrl, album.id) : ""
const backgroundColor = useCoverBackgroundColor(
config && typeof id === "string" ? albumCoverUrl(config.serverUrl, id) : ""
const { palette, settled } = useCoverPalette(
coverUri,
album?.cover != null,
colors.background
album ? album.cover != null : album === null ? false : undefined
)
const songIds = useMemo(
() => album?.tracks.map((track) => track.id as Id<"songs">) ?? [],
[album]
)
useEffect(() => {
@@ -60,12 +71,37 @@ export default function AlbumScreen() {
}
}, [album])
const songIds = useMemo(
() => album?.tracks.map((track) => track.id) ?? [],
[album?.tracks]
const listItems = useMemo(() => albumListItems(album?.tracks ?? []), [album])
const renderItem = useCallback(
({ item }: { item: AlbumListItem }) => {
if (item.type === "disc") {
return <DiscHeader label={item.label} color={palette.foreground} />
}
return album ? (
<AlbumTrackRow
track={item.track}
number={item.number}
album={album}
songIds={songIds}
palette={palette}
favorited={isSongFavorite(item.track.id)}
onPlay={playFromSong}
onAction={handleAlbumTrackAction}
/>
) : null
},
[
album,
handleAlbumTrackAction,
isSongFavorite,
palette,
playFromSong,
songIds,
]
)
if (album === undefined || !config) {
if (album === undefined || !config || !settled) {
return (
<>
<Stack.Screen
@@ -98,13 +134,18 @@ export default function AlbumScreen() {
}
const metadata = formatMetadata(album.genre, album.year)
const favorited = isAlbumFavorite(album.id)
return (
<>
{isFocused ? (
<StatusBar style={palette.isDark ? "light" : "dark"} />
) : null}
<Stack.Screen
options={{
title: "",
headerLargeTitle: false,
headerTintColor: palette.foreground,
headerRight: () => (
<MediaActionMenu
selectedCount={album.tracks.length}
@@ -122,7 +163,7 @@ export default function AlbumScreen() {
<Ionicons
name="ellipsis-horizontal"
size={22}
color={colors.foreground}
color={palette.foreground}
/>
</Pressable>
</MediaActionMenu>
@@ -131,93 +172,142 @@ export default function AlbumScreen() {
/>
<FlatList
{...longListProps}
data={album.tracks}
keyExtractor={(track) => track.id}
style={{ flex: 1, backgroundColor }}
data={listItems}
keyExtractor={albumListItemKey}
style={{ flex: 1, backgroundColor: palette.background }}
contentContainerStyle={{ paddingBottom: contentBottomInset }}
contentInsetAdjustmentBehavior="automatic"
indicatorStyle={palette.isDark ? "white" : "black"}
ListHeaderComponent={
<View style={styles.hero}>
<CoverImage
uri={coverUri}
hasCover={album.cover != null}
style={styles.cover}
/>
<Text style={[styles.title, { color: colors.foreground }]}>
{album.title}
</Text>
<Pressable onPress={() => push(`/artist/${album.artist.id}`)}>
<Text style={[styles.artist, { color: colors.mutedForeground }]}>
{album.artist.name}
</Text>
</Pressable>
{metadata ? (
<Text style={{ color: colors.mutedForeground }}>{metadata}</Text>
) : null}
<View style={styles.actions}>
<Pressable
onPress={() => void toggleAlbumFavorite(album.id)}
hitSlop={8}
style={[styles.iconAction, { backgroundColor: colors.muted }]}
>
<Ionicons
name={isAlbumFavorite(album.id) ? "star" : "star-outline"}
size={24}
color={
isAlbumFavorite(album.id)
? colors.primary
: colors.foreground
}
/>
</Pressable>
<Button
title="Play"
icon="play"
onPress={() => void playAlbum(album.id, songIds)}
style={styles.playButton}
<View>
<View style={styles.hero}>
<CoverImage
uri={coverUri}
hasCover={album.cover != null}
style={styles.cover}
/>
<Pressable
accessibilityRole="button"
accessibilityLabel="Shuffle"
hitSlop={8}
onPress={() => void playAlbumShuffled(album.id, songIds)}
style={[styles.iconAction, { backgroundColor: colors.muted }]}
>
<Ionicons name="shuffle" size={24} color={colors.foreground} />
<Text style={[styles.title, { color: palette.foreground }]}>
{album.title}
</Text>
<Pressable onPress={() => push(`/artist/${album.artist.id}`)}>
<Text style={[styles.artist, { color: palette.accentText }]}>
{album.artist.name}
</Text>
</Pressable>
{metadata ? (
<Text style={{ color: palette.secondaryForeground }}>
{metadata}
</Text>
) : null}
<View style={styles.actions}>
<Pressable
onPress={() => void toggleAlbumFavorite(album.id)}
hitSlop={8}
style={[
styles.iconAction,
{ backgroundColor: palette.surface },
]}
>
<Ionicons
name={favorited ? "star" : "star-outline"}
size={24}
color={favorited ? palette.accent : palette.foreground}
/>
</Pressable>
<Button
title="Play"
icon="play"
onPress={() => void playAlbum(album.id, songIds)}
style={styles.playButton}
tint={{
background: palette.accent,
foreground: palette.accentForeground,
}}
/>
<Pressable
accessibilityRole="button"
accessibilityLabel="Shuffle"
hitSlop={8}
onPress={() => void playAlbumShuffled(album.id, songIds)}
style={[
styles.iconAction,
{ backgroundColor: palette.surface },
]}
>
<Ionicons
name="shuffle"
size={24}
color={palette.foreground}
/>
</Pressable>
</View>
</View>
<CollectionDivider color={palette.divider} />
</View>
}
renderItem={({ item: track, index }) => (
<AlbumTrackRow
track={track}
album={album}
index={index}
favorited={isSongFavorite(track.id)}
songIds={songIds}
onPlay={playFromSong}
onAction={handleAlbumTrackAction}
/>
)}
renderItem={renderItem}
/>
</>
)
}
type AlbumListItem =
| { type: "disc"; key: string; label: string }
| { type: "track"; track: BrowseAlbumTrack; number: number }
/**
* Tracks arrive sorted by disc then track number. Disc headers are only
* inserted when the album spans more than one disc.
*/
function albumListItems(tracks: BrowseAlbumTrack[]): AlbumListItem[] {
const multiDisc = new Set(tracks.map((track) => track.diskNumber)).size > 1
const items: AlbumListItem[] = []
let currentDisc: number | null | undefined
let positionInDisc = 0
for (const track of tracks) {
if (track.diskNumber !== currentDisc) {
currentDisc = track.diskNumber
positionInDisc = 0
if (multiDisc) {
items.push({
type: "disc",
key: `disc-${currentDisc ?? "unknown"}`,
label: currentDisc == null ? "Other" : `Disc ${currentDisc}`,
})
}
}
positionInDisc += 1
items.push({
type: "track",
track,
number: track.track || positionInDisc,
})
}
return items
}
function albumListItemKey(item: AlbumListItem) {
return item.type === "disc" ? item.key : item.track.id
}
const AlbumTrackRow = memo(function AlbumTrackRow({
track,
number,
album,
index,
favorited,
songIds,
palette,
favorited,
onPlay,
onAction,
}: {
track: BrowseAlbumTrack
number: number
album: BrowseAlbumDetail
index: number
favorited: boolean
songIds: Id<"songs">[]
palette: CoverPalette
favorited: boolean
onPlay: (songId: Id<"songs">, songIds: Id<"songs">[]) => Promise<void>
onAction: (
track: BrowseAlbumTrack,
@@ -225,8 +315,6 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
action: MediaAction
) => Promise<void>
}) {
const colors = useThemeColors()
return (
<MediaContextMenu
favorited={favorited}
@@ -242,28 +330,37 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
onAction={(action) => void onAction(track, album, action)}
>
<Pressable
style={[styles.trackRow, { borderBottomColor: colors.border }]}
onPress={() => void onPlay(track.id, songIds)}
style={styles.trackRow}
onPress={() => void onPlay(track.id as Id<"songs">, songIds)}
>
<Text style={[styles.trackNumber, { color: colors.mutedForeground }]}>
{track.track || index + 1}
<Text
style={[styles.trackNumber, { color: palette.secondaryForeground }]}
>
{number}
</Text>
<View style={styles.trackMeta}>
<Text
style={[styles.trackTitle, { color: colors.foreground }]}
numberOfLines={1}
>
{track.title}
</Text>
{track.artists ? (
<Text style={{ color: colors.mutedForeground }} numberOfLines={1}>
{track.artists.join(", ")}
<View
style={[styles.trackContent, { borderBottomColor: palette.divider }]}
>
<View style={styles.trackMeta}>
<Text
style={[styles.trackTitle, { color: palette.foreground }]}
numberOfLines={1}
>
{track.title}
</Text>
) : null}
{track.artists ? (
<Text
style={{ color: palette.secondaryForeground }}
numberOfLines={1}
>
{track.artists.join(", ")}
</Text>
) : null}
</View>
<Text style={{ color: palette.secondaryForeground }}>
{formatDuration(track.durationSeconds)}
</Text>
</View>
<Text style={{ color: colors.mutedForeground }}>
{formatDuration(track.durationSeconds)}
</Text>
</Pressable>
</MediaContextMenu>
)
@@ -301,13 +398,22 @@ const styles = StyleSheet.create({
trackRow: {
flexDirection: "row",
alignItems: "center",
gap: spacing.sm,
paddingLeft: collectionInset,
},
trackNumber: { width: 24, fontSize: 16, textAlign: "center" },
trackContent: {
flex: 1,
minWidth: 0,
flexDirection: "row",
alignItems: "center",
alignSelf: "stretch",
gap: spacing.md,
minHeight: 60,
paddingHorizontal: spacing.lg,
minHeight: 52,
paddingVertical: 12,
marginRight: collectionInset,
borderBottomWidth: StyleSheet.hairlineWidth,
},
trackNumber: { width: 24, textAlign: "center" },
trackMeta: { flex: 1, minWidth: 0 },
trackTitle: { fontSize: 16, fontWeight: "500" },
})
@@ -1,8 +1,15 @@
import { useMutation } from "convex/react"
import { memo, useCallback, useEffect, useMemo } from "react"
import { Stack, useLocalSearchParams, useRouter } from "expo-router"
import {
Stack,
useIsFocused,
useLocalSearchParams,
useRouter,
} from "expo-router"
import { StatusBar } from "expo-status-bar"
import {
FlatList,
Platform,
Pressable,
StyleSheet,
Text,
@@ -12,7 +19,13 @@ import {
import ReanimatedSwipeable from "react-native-gesture-handler/ReanimatedSwipeable"
import { Ionicons } from "@expo/vector-icons"
import { CollectionDivider } from "@/components/collection-list"
import { CoverImage } from "@/components/cover-image"
import {
SwipeToRemoveRow,
useSwipeRowGroup,
type SwipeRowGroup,
} from "@/components/ios-swipe-to-remove-row"
import {
MediaActionMenu,
@@ -28,11 +41,12 @@ import {
useCachedPaginatedQuery,
useCachedQuery,
} from "@/hooks/use-cached-query"
import { useCoverBackgroundColor } from "@/hooks/use-cover-background-color"
import { useCoverPalette } from "@/hooks/use-cover-palette"
import { useMediaMenuActions } from "@/hooks/use-media-menu-actions"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowsePlaylistDetail, BrowseSong } from "@otunes/convex/types"
import type { CoverPalette } from "@/lib/cover-palette"
import { longListProps } from "@/lib/list"
import { rememberSongs } from "@/lib/song-cache"
import { showError, showSuccess } from "@/lib/toast"
@@ -80,13 +94,12 @@ export default function PlaylistScreen() {
playlistId ? { playlistId } : "skip"
)
const coverUri =
config && playlist
? playlistCoverUrl(config.serverUrl, playlist.id ?? "favorites")
config && playlistId
? playlistCoverUrl(config.serverUrl, playlist?.id ?? playlistId)
: ""
const backgroundColor = useCoverBackgroundColor(
const { palette, settled } = useCoverPalette(
coverUri,
playlist?.cover != null,
colors.background
playlist ? playlist.cover != null : playlist === null ? false : undefined
)
useEffect(() => {
@@ -96,7 +109,8 @@ export default function PlaylistScreen() {
if (
playlist === undefined ||
(status === "LoadingFirstPage" && !isCached) ||
!config
!config ||
!settled
) {
return (
<>
@@ -135,7 +149,7 @@ export default function PlaylistScreen() {
songs={songs}
allSongIds={allSongIds}
coverUri={coverUri}
backgroundColor={backgroundColor}
palette={palette}
onEndReached={() => {
if (status === "CanLoadMore") loadMore(PAGE_SIZE)
}}
@@ -148,18 +162,18 @@ function PlaylistContent({
songs,
allSongIds,
coverUri,
backgroundColor,
palette,
onEndReached,
}: {
playlist: BrowsePlaylistDetail
songs: BrowseSong[]
allSongIds: Id<"songs">[] | undefined
coverUri: string
backgroundColor: string
palette: CoverPalette
onEndReached: () => void
}) {
const router = useRouter()
const colors = useThemeColors()
const isFocused = useIsFocused()
const { playPlaylist, playPlaylistShuffled, playFromSong } =
usePlaybackActions()
const { isSongFavorite } = useFavorites()
@@ -174,6 +188,7 @@ function PlaylistContent({
const canEdit = playlist.isOwner && playlistId !== null
const loadedSongIds = useMemo(() => songs.map((song) => song.id), [songs])
const songIds = allSongIds ?? loadedSongIds
const swipeGroup = useSwipeRowGroup()
const handlePlaySong = useCallback(
(song: BrowseSong) => void playFromSong(song.id, songIds),
@@ -188,16 +203,18 @@ function PlaylistContent({
const handleRemoveSong = useCallback(
async (songId: Id<"songs">) => {
if (!playlistId) return
if (!playlistId) return false
try {
await removeSongs({ playlistId, songIds: [songId] })
showSuccess("Removed from playlist")
return true
} catch (error) {
showError(
error instanceof Error
? error.message
: "Failed to remove from playlist"
)
return false
}
},
[playlistId, removeSongs]
@@ -254,6 +271,7 @@ function PlaylistContent({
return {
title: "",
headerLargeTitle: false,
headerTintColor: palette.foreground,
headerRight: () => (
<MediaActionMenu
selectedCount={songIds.length}
@@ -269,7 +287,7 @@ function PlaylistContent({
<Ionicons
name="ellipsis-horizontal"
size={22}
color={colors.foreground}
color={palette.foreground}
/>
</Pressable>
</MediaActionMenu>
@@ -277,9 +295,9 @@ function PlaylistContent({
}
}, [
canEdit,
colors.foreground,
deletePlaylist,
handlePlaylistDetailAction,
palette.foreground,
playlistId,
router,
songIds,
@@ -291,41 +309,49 @@ function PlaylistContent({
song={song}
favorited={isSongFavorite(song.id)}
removable={canEdit}
backgroundColor={backgroundColor}
palette={palette}
swipeGroup={swipeGroup}
onPlay={handlePlaySong}
onAction={handleSongMenuAction}
onRemove={handleRemoveSong}
/>
),
[
backgroundColor,
canEdit,
handlePlaySong,
handleRemoveSong,
handleSongMenuAction,
isSongFavorite,
palette,
swipeGroup,
]
)
return (
<>
{isFocused ? (
<StatusBar style={palette.isDark ? "light" : "dark"} />
) : null}
<Stack.Screen options={screenOptions} />
<FlatList
{...longListProps}
data={songs}
keyExtractor={songKey}
renderItem={renderItem}
style={{ flex: 1, backgroundColor }}
style={{ flex: 1, backgroundColor: palette.background }}
indicatorStyle={palette.isDark ? "white" : "black"}
contentContainerStyle={styles.listContent}
contentInsetAdjustmentBehavior="automatic"
onEndReached={onEndReached}
onEndReachedThreshold={0.5}
onScrollBeginDrag={swipeGroup.closeOpenRow}
ListHeaderComponent={
<PlaylistHero
coverUri={coverUri}
hasCover={playlist.cover != null}
title={playlist.title}
ownerName={playlist.owner.name}
palette={palette}
isSubscribed={isSubscribed}
showSubscribe={!playlist.isOwner && playlistId !== null}
onSubscribeToggle={handleSubscribeToggle}
@@ -346,7 +372,8 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
song,
favorited,
removable,
backgroundColor,
palette,
swipeGroup,
onPlay,
onAction,
onRemove,
@@ -354,17 +381,21 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
song: BrowseSong
favorited: boolean
removable: boolean
backgroundColor: string
palette: CoverPalette
swipeGroup: SwipeRowGroup
onPlay: (song: BrowseSong) => void
onAction: (song: BrowseSong, action: MediaAction) => void
onRemove: (songId: Id<"songs">) => void
onRemove: (songId: Id<"songs">) => Promise<boolean>
}) {
const colors = useThemeColors()
const handleRemove = useCallback(() => onRemove(song.id), [onRemove, song.id])
const row = (
<SongListRow
song={song}
favorited={favorited}
playlistLabel={PLAYLIST_LABEL}
palette={palette}
inset
onPlay={onPlay}
onAction={onAction}
/>
@@ -374,6 +405,19 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
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}
@@ -381,14 +425,14 @@ const PlaylistSongRow = memo(function PlaylistSongRow({
overshootRight={false}
enableTrackpadTwoFingerGesture
containerStyle={{ backgroundColor: colors.destructive }}
childrenContainerStyle={{ backgroundColor }}
childrenContainerStyle={{ backgroundColor: palette.background }}
renderRightActions={(_progress, _translation, swipeable) => (
<Pressable
accessibilityRole="button"
accessibilityLabel={`Remove ${song.title} from playlist`}
onPress={() => {
swipeable.close()
onRemove(song.id)
void handleRemove()
}}
style={[styles.removeAction, { backgroundColor: colors.destructive }]}
>
@@ -414,6 +458,7 @@ const PlaylistHero = memo(function PlaylistHero({
hasCover,
title,
ownerName,
palette,
isSubscribed,
showSubscribe = false,
onSubscribeToggle,
@@ -424,59 +469,69 @@ const PlaylistHero = memo(function PlaylistHero({
hasCover: boolean
title: string
ownerName: string
palette: CoverPalette
isSubscribed?: boolean
showSubscribe?: boolean
onSubscribeToggle?: () => void
onPlay: () => void
onShuffle: () => void
}) {
const colors = useThemeColors()
return (
<View style={styles.hero}>
<CoverImage uri={coverUri} hasCover={hasCover} style={styles.cover} />
<Text style={[styles.title, { color: colors.foreground }]}>{title}</Text>
<Text style={{ color: colors.mutedForeground }}>{ownerName}</Text>
<View style={styles.actions}>
{showSubscribe ? (
<View>
<View style={styles.hero}>
<CoverImage uri={coverUri} hasCover={hasCover} style={styles.cover} />
<Text style={[styles.title, { color: palette.foreground }]}>
{title}
</Text>
<Text style={{ color: palette.secondaryForeground }}>{ownerName}</Text>
<View style={styles.actions}>
{showSubscribe ? (
<Pressable
accessibilityRole="button"
accessibilityLabel={isSubscribed ? "Subscribed" : "Subscribe"}
accessibilityState={{ selected: isSubscribed }}
hitSlop={8}
onPress={onSubscribeToggle}
style={[
styles.iconAction,
{
backgroundColor: isSubscribed
? palette.surface
: palette.accent,
},
]}
>
<Ionicons
name={isSubscribed ? "checkmark" : "add"}
size={24}
color={
isSubscribed ? palette.foreground : palette.accentForeground
}
/>
</Pressable>
) : null}
<Button
title="Play"
icon="play"
onPress={onPlay}
style={styles.playButton}
tint={{
background: palette.accent,
foreground: palette.accentForeground,
}}
/>
<Pressable
accessibilityRole="button"
accessibilityLabel={isSubscribed ? "Subscribed" : "Subscribe"}
accessibilityState={{ selected: isSubscribed }}
accessibilityLabel="Shuffle"
hitSlop={8}
onPress={onSubscribeToggle}
style={[
styles.iconAction,
{
backgroundColor: isSubscribed ? colors.muted : colors.primary,
},
]}
onPress={onShuffle}
style={[styles.iconAction, { backgroundColor: palette.surface }]}
>
<Ionicons
name={isSubscribed ? "checkmark" : "add"}
size={24}
color={
isSubscribed ? colors.foreground : colors.primaryForeground
}
/>
<Ionicons name="shuffle" size={24} color={palette.foreground} />
</Pressable>
) : null}
<Button
title="Play"
icon="play"
onPress={onPlay}
style={styles.playButton}
/>
<Pressable
accessibilityRole="button"
accessibilityLabel="Shuffle"
hitSlop={8}
onPress={onShuffle}
style={[styles.iconAction, { backgroundColor: colors.muted }]}
>
<Ionicons name="shuffle" size={24} color={colors.foreground} />
</Pressable>
</View>
</View>
<CollectionDivider color={palette.divider} />
</View>
)
})
@@ -8,6 +8,7 @@ import {
type ListRenderItemInfo,
} from "react-native"
import { CollectionDivider } from "@/components/collection-list"
import { CollectionDetailSkeleton } from "@/components/skeletons"
import { Button } from "@/components/ui/primitives"
import { contentBottomInset, SongListRow } from "@/components/player"
@@ -79,6 +80,7 @@ export default function FavoritesScreen() {
song={song}
favorited={isSongFavorite(song.id)}
playlistLabel="Add to Another Playlist"
inset
onPlay={handlePlaySong}
onAction={handleSongMenuAction}
/>
@@ -155,34 +157,39 @@ const FavoritesHero = memo(function FavoritesHero({
const colors = useThemeColors()
return (
<View style={styles.hero}>
<View
style={[
styles.cover,
styles.coverPlaceholder,
{ backgroundColor: colors.coverPlaceholder },
]}
>
<Ionicons name="star" size={120} color={colors.primary} />
</View>
<Text style={[styles.title, { color: colors.foreground }]}>{title}</Text>
<View style={styles.actions}>
<Button
title="Play"
icon="play"
onPress={onPlay}
style={styles.playButton}
/>
<Pressable
accessibilityRole="button"
accessibilityLabel="Shuffle"
hitSlop={8}
onPress={onShuffle}
style={[styles.iconAction, { backgroundColor: colors.muted }]}
<View>
<View style={styles.hero}>
<View
style={[
styles.cover,
styles.coverPlaceholder,
{ backgroundColor: colors.coverPlaceholder },
]}
>
<Ionicons name="shuffle" size={24} color={colors.foreground} />
</Pressable>
<Ionicons name="star" size={120} color={colors.primary} />
</View>
<Text style={[styles.title, { color: colors.foreground }]}>
{title}
</Text>
<View style={styles.actions}>
<Button
title="Play"
icon="play"
onPress={onPlay}
style={styles.playButton}
/>
<Pressable
accessibilityRole="button"
accessibilityLabel="Shuffle"
hitSlop={8}
onPress={onShuffle}
style={[styles.iconAction, { backgroundColor: colors.muted }]}
>
<Ionicons name="shuffle" size={24} color={colors.foreground} />
</Pressable>
</View>
</View>
<CollectionDivider />
</View>
)
})
+79 -65
View File
@@ -476,77 +476,82 @@ function UsersSection({
title="People"
subtitle="Manage who can access this server."
>
{users.map((user, index) => (
<View key={user._id}>
{index > 0 ? (
<View
style={[styles.divider, { backgroundColor: colors.border }]}
/>
) : null}
<View style={styles.userRow}>
<ProfileAvatar user={user} size={44} />
<View style={styles.userCopy}>
<View style={styles.userNameRow}>
<View style={styles.userList}>
{users.map((user, index) => (
<View
key={user._id}
style={[
styles.userBlock,
index > 0
? [styles.userBlockSpaced, { borderTopColor: colors.border }]
: null,
]}
>
<View style={styles.userRow}>
<ProfileAvatar user={user} size={44} />
<View style={styles.userCopy}>
<View style={styles.userNameRow}>
<Text
style={[styles.userName, { color: colors.foreground }]}
numberOfLines={1}
>
{user.name}
</Text>
{user.isAdmin ? (
<View
style={[styles.badge, { backgroundColor: colors.muted }]}
>
<Text
style={[
styles.badgeText,
{ color: colors.mutedForeground },
]}
>
Admin
</Text>
</View>
) : null}
</View>
<Text
style={[styles.userName, { color: colors.foreground }]}
style={{ color: colors.mutedForeground }}
numberOfLines={1}
>
{user.name}
{user.email}
</Text>
{user.isAdmin ? (
<View
style={[styles.badge, { backgroundColor: colors.muted }]}
>
<Text
style={[
styles.badgeText,
{ color: colors.mutedForeground },
]}
>
Admin
</Text>
</View>
) : null}
</View>
<Text
style={{ color: colors.mutedForeground }}
numberOfLines={1}
>
{user.email}
</Text>
</View>
{user._id !== currentUserId ? (
<View style={styles.userActions}>
<Button
title={user.isAdmin ? "Remove Admin" : "Make Admin"}
variant="secondary"
onPress={() =>
void setAdmin({
userId: user._id,
isAdmin: !user.isAdmin,
}).then(
() => showSuccess("Updated permissions"),
(error: Error) => showError(error.message)
)
}
style={styles.userActionButton}
/>
<Button
title="Delete"
variant="destructive"
onPress={() =>
void deleteUserMutation({ userId: user._id }).then(
() => showSuccess("User deleted"),
(error: Error) => showError(error.message)
)
}
style={styles.userActionButton}
/>
</View>
) : null}
</View>
{user._id !== currentUserId ? (
<View style={styles.userActions}>
<Button
title={user.isAdmin ? "Remove Admin" : "Make Admin"}
variant="secondary"
onPress={() =>
void setAdmin({
userId: user._id,
isAdmin: !user.isAdmin,
}).then(
() => showSuccess("Updated permissions"),
(error: Error) => showError(error.message)
)
}
style={styles.userActionButton}
/>
<Button
title="Delete"
variant="destructive"
onPress={() =>
void deleteUserMutation({ userId: user._id }).then(
() => showSuccess("User deleted"),
(error: Error) => showError(error.message)
)
}
style={styles.userActionButton}
/>
</View>
) : null}
</View>
))}
))}
</View>
</SettingsCard>
</>
)
@@ -833,6 +838,16 @@ const styles = StyleSheet.create({
alignItems: "center",
gap: spacing.md,
},
userList: {
gap: spacing.lg,
},
userBlock: {
gap: spacing.md,
},
userBlockSpaced: {
paddingTop: spacing.lg,
borderTopWidth: StyleSheet.hairlineWidth,
},
userRow: {
flexDirection: "row",
alignItems: "center",
@@ -855,7 +870,6 @@ const styles = StyleSheet.create({
userActions: {
flexDirection: "row",
gap: spacing.sm,
marginTop: spacing.md,
},
userActionButton: {
flex: 1,
@@ -16,17 +16,18 @@ export default function LibraryLayout() {
screenOptions={({ route }) => ({
...baseOptions,
title: tabStackScreenTitles[route.name] ?? "Library",
headerRight: route.name === "settings" ? undefined : () => <ProfileHeaderButton />,
headerRight:
route.name === "index" ? () => <ProfileHeaderButton /> : undefined,
unstable_headerRightItems:
route.name === "settings"
? undefined
: () => [
route.name === "index"
? () => [
{
type: "custom",
element: <ProfileHeaderButton />,
hidesSharedBackground: true,
},
],
]
: undefined,
})}
/>
)
@@ -16,17 +16,18 @@ export default function SearchLayout() {
screenOptions={({ route }) => ({
...baseOptions,
title: tabStackScreenTitles[route.name] ?? "Search",
headerRight: route.name === "settings" ? undefined : () => <ProfileHeaderButton />,
headerRight:
route.name === "index" ? () => <ProfileHeaderButton /> : undefined,
unstable_headerRightItems:
route.name === "settings"
? undefined
: () => [
route.name === "index"
? () => [
{
type: "custom",
element: <ProfileHeaderButton />,
hidesSharedBackground: true,
},
],
]
: undefined,
})}
/>
)
@@ -0,0 +1,46 @@
import { memo } from "react"
import { StyleSheet, Text, View } from "react-native"
import { useThemeColors } from "@/lib/theme"
/** Horizontal inset for rows and dividers in album and playlist track lists. */
export const collectionInset = 20
/** Separates a collection's header from its track list. */
export function CollectionDivider({ color }: { color?: string }) {
const colors = useThemeColors()
return (
<View
style={[styles.divider, { backgroundColor: color ?? colors.border }]}
/>
)
}
export const DiscHeader = memo(function DiscHeader({
label,
color,
}: {
label: string
color?: string
}) {
const colors = useThemeColors()
return (
<Text style={[styles.discHeader, { color: color ?? colors.foreground }]}>
{label}
</Text>
)
})
const styles = StyleSheet.create({
divider: {
height: StyleSheet.hairlineWidth,
marginHorizontal: collectionInset,
},
discHeader: {
fontSize: 17,
fontWeight: "700",
paddingHorizontal: collectionInset,
paddingTop: 24,
paddingBottom: 8,
},
})
@@ -0,0 +1,359 @@
import * as Haptics from "expo-haptics"
import { SymbolView } from "expo-symbols"
import { useCallback, useMemo, useState, type ReactNode } from "react"
import {
PlatformColor,
Pressable,
StyleSheet,
type LayoutChangeEvent,
} from "react-native"
import { Gesture, GestureDetector } from "react-native-gesture-handler"
import Animated, {
cancelAnimation,
Extrapolation,
interpolate,
useAnimatedStyle,
useSharedValue,
withSpring,
withTiming,
} from "react-native-reanimated"
import { scheduleOnRN } from "react-native-worklets"
const ACTION_WIDTH = 82
const CARD_ROUNDING_REVEAL = 40
const PILL_MIN_MARGIN = 10
const PILL_COMMITTED_MARGIN = 6
const PILL_WIDTH_INPUT = [24, ACTION_WIDTH, 220]
const PILL_WIDTH_OUTPUT = [0, 62, 200]
const PILL_HEIGHT_INPUT = [0, 24, 62, 140, 200]
const PILL_HEIGHT_RATIO = [0, 0.3, 0.77, 0.82, 0.86]
const ICON_FULL_SIZE_REVEAL = 64
const FULL_SWIPE_RATIO = 0.55
const FLING_VELOCITY = 400
const SETTLE_SPRING = { duration: 450, dampingRatio: 1 }
const LABEL_SPRING = { duration: 300, dampingRatio: 0.85 }
const SLIDE_OUT = { duration: 200 }
const COLLAPSE = { duration: 250 }
/**
* Keeps at most one row open, like a `UITableView`: opening a row closes the
* previous one, and `closeOpenRow` closes whichever is open (call it when the
* list starts scrolling).
*/
export type SwipeRowGroup = {
setOpen: (close: () => void) => void
clear: (close: () => void) => void
closeOpenRow: () => void
}
export function useSwipeRowGroup(): SwipeRowGroup {
const [group] = useState<SwipeRowGroup>(() => {
let openRowClose: (() => void) | null = null
return {
setOpen(close) {
if (openRowClose && openRowClose !== close) openRowClose()
openRowClose = close
},
clear(close) {
if (openRowClose === close) openRowClose = null
},
closeOpenRow() {
openRowClose?.()
openRowClose = null
},
}
})
return group
}
type SwipeToRemoveRowProps = {
group: SwipeRowGroup
backgroundColor: string
actionAccessibilityLabel: string
/** Resolves `false` if the removal failed, which restores the row. */
onRemove: () => Promise<boolean>
children: ReactNode
}
/**
* The iOS 26 trailing swipe-to-delete row: the row lifts into a rounded card
* and a red pill grows in the revealed space. Release past half the pill to
* leave it open, or drag past the full-swipe point (haptic, the pill fills the
* space) to remove on release.
*/
export function SwipeToRemoveRow(props: SwipeToRemoveRowProps) {
const [generation, setGeneration] = useState(0)
const restore = useCallback(() => setGeneration((value) => value + 1), [])
return <SwipeRowBody key={generation} {...props} onRestore={restore} />
}
function SwipeRowBody({
group,
backgroundColor,
actionAccessibilityLabel,
onRemove,
onRestore,
children,
}: SwipeToRemoveRowProps & { onRestore: () => void }) {
const width = useSharedValue(0)
const height = useSharedValue(0)
const translateX = useSharedValue(0)
const startX = useSharedValue(0)
const committed = useSharedValue(false)
const commitProgress = useSharedValue(0)
const collapse = useSharedValue(0)
const removing = useSharedValue(false)
const [isOpen, setIsOpen] = useState(false)
const close = useCallback(() => {
if (removing.value) return
translateX.value = withSpring(0, SETTLE_SPRING)
setIsOpen(false)
}, [removing, translateX])
const handleSwipeStart = useCallback(() => group.setOpen(close), [close, group])
const handleSettle = useCallback(
(open: boolean) => {
setIsOpen(open)
if (!open) group.clear(close)
},
[close, group]
)
const handleRemove = useCallback(async () => {
group.clear(close)
if (!(await onRemove())) onRestore()
}, [close, group, onRemove, onRestore])
const animateRemoval = useCallback(() => {
"worklet"
removing.value = true
commitProgress.value = withSpring(1, LABEL_SPRING)
translateX.value = withTiming(-width.value, SLIDE_OUT, (slid) => {
if (!slid) return
collapse.value = withTiming(1, COLLAPSE, (collapsed) => {
if (collapsed) scheduleOnRN(handleRemove)
})
})
}, [collapse, commitProgress, handleRemove, removing, translateX, width])
const pan = useMemo(() => {
const gesture = Gesture.Pan()
.failOffsetY([-10, 10])
.onStart(() => {
if (removing.value) return
cancelAnimation(translateX)
startX.value = translateX.value
scheduleOnRN(handleSwipeStart)
})
.onUpdate((event) => {
if (removing.value) return
const rowWidth = width.value
const x = Math.max(
-rowWidth,
Math.min(0, startX.value + event.translationX)
)
translateX.value = x
const shouldCommit = -x > rowWidth * FULL_SWIPE_RATIO
if (shouldCommit !== committed.value) {
committed.value = shouldCommit
commitProgress.value = withSpring(shouldCommit ? 1 : 0, LABEL_SPRING)
scheduleOnRN(impact)
}
})
.onEnd((event) => {
if (removing.value) return
if (committed.value) {
animateRemoval()
return
}
const velocity = event.velocityX
const open =
velocity < -FLING_VELOCITY ||
(velocity <= FLING_VELOCITY && translateX.value < -ACTION_WIDTH / 2)
translateX.value = withSpring(open ? -ACTION_WIDTH : 0, {
...SETTLE_SPRING,
velocity,
})
scheduleOnRN(handleSettle, open)
})
return isOpen
? gesture.activeOffsetX([-10, 10])
: gesture.activeOffsetX(-10).failOffsetX(10)
}, [
animateRemoval,
commitProgress,
committed,
handleSettle,
handleSwipeStart,
isOpen,
removing,
startX,
translateX,
width,
])
const handleLayout = useCallback(
(event: LayoutChangeEvent) => {
if (removing.value) return
width.value = event.nativeEvent.layout.width
height.value = event.nativeEvent.layout.height
},
[height, removing, width]
)
const containerStyle = useAnimatedStyle(() =>
collapse.value > 0 ? { height: height.value * (1 - collapse.value) } : {}
)
const contentStyle = useAnimatedStyle(() => ({
borderRadius: interpolate(
-translateX.value,
[0, CARD_ROUNDING_REVEAL],
[0, height.value / 2],
Extrapolation.CLAMP
),
transform: [{ translateX: translateX.value }],
}))
const cardFillStyle = useAnimatedStyle(() => ({
opacity: interpolate(
-translateX.value,
[0, CARD_ROUNDING_REVEAL],
[0, 1],
Extrapolation.CLAMP
),
}))
const actionStyle = useAnimatedStyle(() => ({
width: -translateX.value,
}))
// The pill grows out of a dot centered in the revealed space; past the
// full-swipe point it stretches to fill that space.
const pillStyle = useAnimatedStyle(() => {
const revealed = -translateX.value
const rowHeight = height.value
const resting = Math.min(
revealed - PILL_MIN_MARGIN * 2,
interpolate(
revealed,
PILL_WIDTH_INPUT,
PILL_WIDTH_OUTPUT,
Extrapolation.EXTEND
)
)
const pillWidth = Math.max(
0,
resting +
(revealed - PILL_COMMITTED_MARGIN * 2 - resting) *
commitProgress.value
)
const restingHeight = interpolate(
pillWidth,
PILL_HEIGHT_INPUT,
PILL_HEIGHT_RATIO.map((ratio) => ratio * rowHeight),
Extrapolation.CLAMP
)
const pillHeight =
restingHeight +
(rowHeight - PILL_COMMITTED_MARGIN * 2 - restingHeight) *
commitProgress.value
return {
width: pillWidth,
height: pillHeight,
borderRadius: pillHeight / 2,
opacity: 1 - collapse.value,
}
})
const iconStyle = useAnimatedStyle(() => ({
transform: [
{
scale: interpolate(
-translateX.value,
[PILL_WIDTH_INPUT[0], ICON_FULL_SIZE_REVEAL],
[0, 1],
Extrapolation.CLAMP
),
},
],
}))
return (
<Animated.View
onLayout={handleLayout}
style={[styles.container, containerStyle]}
>
<Animated.View style={[styles.action, actionStyle]}>
<Pressable
accessibilityRole="button"
accessibilityLabel={actionAccessibilityLabel}
onPress={() => animateRemoval()}
style={styles.actionButton}
>
<Animated.View style={[styles.pill, pillStyle]}>
<Animated.View style={iconStyle}>
<SymbolView
name="minus.circle.fill"
size={20}
tintColor="white"
/>
</Animated.View>
</Animated.View>
</Pressable>
</Animated.View>
<GestureDetector gesture={pan}>
<Animated.View style={[styles.card, { backgroundColor }, contentStyle]}>
<Animated.View
pointerEvents="none"
style={[styles.cardFill, cardFillStyle]}
/>
{children}
{isOpen ? (
<Pressable
accessible={false}
onPress={close}
style={StyleSheet.absoluteFill}
/>
) : null}
</Animated.View>
</GestureDetector>
</Animated.View>
)
}
function impact() {
void Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Medium)
}
const styles = StyleSheet.create({
container: { overflow: "hidden" },
card: { overflow: "hidden" },
cardFill: {
...StyleSheet.absoluteFill,
backgroundColor: PlatformColor("tertiarySystemFill"),
},
action: {
position: "absolute",
top: 0,
right: 0,
bottom: 0,
},
actionButton: {
flex: 1,
alignItems: "center",
justifyContent: "center",
},
pill: {
alignItems: "center",
justifyContent: "center",
overflow: "hidden",
backgroundColor: PlatformColor("systemRed"),
},
})
+63 -13
View File
@@ -1,6 +1,8 @@
import { collectionInset } from "@/components/collection-list"
import { CoverImage } from "@/components/cover-image"
import { useServerConfig } from "@/contexts/server-config"
import type { BrowseSong } from "@otunes/convex/types"
import type { CoverPalette } from "@/lib/cover-palette"
import { formatDuration } from "@/lib/format"
import { albumCoverUrl } from "@/lib/urls"
import { miniPlayerHeight, spacing, useThemeColors } from "@/lib/theme"
@@ -18,6 +20,8 @@ export const SongRow = memo(function SongRow({
onPress,
contextMenu,
trailing,
palette,
inset = false,
}: {
song: BrowseSong
onPress?: () => void
@@ -25,14 +29,41 @@ export const SongRow = memo(function SongRow({
onAction: MediaMenuConfig["onAction"]
}
trailing?: React.ReactNode
palette?: Pick<CoverPalette, "foreground" | "secondaryForeground" | "divider">
/** Album/playlist layout: the divider starts at the title, not the artwork. */
inset?: boolean
}) {
const { config } = useServerConfig()
const colors = useThemeColors()
if (!config) return null
const foreground = palette?.foreground ?? colors.foreground
const secondaryForeground =
palette?.secondaryForeground ?? colors.mutedForeground
const divider = palette?.divider ?? colors.border
const content = (
<>
<View style={styles.rowMeta}>
<Text style={[styles.rowTitle, { color: foreground }]} numberOfLines={1}>
{song.title}
</Text>
<Text style={[styles.rowSubtitle, { color: secondaryForeground }]} numberOfLines={1}>
{song.artist.name} · {song.album.title}
</Text>
</View>
<Text style={[styles.duration, { color: secondaryForeground }]}>
{formatDuration(song.durationSeconds)}
</Text>
{trailing}
</>
)
const row = (
<Pressable
style={[styles.row, { borderBottomColor: colors.border }]}
style={
inset ? styles.insetRow : [styles.row, { borderBottomColor: divider }]
}
onPress={onPress}
>
<CoverImage
@@ -40,18 +71,13 @@ export const SongRow = memo(function SongRow({
hasCover={song.album.cover != null}
style={styles.rowArtwork}
/>
<View style={styles.rowMeta}>
<Text style={[styles.rowTitle, { color: colors.foreground }]} numberOfLines={1}>
{song.title}
</Text>
<Text style={[styles.rowSubtitle, { color: colors.mutedForeground }]} numberOfLines={1}>
{song.artist.name} · {song.album.title}
</Text>
</View>
<Text style={[styles.duration, { color: colors.mutedForeground }]}>
{formatDuration(song.durationSeconds)}
</Text>
{trailing}
{inset ? (
<View style={[styles.insetContent, { borderBottomColor: divider }]}>
{content}
</View>
) : (
content
)}
</Pressable>
)
@@ -75,12 +101,16 @@ export const SongListRow = memo(function SongListRow({
song,
favorited,
playlistLabel,
palette,
inset,
onPlay,
onAction,
}: {
song: BrowseSong
favorited: boolean
playlistLabel?: string
palette?: Pick<CoverPalette, "foreground" | "secondaryForeground" | "divider">
inset?: boolean
onPlay: (song: BrowseSong) => void
onAction: (song: BrowseSong, action: MediaAction) => void
}) {
@@ -89,6 +119,8 @@ export const SongListRow = memo(function SongListRow({
return (
<SongRow
song={song}
palette={palette}
inset={inset}
onPress={handlePress}
contextMenu={{
favorited,
@@ -121,6 +153,24 @@ const styles = StyleSheet.create({
paddingHorizontal: spacing.lg,
borderBottomWidth: StyleSheet.hairlineWidth,
},
insetRow: {
flexDirection: "row",
alignItems: "center",
gap: spacing.md,
paddingLeft: collectionInset,
},
insetContent: {
flex: 1,
minWidth: 0,
flexDirection: "row",
alignItems: "center",
alignSelf: "stretch",
gap: spacing.md,
minHeight: 64,
paddingVertical: 10,
marginRight: collectionInset,
borderBottomWidth: StyleSheet.hairlineWidth,
},
rowArtwork: {
width: 44,
height: 44,
+9 -4
View File
@@ -20,6 +20,8 @@ type ButtonProps = Omit<PressableProps, "style"> & {
loading?: boolean
icon?: React.ComponentProps<typeof Ionicons>["name"]
style?: StyleProp<ViewStyle>
/** Overrides the variant's colors, e.g. on screens tinted by cover art. */
tint?: { background: string; foreground: string }
}
export function Button({
@@ -29,13 +31,15 @@ export function Button({
disabled,
icon,
style,
tint,
...props
}: ButtonProps) {
const colors = useThemeColors()
const isDisabled = disabled || loading
const backgroundColor =
variant === "primary"
const backgroundColor = tint
? tint.background
: variant === "primary"
? colors.primary
: variant === "secondary"
? colors.muted
@@ -43,8 +47,9 @@ export function Button({
? colors.destructive
: "transparent"
const textColor =
variant === "primary"
const textColor = tint
? tint.foreground
: variant === "primary"
? colors.primaryForeground
: variant === "destructive"
? "#fff"
@@ -1,58 +0,0 @@
import { useEffect, useState } from "react"
import { getColors, type ImageColorsResult } from "react-native-image-colors"
import { withCoverImageSize } from "@/lib/urls"
function prominentColor(result: ImageColorsResult): string {
switch (result.platform) {
case "ios":
return result.primary || result.background
case "android":
return result.vibrant || result.dominant || result.average
case "web":
return result.vibrant || result.dominant
}
}
export function useCoverBackgroundColor(
uri: string,
hasCover: boolean,
fallback: string,
) {
const [backgroundColor, setBackgroundColor] = useState(fallback)
useEffect(() => {
let cancelled = false
if (!hasCover) {
setBackgroundColor(fallback)
return
}
setBackgroundColor(fallback)
const colorSourceUri = withCoverImageSize(uri, 64)
void getColors(colorSourceUri, {
fallback,
cache: true,
key: colorSourceUri,
quality: "low",
pixelSpacing: 8,
})
.then((result) => {
if (!cancelled) {
setBackgroundColor(prominentColor(result))
}
})
.catch(() => {
if (!cancelled) {
setBackgroundColor(fallback)
}
})
return () => {
cancelled = true
}
}, [fallback, hasCover, uri])
return backgroundColor
}
+163
View File
@@ -0,0 +1,163 @@
import { useEffect, useMemo, useState } from "react"
import { getColors, type ImageColorsResult } from "react-native-image-colors"
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"
// 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
// 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)
return readCache<CoverSwatches>(cacheKey(key))
}
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
}
/**
* 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
): { 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,
}
}
+296
View File
@@ -0,0 +1,296 @@
import type { ThemeColors } from "@/lib/theme"
/**
* Colors for a screen tinted by its cover art, modeled on Apple Music's
* artwork colors (`bgColor`, `textColor1`, `textColor2`).
*/
export type CoverPalette = {
background: string
foreground: string
secondaryForeground: string
accent: string
accentForeground: string
/** `accent` adjusted to be legible as body text. */
accentText: string
surface: string
divider: string
isDark: boolean
}
/**
* 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
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 themeCoverPalette(theme: ThemeColors, isDark: boolean): CoverPalette {
return {
background: theme.background,
foreground: theme.foreground,
secondaryForeground: theme.mutedForeground,
accent: theme.primary,
accentForeground: theme.primaryForeground,
accentText: theme.primary,
surface: theme.muted,
divider: theme.border,
isDark,
}
}
export function deriveCoverPalette(
swatches: CoverSwatches,
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 -1
View File
@@ -63,5 +63,5 @@ const asyncStorageBackend: PersistentCacheBackend = {
// Android's AsyncStorage database is capped at 6 MB by default, so keep fewer
// entries than the web cache.
configurePersistentCache(asyncStorageBackend, {
maxEntriesByPrefix: { q: 200, song: 3000, files: 500 },
maxEntriesByPrefix: { q: 200, song: 3000, files: 500, palette: 500 },
})