Peach: Local-first video metadata scraper and media manager.
/* 馆藏卡片网格的数据:目录(`/` 与四个筛选态、回收站)、资料页作品区,以及壳直接给一批
* 条目的那两处(详情页的接着看)。
*
* 目录和作品区都是一页一个 `useInfiniteQuery`,「载入更多」就是取下一页。
*
* 一屏卡片的排法全由这里算,渲染只照着画:
* - 分卷与版次各自折叠。同一组只留第一次出现的那一张,跨页也算(设置关掉就不折)。
* - 目录每一页可见的卡够 8 张时,第 8 位插一张 Mix;种子从 Mix 位再往下隔一屏开始找,
* 不会和同屏的卡撞图。
* - 竖屏带每接一页出现一条,落点在这一页新增的那几行之间的行边界上随机取一个。 */
import type { InfiniteData, QueryKey } from '@tanstack/react-query';
import { apiGet } from '../../api';
import { javImageKind } from '../../jav-artwork';
import type { CatalogGridProps, MediaItem, MediaPage } from './types';
import { queryClient } from '../query';
/** 竖屏带一条放几张。 */
export const SHORTS_BATCH = 18;
/** Mix 卡插在每一页的这一位,也就是第 8 张。 */
export const MIX_SLOT = 7;
/** 一页的结果,外加第一页为空时「整个馆藏是不是空的」:空态据此说「还没有作品」还是
* 「没有符合的」。 */
export interface GridPage extends MediaPage {
offset: number;
libraryEmpty?: boolean;
}
/** 目录的查询串,不含 `limit`/`offset`。`exclude_vertical` 的判据归壳:首页默认列表另有
* 竖屏带承接竖屏,搜索和显式筛了竖屏的时候不排除。 */
export function catalogParams(filters: Readonly<Record<string, string>>, excludeVertical: boolean): string {
const params = new URLSearchParams(Object.entries(filters).filter(([, value]) => value));
if (excludeVertical) params.set('exclude_vertical', '1');
return params.toString();
}
export const catalogKey = (params: string, revision: number): QueryKey => ['catalog-grid', 'catalog', params, revision];
export const entityKey = (key: string, revision: number): QueryKey => ['catalog-grid', 'entity', key, revision];
/** 目录的一页。第一页为空、又不是回收站时,再问一次整个馆藏有没有东西。 */
export async function fetchCatalogPage(
params: string, offset: number, batch: number, trash: boolean, signal: AbortSignal,
): Promise<GridPage> {
const query = new URLSearchParams(params);
query.set('limit', String(batch));
query.set('offset', String(offset));
if (offset) query.set('count', '0');
const page = await apiGet<MediaPage>(`/api/items?${query}`, signal);
const result: GridPage = { ...page, items: page.items || [], offset };
if (!offset && !result.items.length && !trash) {
const library = await apiGet<MediaPage>('/api/items?limit=1&thumb=0', signal);
result.libraryEmpty = library.total === 0;
}
return result;
}
/** 下一页从哪儿取。第一页按总数判断,往后的页不带总数,看 `has_more`。 */
export const nextOffset = (batch: number) => (last: GridPage): number | undefined => {
const more = last.offset === 0 ? last.items.length < (last.total || 0) : !!last.has_more;
return more ? last.offset + batch : undefined;
};
/** 资料页作品区的下一页:壳给的第一页可能带 `has_more`,也可能只有总数。 */
export const nextEntityOffset = (last: GridPage, pages: GridPage[]): number | undefined => {
const loaded = pages.reduce((sum, page) => sum + page.items.length, 0);
const more = last.has_more == null ? loaded < (last.total || 0) : !!last.has_more;
return more ? loaded : undefined;
};
export function catalogQuery(props: CatalogGridProps) {
const params = catalogParams(props.filters || {}, !!props.excludeVertical);
const batch = props.batchSize || 60;
const trash = props.filters?.state === 'trash';
return {
queryKey: catalogKey(params, props.revision || 0),
queryFn: ({ pageParam, signal }: { pageParam: number; signal: AbortSignal }) =>
fetchCatalogPage(params, pageParam, batch, trash, signal),
initialPageParam: 0,
getNextPageParam: nextOffset(batch),
};
}
/** 目录卡片网格的首屏:取到第一页再挂,岛挂上就是最终样子,壳铺的骨架一直留到数据到,不再交接给岛自己的
* 另一份骨架。同一个键缓存里还有(回到看过的筛选),或岛会认领上一代分页(恢复导航、沉浸墙)时不取,
* 与 `GridBody` 的初值一致。列表视图与资料页各有自己的取数。 */
export async function prefetchCatalogGrid(props: CatalogGridProps, view: string, signal: AbortSignal): Promise<void> {
if (props.mode === 'items' || props.mode === 'entity' || (view === 'list' && !props.wall)) return;
const query = catalogQuery(props);
if (queryClient.getQueryData(query.queryKey) !== undefined) return;
if ((props.restoreNavigation || props.wall) && latestCatalogPages(query.queryKey)) return;
await queryClient.fetchInfiniteQuery({
queryKey: query.queryKey,
queryFn: ({ pageParam }) => query.queryFn({ pageParam: pageParam as number, signal }),
initialPageParam: 0,
getNextPageParam: query.getNextPageParam,
});
}
export function entityQuery(props: CatalogGridProps) {
return {
queryKey: entityKey(props.entityKey || '', props.revision || 0),
queryFn: async ({ pageParam, signal }: { pageParam: number; signal: AbortSignal }) => {
if (!props.fetchPage) return { items: [], total: 0, offset: pageParam } as GridPage;
const page = await props.fetchPage(pageParam, signal);
return { ...page, items: page.items || [], offset: pageParam } as GridPage;
},
initialPageParam: 0,
getNextPageParam: nextEntityOffset,
};
}
/** 同一集合的分页保存在 Query 中;刷新代次之间认领整份分页,不复制作品到界面状态。 */
export function latestCatalogPages(key: QueryKey): InfiniteData<GridPage, number> | undefined {
const exact = JSON.stringify(key);
const cached = queryClient.getQueryCache().findAll({ queryKey: key.slice(0, -1) })
.filter(query => JSON.stringify(query.queryKey) !== exact && !query.state.isInvalidated
&& Array.isArray((query.state.data as InfiniteData<GridPage> | undefined)?.pages))
.sort((a, b) => b.state.dataUpdatedAt - a.state.dataUpdatedAt)[0];
return cached?.state.data as InfiniteData<GridPage, number> | undefined;
}
/** 分卷与版次各自折叠:分卷是一部片被切成几段,版次是同一部片的几个来源,两者能同时
* 出现在一个番号上,所以两套 key 分开记。`seen` 跨页累积,一组只留第一次出现的那一张。 */
export function collapseGroups(
items: readonly MediaItem[], seen: { parts: Set<string>; editions: Set<string> }, enabled: boolean,
): MediaItem[] {
if (!enabled) return [...items];
return items.filter((item) => {
const part = item.part_group?.key;
if (part) {
if (seen.parts.has(part)) return false;
seen.parts.add(part);
}
const edition = item.edition_group?.key;
if (edition) {
if (seen.editions.has(edition)) return false;
seen.editions.add(edition);
}
return true;
});
}
/** 这一条真能画出图吗:和卡片封面的分支一致,只看 `has_cover` 会把只有官方封套、却按
* 预览图偏好画的条目当成有图。 */
export const mixHasPicture = (item: MediaItem | undefined, javImage: string) =>
!!item && Boolean(javImageKind(item, javImage));
/** 种子决定 Mix 的封面和署名。从 Mix 位再往下隔一屏开始找有图、有署名的,找不到逐级放宽。 */
export function mixSeed(visible: readonly MediaItem[], javImage: string): MediaItem | undefined {
const named = (item: MediaItem) => mixHasPicture(item, javImage)
&& Boolean(item.creator || (item.performers || []).length || item.studio);
return visible.slice(MIX_SLOT + 8).find(named)
|| visible.slice(MIX_SLOT + 1).find(named)
|| visible.slice(MIX_SLOT + 1).find((item) => mixHasPicture(item, javImage))
|| visible[visible.length - 1];
}
/** 网格里的一格:一张作品卡,或一张 Mix。 */
export type Tile = { kind: 'card'; item: MediaItem } | { kind: 'mix'; seed: MediaItem };
/** 把已取回的各页排成一列格子。每一页各自折叠、各自插 Mix,和逐页接上来时一样。
* `pageStarts[i]` 是第 i 页在这一列里的起点,竖屏带的落点要落在那一页新增的格子之间。 */
export function arrangeTiles(
pages: readonly GridPage[], { collapse, mix, javImage }: { collapse: boolean; mix: boolean; javImage: string },
): { tiles: Tile[]; pageStarts: number[] } {
const seen = { parts: new Set<string>(), editions: new Set<string>() };
/* 翻页期间库里新进了作品,偏移量整体后挪,上一页末尾那几条会在下一页再出现一次。
同一条只画第一次:一屏里两张一样的卡什么也不说明。 */
const ids = new Set<number>();
const tiles: Tile[] = [];
const pageStarts: number[] = [];
for (const page of pages) {
pageStarts.push(tiles.length);
const fresh = page.items.filter((item) => !ids.has(item.id) && Boolean(ids.add(item.id)));
const visible = collapseGroups(fresh, seen, collapse);
const cards: Tile[] = visible.map((item) => ({ kind: 'card', item }));
if (mix && visible.length >= 8) {
const seed = mixSeed(visible, javImage);
if (seed) cards.splice(MIX_SLOT, 0, { kind: 'mix', seed });
}
tiles.push(...cards);
}
return { tiles, pageStarts };
}
/** 竖屏带的落点候选:从这一页新增的那几行开始,每个行边界一个;两端各留至少一行,剪在
* 头尾就成了「置顶」或「垫底」,不是穿插。`addedFrom` 与 `count` 都按最后一段计。 */
export function shortsBoundaries(count: number, addedFrom: number, columns: number): number[] {
const step = Math.max(1, columns);
const boundaries: number[] = [];
for (let at = Math.max(step, Math.ceil(Math.max(0, addedFrom) / step) * step); at < count; at += step) {
boundaries.push(at);
}
return boundaries;
}
/** 已经插进网格的一条竖屏带:`at` 是它下面那一段在整列格子里的起点。 */
export interface ShortsCut {
at: number;
total: number;
items: MediaItem[];
}
/** 竖屏带的查询串:跟着主列表的筛选与排序走,换一批时它也一起换。 */
export function shortsParams(filters: Readonly<Record<string, string>>, offset: number): string {
const params = new URLSearchParams(Object.entries(filters).filter(([, value]) => value));
params.set('orient', '竖屏');
params.set('limit', String(SHORTS_BATCH));
params.set('offset', String(offset));
return params.toString();
}
/** 把一列格子按竖屏带切成几段,段与段之间插带子。 */
export function splitSections(tiles: readonly Tile[], cuts: readonly ShortsCut[]) {
const ordered = [...cuts].sort((a, b) => a.at - b.at);
const sections: { start: number; tiles: Tile[]; strip: ShortsCut | null }[] = [];
let start = 0;
for (const cut of ordered) {
sections.push({ start, tiles: tiles.slice(start, cut.at), strip: cut });
start = cut.at;
}
sections.push({ start, tiles: tiles.slice(start), strip: null });
return sections;
}
/** 每一版已缓存的目录与作品区里的同一张卡换上 `patch`(详情里评分、反馈、稍后看之后)。
* 只改字段不增删卡:详情不知道每一版筛着哪一档,移出与否等下次取数。 */
export function replaceCatalogItem(id: number, patch: Partial<MediaItem>): void {
patchCatalogItems((item) => item.id === id, patch);
}
/** 同上,换的是 `match` 认出来的每一张:一个番号的几段、几个版本共用同一张封面。 */
export function patchCatalogItems(match: (item: MediaItem) => boolean, patch: Partial<MediaItem>): void {
queryClient.setQueriesData<{ cuts: ShortsCut[] }>({ queryKey: ['catalog-short-layout'] }, data => {
if (!data || !data.cuts.some(cut => cut.items.some(match))) return data;
return { ...data, cuts: data.cuts.map(cut => ({ ...cut,
items: cut.items.map(item => match(item) ? { ...item, ...patch } : item),
})) };
});
queryClient.setQueriesData<MediaPage>({ queryKey: ['catalog-grid', 'table'] }, data => {
if (!data?.items.some(match)) return data;
return { ...data, items: data.items.map(item => match(item) ? { ...item, ...patch } : item) };
});
queryClient.setQueriesData<InfiniteData<GridPage>>({
queryKey: ['catalog-grid'], predicate: (query) => Array.isArray((query.state.data as InfiniteData<GridPage>)?.pages),
}, (data) => {
if (!data || !data.pages.some((page) => page.items.some(match))) return data;
return {
...data,
pages: data.pages.map((page) => (page.items.some(match)
? { ...page, items: page.items.map((item) => (match(item) ? { ...item, ...patch } : item)) } : page)),
};
});
}