# Conflicts: # apps/mobile/app/(app)/(tabs)/home/album/[id].tsx # apps/mobile/app/(app)/(tabs)/home/settings.tsx # apps/mobile/hooks/use-cover-palette.ts # apps/mobile/hooks/use-legacy-cover-palette.ts
149 lines
4.6 KiB
TypeScript
149 lines
4.6 KiB
TypeScript
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,
|
|
}
|
|
}
|
|
|
|
/** Forget in-memory swatches so covers are re-extracted. */
|
|
function clear() {
|
|
swatchesByKey.clear()
|
|
pending.clear()
|
|
}
|
|
|
|
return { prefetch, usePalette, clear }
|
|
}
|
|
|
|
function sameSwatches(a: unknown, b: unknown) {
|
|
return a === b || JSON.stringify(a) === JSON.stringify(b)
|
|
}
|