Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
545 lines
13 KiB
TypeScript
545 lines
13 KiB
TypeScript
import { useMediaGridLayout } from "@/hooks/use-media-grid-layout"
|
|
import { useTabletLayout } from "@/hooks/use-tablet-layout"
|
|
import {
|
|
CollectionHero,
|
|
useCollectionHeroLayout,
|
|
} from "@/components/collection-hero"
|
|
import {
|
|
CollectionDivider,
|
|
collectionInset,
|
|
} from "@/components/collection-list"
|
|
import { tabletCardTextHeight } from "@/components/tablet-media-grid"
|
|
import { ScreenTitle } from "@/components/screen-title"
|
|
import { Link } from "expo-router"
|
|
import { useHeaderHeight } from "expo-router/react-navigation"
|
|
import Reanimated from "react-native-reanimated"
|
|
import { type ComponentProps, type ReactNode } from "react"
|
|
import {
|
|
Platform,
|
|
StyleSheet,
|
|
View,
|
|
type DimensionValue,
|
|
type StyleProp,
|
|
type ViewStyle,
|
|
} from "react-native"
|
|
|
|
import { carouselCardWidth, radius, spacing, useThemeColors } from "@/lib/theme"
|
|
|
|
/**
|
|
* Loading screens never scroll, so they cannot rely on scroll-view inset
|
|
* adjustment. iOS headers are transparent and overlap the screen; Android
|
|
* headers are opaque and already sit above it.
|
|
*/
|
|
function SkeletonScreen({
|
|
children,
|
|
style,
|
|
backgroundColor,
|
|
onLayout,
|
|
}: {
|
|
children: ReactNode
|
|
style?: ComponentProps<typeof Reanimated.View>["style"]
|
|
backgroundColor?: string
|
|
onLayout?: () => void
|
|
}) {
|
|
const colors = useThemeColors()
|
|
const headerHeight = useHeaderHeight()
|
|
return (
|
|
<Reanimated.View
|
|
onLayout={onLayout}
|
|
accessibilityLabel="Loading"
|
|
accessibilityRole="progressbar"
|
|
style={[
|
|
styles.screen,
|
|
{
|
|
backgroundColor: backgroundColor ?? colors.background,
|
|
paddingTop: Platform.OS === "ios" ? headerHeight : 0,
|
|
},
|
|
style,
|
|
]}
|
|
>
|
|
{children}
|
|
</Reanimated.View>
|
|
)
|
|
}
|
|
|
|
export function Skeleton({ style }: { style?: StyleProp<ViewStyle> }) {
|
|
const colors = useThemeColors()
|
|
|
|
return (
|
|
<View
|
|
style={[
|
|
{ backgroundColor: colors.muted, borderRadius: radius.sm },
|
|
style,
|
|
]}
|
|
/>
|
|
)
|
|
}
|
|
|
|
/** Occupies the line box of text at `fontSize`, so loaded text lands in place. */
|
|
function TextLine({
|
|
width,
|
|
fontSize,
|
|
}: {
|
|
width: DimensionValue
|
|
fontSize: number
|
|
}) {
|
|
return (
|
|
<View
|
|
style={{
|
|
width,
|
|
height: Math.round(fontSize * 1.2),
|
|
justifyContent: "center",
|
|
}}
|
|
>
|
|
<Skeleton
|
|
style={{ height: Math.round(fontSize * 0.8), borderRadius: 4 }}
|
|
/>
|
|
</View>
|
|
)
|
|
}
|
|
|
|
/** Mirrors `SongRow`, including its `inset` album/playlist layout. */
|
|
export function SongRowSkeleton({ inset = false }: { inset?: boolean }) {
|
|
const colors = useThemeColors()
|
|
const meta = (
|
|
<View style={styles.songMeta}>
|
|
<TextLine width="60%" fontSize={16} />
|
|
<View style={styles.songSubtitle}>
|
|
<TextLine width="40%" fontSize={14} />
|
|
</View>
|
|
</View>
|
|
)
|
|
if (inset) {
|
|
return (
|
|
<View style={styles.insetRow}>
|
|
<Skeleton style={styles.songArtwork} />
|
|
<View
|
|
style={[
|
|
styles.insetSongContent,
|
|
{ borderBottomColor: colors.border },
|
|
]}
|
|
>
|
|
{meta}
|
|
</View>
|
|
</View>
|
|
)
|
|
}
|
|
return (
|
|
<View style={[styles.songRow, { borderBottomColor: colors.border }]}>
|
|
<Skeleton style={styles.songArtwork} />
|
|
{meta}
|
|
</View>
|
|
)
|
|
}
|
|
|
|
function TrackRowSkeleton() {
|
|
const colors = useThemeColors()
|
|
return (
|
|
<View style={styles.trackRow}>
|
|
<View style={styles.trackNumber}>
|
|
<TextLine width={12} fontSize={16} />
|
|
</View>
|
|
<View style={[styles.trackContent, { borderBottomColor: colors.border }]}>
|
|
<TextLine width="55%" fontSize={16} />
|
|
</View>
|
|
</View>
|
|
)
|
|
}
|
|
|
|
function SongRows({ rows, inset }: { rows: number; inset?: boolean }) {
|
|
return Array.from({ length: rows }, (_, index) => (
|
|
<SongRowSkeleton key={index} inset={inset} />
|
|
))
|
|
}
|
|
|
|
export function SongListSkeleton({
|
|
rows = 10,
|
|
title,
|
|
titleAccessory,
|
|
}: {
|
|
rows?: number
|
|
title?: string
|
|
titleAccessory?: ReactNode
|
|
}) {
|
|
return (
|
|
<SkeletonScreen>
|
|
{title ? <ScreenTitle title={title} accessory={titleAccessory} /> : null}
|
|
<SongRows rows={rows} />
|
|
</SkeletonScreen>
|
|
)
|
|
}
|
|
|
|
/** Mirrors the album, playlist, and artist cards in `media-cards`. */
|
|
function CardSkeleton({
|
|
width,
|
|
minHeight,
|
|
round = false,
|
|
}: {
|
|
width: number
|
|
minHeight?: number
|
|
round?: boolean
|
|
}) {
|
|
return (
|
|
<View style={[styles.card, { width, minHeight }]}>
|
|
<Skeleton
|
|
style={{
|
|
width,
|
|
height: width,
|
|
borderRadius: round ? width / 2 : radius.md,
|
|
}}
|
|
/>
|
|
<TextLine width="80%" fontSize={14} />
|
|
{round ? null : <TextLine width="50%" fontSize={12} />}
|
|
</View>
|
|
)
|
|
}
|
|
|
|
/** Mirrors `MediaGridList`: a `FlatList` on phones, `TabletMediaGrid` on iPad. */
|
|
function MediaGridContent({
|
|
items,
|
|
contentInset,
|
|
header,
|
|
}: {
|
|
items: number
|
|
contentInset: boolean
|
|
header?: ReactNode
|
|
}) {
|
|
const tabletLayout = useTabletLayout()
|
|
const { cardWidth, columns, onLayout, horizontalPadding, gap, ready } =
|
|
useMediaGridLayout()
|
|
return (
|
|
<>
|
|
{header}
|
|
<View
|
|
onLayout={onLayout}
|
|
style={[
|
|
styles.grid,
|
|
{
|
|
paddingHorizontal: horizontalPadding,
|
|
paddingTop: contentInset ? horizontalPadding : 0,
|
|
// FlatList applies its content gap after the list header as well.
|
|
marginTop: header && !tabletLayout ? gap : 0,
|
|
gap,
|
|
},
|
|
]}
|
|
>
|
|
{Array.from(
|
|
{ length: ready ? Math.max(items, columns * 3) : 0 },
|
|
(_, index) => (
|
|
<CardSkeleton
|
|
key={index}
|
|
width={cardWidth}
|
|
minHeight={
|
|
tabletLayout ? cardWidth + tabletCardTextHeight : undefined
|
|
}
|
|
/>
|
|
)
|
|
)}
|
|
</View>
|
|
</>
|
|
)
|
|
}
|
|
|
|
export function MediaGridSkeleton({
|
|
items = 6,
|
|
contentInset = true,
|
|
header,
|
|
title,
|
|
titleAccessory,
|
|
}: {
|
|
items?: number
|
|
contentInset?: boolean
|
|
/** The loaded list's `ListHeaderComponent`, so it keeps its position. */
|
|
header?: ReactNode
|
|
/** The loaded list's `ScreenTitle`, which replaces its top inset. */
|
|
title?: string
|
|
titleAccessory?: ReactNode
|
|
}) {
|
|
return (
|
|
<SkeletonScreen>
|
|
<MediaGridContent
|
|
items={items}
|
|
contentInset={contentInset && !title}
|
|
header={
|
|
title ? (
|
|
<>
|
|
<MediaGridTitle title={title} accessory={titleAccessory} />
|
|
{header}
|
|
</>
|
|
) : (
|
|
header
|
|
)
|
|
}
|
|
/>
|
|
</SkeletonScreen>
|
|
)
|
|
}
|
|
|
|
function MediaGridTitle({
|
|
title,
|
|
accessory,
|
|
}: {
|
|
title: string
|
|
accessory?: ReactNode
|
|
}) {
|
|
const { horizontalPadding } = useMediaGridLayout()
|
|
return (
|
|
<ScreenTitle
|
|
title={title}
|
|
accessory={accessory}
|
|
style={{ paddingHorizontal: horizontalPadding }}
|
|
/>
|
|
)
|
|
}
|
|
|
|
export function CarouselSkeleton() {
|
|
return (
|
|
<View style={styles.carousel}>
|
|
<TextLine width={160} fontSize={22} />
|
|
<View style={styles.carouselRow}>
|
|
{Array.from({ length: 8 }, (_, index) => (
|
|
<CardSkeleton key={index} width={carouselCardWidth} />
|
|
))}
|
|
</View>
|
|
</View>
|
|
)
|
|
}
|
|
|
|
export function HomeSkeleton({
|
|
title,
|
|
titleAccessory,
|
|
}: {
|
|
title: string
|
|
titleAccessory?: ReactNode
|
|
}) {
|
|
return (
|
|
<SkeletonScreen>
|
|
<View style={styles.home}>
|
|
<ScreenTitle
|
|
title={title}
|
|
accessory={titleAccessory}
|
|
style={styles.homeTitle}
|
|
/>
|
|
<CarouselSkeleton />
|
|
<CarouselSkeleton />
|
|
</View>
|
|
</SkeletonScreen>
|
|
)
|
|
}
|
|
|
|
function HeroActions({
|
|
favorite = true,
|
|
reverse = false,
|
|
}: {
|
|
favorite?: boolean
|
|
reverse?: boolean
|
|
}) {
|
|
return (
|
|
<View style={[styles.actions, reverse && styles.actionsReverse]}>
|
|
{favorite ? <Skeleton style={styles.iconAction} /> : null}
|
|
<Skeleton style={styles.playButton} />
|
|
<Skeleton style={styles.iconAction} />
|
|
</View>
|
|
)
|
|
}
|
|
|
|
/** Album and playlist pages: cover, title, play buttons, then tracks. */
|
|
export function CollectionDetailSkeleton({
|
|
variant,
|
|
style,
|
|
backgroundColor,
|
|
onLayout,
|
|
}: {
|
|
variant: "album" | "playlist" | "favorites" | "artist"
|
|
style?: ComponentProps<typeof Reanimated.View>["style"]
|
|
backgroundColor?: string
|
|
onLayout?: () => void
|
|
}) {
|
|
const { landscape, coverSize: tabletCoverSize } = useCollectionHeroLayout()
|
|
|
|
if (variant === "artist" || variant === "favorites") {
|
|
const artist = variant === "artist"
|
|
const coverSize = artist ? 180 : 200
|
|
const hero = (
|
|
<View style={styles.centeredHero}>
|
|
<Skeleton
|
|
style={{
|
|
width: coverSize,
|
|
height: coverSize,
|
|
borderRadius: artist ? coverSize / 2 : radius.lg,
|
|
}}
|
|
/>
|
|
<TextLine width={200} fontSize={artist ? 28 : 24} />
|
|
<HeroActions favorite={artist} />
|
|
</View>
|
|
)
|
|
return (
|
|
<SkeletonScreen
|
|
style={style}
|
|
backgroundColor={backgroundColor}
|
|
onLayout={onLayout}
|
|
>
|
|
{artist ? (
|
|
<MediaGridContent items={4} contentInset={false} header={hero} />
|
|
) : (
|
|
<>
|
|
{hero}
|
|
<CollectionDivider />
|
|
<SongRows rows={8} inset />
|
|
</>
|
|
)}
|
|
</SkeletonScreen>
|
|
)
|
|
}
|
|
|
|
const album = variant === "album"
|
|
const coverSize = tabletCoverSize ?? (album ? 220 : 200)
|
|
return (
|
|
<SkeletonScreen
|
|
style={style}
|
|
backgroundColor={backgroundColor}
|
|
onLayout={onLayout}
|
|
>
|
|
<CollectionHero
|
|
artwork={
|
|
<Link.AppleZoomTarget>
|
|
<View collapsable={false}>
|
|
<Skeleton
|
|
style={{
|
|
width: coverSize,
|
|
height: coverSize,
|
|
borderRadius: radius.lg,
|
|
}}
|
|
/>
|
|
</View>
|
|
</Link.AppleZoomTarget>
|
|
}
|
|
actions={<HeroActions favorite={album} reverse={landscape} />}
|
|
>
|
|
<TextLine
|
|
width={landscape ? "85%" : 200}
|
|
fontSize={landscape ? 22 : 24}
|
|
/>
|
|
<TextLine
|
|
width={landscape ? "60%" : 120}
|
|
fontSize={landscape ? 22 : 16}
|
|
/>
|
|
{album ? (
|
|
<TextLine width={landscape ? "40%" : 150} fontSize={14} />
|
|
) : null}
|
|
</CollectionHero>
|
|
<CollectionDivider />
|
|
{album ? (
|
|
Array.from({ length: 10 }, (_, index) => (
|
|
<TrackRowSkeleton key={index} />
|
|
))
|
|
) : (
|
|
<SongRows rows={8} inset />
|
|
)}
|
|
</SkeletonScreen>
|
|
)
|
|
}
|
|
|
|
export function ArtistListSkeleton({
|
|
rows = 12,
|
|
title,
|
|
}: {
|
|
rows?: number
|
|
title?: string
|
|
}) {
|
|
const colors = useThemeColors()
|
|
return (
|
|
<SkeletonScreen>
|
|
{title ? <ScreenTitle title={title} /> : null}
|
|
{Array.from({ length: rows }, (_, index) => (
|
|
<View
|
|
key={index}
|
|
style={[styles.artistRow, { borderBottomColor: colors.border }]}
|
|
>
|
|
<Skeleton style={styles.artistAvatar} />
|
|
<TextLine width="50%" fontSize={16} />
|
|
</View>
|
|
))}
|
|
</SkeletonScreen>
|
|
)
|
|
}
|
|
|
|
const styles = StyleSheet.create({
|
|
screen: { flex: 1, overflow: "hidden" },
|
|
songRow: {
|
|
flexDirection: "row",
|
|
alignItems: "center",
|
|
gap: spacing.md,
|
|
minHeight: 64,
|
|
paddingVertical: 10,
|
|
paddingHorizontal: spacing.lg,
|
|
borderBottomWidth: StyleSheet.hairlineWidth,
|
|
},
|
|
insetRow: {
|
|
flexDirection: "row",
|
|
alignItems: "center",
|
|
gap: spacing.md,
|
|
paddingLeft: collectionInset,
|
|
},
|
|
insetSongContent: {
|
|
flex: 1,
|
|
flexDirection: "row",
|
|
alignItems: "center",
|
|
alignSelf: "stretch",
|
|
minHeight: 64,
|
|
paddingVertical: 10,
|
|
marginRight: collectionInset,
|
|
borderBottomWidth: StyleSheet.hairlineWidth,
|
|
},
|
|
songArtwork: { width: 44, height: 44, borderRadius: 6 },
|
|
songMeta: { flex: 1 },
|
|
songSubtitle: { marginTop: 3 },
|
|
trackRow: {
|
|
flexDirection: "row",
|
|
alignItems: "center",
|
|
gap: spacing.sm,
|
|
paddingLeft: collectionInset,
|
|
},
|
|
trackNumber: { width: 24, alignItems: "center" },
|
|
trackContent: {
|
|
flex: 1,
|
|
justifyContent: "center",
|
|
alignSelf: "stretch",
|
|
minHeight: 52,
|
|
paddingVertical: 12,
|
|
marginRight: collectionInset,
|
|
borderBottomWidth: StyleSheet.hairlineWidth,
|
|
},
|
|
card: { gap: spacing.xs },
|
|
grid: { flexDirection: "row", flexWrap: "wrap" },
|
|
carousel: { gap: spacing.md, overflow: "hidden" },
|
|
carouselRow: { flexDirection: "row", gap: spacing.md },
|
|
home: { padding: spacing.lg, gap: spacing.xl },
|
|
// Mirrors the home screen's title spacing.
|
|
homeTitle: {
|
|
paddingHorizontal: 0,
|
|
marginTop: -spacing.lg,
|
|
marginBottom: -spacing.md,
|
|
},
|
|
centeredHero: { alignItems: "center", padding: spacing.lg, gap: spacing.sm },
|
|
actions: {
|
|
flexDirection: "row",
|
|
alignItems: "center",
|
|
justifyContent: "center",
|
|
gap: spacing.sm,
|
|
marginTop: spacing.sm,
|
|
},
|
|
actionsReverse: { flexDirection: "row-reverse" },
|
|
iconAction: { width: 44, height: 44, borderRadius: 22 },
|
|
playButton: { width: 160, height: 44, borderRadius: 999 },
|
|
artistRow: {
|
|
flexDirection: "row",
|
|
alignItems: "center",
|
|
gap: spacing.md,
|
|
paddingHorizontal: spacing.lg,
|
|
paddingVertical: spacing.md,
|
|
borderBottomWidth: StyleSheet.hairlineWidth,
|
|
},
|
|
artistAvatar: { width: 44, height: 44, borderRadius: 22 },
|
|
})
|