117 lines
4.0 KiB
TypeScript
117 lines
4.0 KiB
TypeScript
/**
|
|
* Keeping a list of playlists in step with the socket.
|
|
*
|
|
* @module
|
|
*/
|
|
|
|
import { useEffect, useLayoutEffect, useRef } from "react";
|
|
import type { Playlist } from "../../../shared/playlist.ts";
|
|
import { useWS } from "../ws/useWS.ts";
|
|
|
|
/** How {@link usePlaylistListSync} treats the list. */
|
|
export interface PlaylistListSyncOptions {
|
|
/** Keep private playlists visible (caller is the owner). */
|
|
isOwner?: boolean;
|
|
/**
|
|
* Only act on created/updated events for playlists owned by this user.
|
|
* Leave undefined to act on any playlist already in the list.
|
|
*/
|
|
ownerId?: string;
|
|
/**
|
|
* Set true for "followed" lists: never prepend newly created playlists
|
|
* (followed membership is managed separately), but still update/remove.
|
|
*/
|
|
noNewEntries?: boolean;
|
|
/**
|
|
* When true, don't re-add a playlist that isn't in the list (idx === -1).
|
|
* Use this when the caller handles re-insertion itself (e.g. with a position
|
|
* map, like the dumps/votes pattern in UserPublicProfile).
|
|
*/
|
|
skipReinsert?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Keeps the playlist list set through `setPlaylists` in sync with real-time WS
|
|
* events.
|
|
*
|
|
* - a playlist created → prepended (unless `noNewEntries`)
|
|
* - a playlist updated → updated in place, or removed if now private
|
|
* - a playlist deleted → removed
|
|
* - a playlist's dumps changed → its `dumpCount` updated
|
|
*/
|
|
export function usePlaylistListSync(
|
|
setPlaylists: (fn: (prev: Playlist[]) => Playlist[]) => void,
|
|
options?: PlaylistListSyncOptions,
|
|
): void {
|
|
const { lastPlaylistEvent, deletedPlaylistIds } = useWS();
|
|
|
|
const setPlaylistsRef = useRef(setPlaylists);
|
|
const optionsRef = useRef(options);
|
|
useLayoutEffect(() => {
|
|
setPlaylistsRef.current = setPlaylists;
|
|
optionsRef.current = options;
|
|
});
|
|
|
|
useEffect(() => {
|
|
if (!lastPlaylistEvent) return;
|
|
const { isOwner, ownerId, noNewEntries } = optionsRef.current ?? {};
|
|
const ev = lastPlaylistEvent;
|
|
|
|
setPlaylistsRef.current((prev) => {
|
|
if (ev.type === "created" && ev.playlist) {
|
|
if (noNewEntries) return prev;
|
|
if (ownerId && ev.playlist.userId !== ownerId) return prev;
|
|
if (!ev.playlist.isPublic && !isOwner) return prev;
|
|
if (prev.some((p) => p.id === ev.playlist!.id)) return prev;
|
|
return [ev.playlist, ...prev];
|
|
}
|
|
|
|
if (ev.type === "updated" && ev.playlist) {
|
|
const idx = prev.findIndex((p) => p.id === ev.playlist!.id);
|
|
if (idx === -1) {
|
|
// Playlist was removed (went private). Re-add if it's now public and
|
|
// visible to this list. noNewEntries lists (followed) skip this since
|
|
// we can't verify the follow relationship is still active.
|
|
if (noNewEntries) return prev;
|
|
if (ownerId && ev.playlist.userId !== ownerId) return prev;
|
|
if (!ev.playlist.isPublic && !isOwner) return prev;
|
|
// skipReinsert: caller handles re-insertion at the correct position.
|
|
if (optionsRef.current?.skipReinsert) return prev;
|
|
return [ev.playlist, ...prev];
|
|
}
|
|
// Remove if it became private and the viewer can't see private playlists
|
|
if (!ev.playlist.isPublic && !isOwner) {
|
|
return prev.filter((p) => p.id !== ev.playlist!.id);
|
|
}
|
|
const next = [...prev];
|
|
next[idx] = ev.playlist;
|
|
return next;
|
|
}
|
|
|
|
if (ev.type === "deleted") {
|
|
return prev.filter((p) => p.id !== ev.playlistId);
|
|
}
|
|
|
|
if (ev.type === "dumps_updated" && ev.dumpIds) {
|
|
const idx = prev.findIndex((p) => p.id === ev.playlistId);
|
|
if (idx === -1) return prev;
|
|
const next = [...prev];
|
|
next[idx] = {
|
|
...next[idx],
|
|
dumpCount: ev.dumpCount ?? ev.dumpIds.length,
|
|
};
|
|
return next;
|
|
}
|
|
|
|
return prev;
|
|
});
|
|
}, [lastPlaylistEvent]);
|
|
|
|
useEffect(() => {
|
|
if (deletedPlaylistIds.size === 0) return;
|
|
setPlaylistsRef.current((prev) =>
|
|
prev.filter((p) => !deletedPlaylistIds.has(p.id))
|
|
);
|
|
}, [deletedPlaylistIds]);
|
|
}
|