486 lines
13 KiB
TypeScript
486 lines
13 KiB
TypeScript
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
|
|
/** Width of each action when two share a side. */
|
|
const PAIRED_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.
|
|
* A full swipe commits the outer action: Add to Queue on the leading side, and
|
|
* Remove on the trailing side when `onRemove` is set, else Download. Download
|
|
* turns into a red Remove Download once `downloaded`.
|
|
*/
|
|
export function SongSwipeRow({
|
|
children,
|
|
style,
|
|
backgroundColor,
|
|
group,
|
|
onPress,
|
|
onPlayNext,
|
|
onAddToQueue,
|
|
onRemove,
|
|
onDownload,
|
|
downloaded = false,
|
|
}: {
|
|
children: ReactNode
|
|
style?: StyleProp<ViewStyle>
|
|
backgroundColor: string
|
|
group: SwipeRowGroup
|
|
onPress?: () => void
|
|
onPlayNext: () => void
|
|
onAddToQueue: () => void
|
|
onRemove?: () => void
|
|
onDownload?: () => void
|
|
downloaded?: boolean
|
|
}) {
|
|
const hasRemove = !!onRemove
|
|
const trailingWidth = hasRemove ? PAIRED_ACTION_WIDTH * 2 : ACTION_WIDTH
|
|
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()
|
|
else if (onRemove) onRemove()
|
|
else onDownload?.()
|
|
},
|
|
[close, onAddToQueue, onRemove, onDownload]
|
|
)
|
|
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 ? PAIRED_ACTION_WIDTH * 2 : trailingWidth,
|
|
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 ? PAIRED_ACTION_WIDTH * 2 : trailingWidth),
|
|
{
|
|
...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,
|
|
begin,
|
|
close,
|
|
commitProgress,
|
|
committed,
|
|
settle,
|
|
startX,
|
|
tapRow,
|
|
trailingWidth,
|
|
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()
|
|
}}
|
|
/>
|
|
<SwipeAction
|
|
side={-1}
|
|
paired={hasRemove}
|
|
remove={hasRemove}
|
|
downloaded={downloaded}
|
|
x={x}
|
|
height={height}
|
|
progress={commitProgress}
|
|
open={open === -1}
|
|
onPress={() => activate(-1)}
|
|
/>
|
|
{hasRemove && (
|
|
<SwipeAction
|
|
side={-1}
|
|
secondary
|
|
paired
|
|
downloaded={downloaded}
|
|
x={x}
|
|
height={height}
|
|
progress={commitProgress}
|
|
open={open === -1}
|
|
onPress={() => {
|
|
close()
|
|
onDownload?.()
|
|
}}
|
|
/>
|
|
)}
|
|
<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: downloaded ? "Remove Download" : "Download",
|
|
},
|
|
...(hasRemove
|
|
? [{ name: "remove", label: "Remove from Playlist" }]
|
|
: []),
|
|
]}
|
|
onAccessibilityAction={(event) => {
|
|
if (event.nativeEvent.actionName === "remove") activate(-1)
|
|
if (event.nativeEvent.actionName === "addToQueue") activate(1)
|
|
if (event.nativeEvent.actionName === "download") {
|
|
close()
|
|
onDownload?.()
|
|
}
|
|
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,
|
|
downloaded = false,
|
|
x,
|
|
height,
|
|
progress,
|
|
open,
|
|
onPress,
|
|
}: {
|
|
side: 1 | -1
|
|
secondary?: boolean
|
|
paired?: boolean
|
|
remove?: boolean
|
|
/** Shows the download action as Remove Download. */
|
|
downloaded?: 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 - (paired ? 10 : 20),
|
|
interpolate(
|
|
revealed,
|
|
[24, paired ? PAIRED_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
|
|
),
|
|
},
|
|
],
|
|
}))
|
|
const removesDownload = side < 0 && !remove && downloaded
|
|
const destructive = remove || removesDownload
|
|
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"
|
|
: removesDownload
|
|
? "Remove Download"
|
|
: side > 0
|
|
? secondary
|
|
? "Play Next"
|
|
: "Add to Queue"
|
|
: "Download"
|
|
}
|
|
onPress={onPress}
|
|
style={styles.actionButton}
|
|
>
|
|
<Animated.View
|
|
style={[
|
|
styles.pill,
|
|
{
|
|
backgroundColor: destructive
|
|
? IS_ANDROID
|
|
? "#d32f2f"
|
|
: "#ff3b30"
|
|
: side > 0
|
|
? secondary
|
|
? "#6b5bff"
|
|
: "#f29943"
|
|
: "#008dff",
|
|
},
|
|
pillStyle,
|
|
]}
|
|
>
|
|
<Animated.View style={iconStyle}>
|
|
{IS_ANDROID ? (
|
|
<Ionicons
|
|
name={
|
|
destructive
|
|
? "trash-outline"
|
|
: side < 0
|
|
? "arrow-down"
|
|
: secondary
|
|
? "play-forward"
|
|
: "list"
|
|
}
|
|
size={22}
|
|
color="white"
|
|
/>
|
|
) : (
|
|
<SymbolView
|
|
name={
|
|
destructive
|
|
? "trash"
|
|
: 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" },
|
|
})
|