Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

28.8 KB
Raw Blame
/* 侧栏:骨架与路由树的换手、导航顺序跟 store 走、拖动排序写回、筛选键的按下态与计数、分组开合、
 * 「展开全部」、关注标签与时长两端,以及它作为常驻组件(`RESIDENT_ROUTES.sidebar`)在路由树里的行为:
 * 宿主就是 `#drawerScroll`、骨架在首帧的同一个任务里换掉、`attached` 在首帧之后调一次、句柄同步画完、
 * 壳挪进标题行的节点经重画仍在、抛错只卸组件。
 *
 * 玻璃的滑动、真实的拖动手势与抽屉开合要量布局,由 e2e 在浏览器里走(`e2e/sidebar.test.ts`)。 */
import { act } from 'react';
import { createRoot } from 'react-dom/client';
import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';

import { createSettingsStore } from '../../src/settings-store';
import { NAV_CATALOG } from '../../src/application/navigation-items';
import { DEFAULT_SIDEBAR_ORDER } from '../../src/sidebar';
import { sidebarSkeletonHtml } from '../../src/sidebar-skeleton';
import type { BatchDockApi, BatchDockHost } from '../../src/react/batch-dock/batch-dock-api';
import type { ShellActions } from '../../src/react/router/shell-actions';
import type { SidebarApi, SidebarChip, SidebarFacets, SidebarHost, SidebarProps } from '../../src/react/sidebar/sidebar-api';
import { moveSidebarKey } from '../../src/react/sidebar/sidebar-order';
import { click, fetchMock, sentBody, settle } from './render';

// 首次导入会编译路由表带进来的整棵页面子树,编译等待使用独立的有限窗口;之后每条用例重新装载只重跑模块。
const REACT_IMPORT_TIMEOUT_MS = 30_000;

type ActFlag = { IS_REACT_ACT_ENVIRONMENT?: boolean };

beforeAll(async () => { await import('../../src/react/router/router') }, REACT_IMPORT_TIMEOUT_MS);

/* 侧栏的字形换成一层能当场决定抛不抛的包装:用例中途改 `glyph.broken`,就是「下一次绘制抛错」。 */
const glyph = vi.hoisted(() => ({ broken: false }));
vi.mock(import('../../src/react/settings-panel/icon'), async (importOriginal) => {
  const actual = await importOriginal();
  return {
    ...actual,
    Icon: (props: Parameters<typeof actual.Icon>[0]) => {
      if (glyph.broken) throw new Error('侧栏画不出来');
      return actual.Icon(props);
    },
  };
});

/* 常驻组件适配层直接读取同一包内的配置函数;测试只接本场景的句柄契约。 */
type ShellIslands = { connectApplication(next: (actions: ShellActions) => void): () => void;
  loadSidebar(host: SidebarHost): Promise<SidebarApi>;
  sidebarApi(): SidebarApi | null;
  loadBatchDock(host: BatchDockHost): Promise<BatchDockApi>;
};
const ISLANDS_MODULE = '../../src/react/application-residents';

async function load() {
  vi.resetModules();
  window.history.replaceState(null, '', '/');
  const [history, router, routes, islands] = await Promise.all([
    import('../../src/history'), import('../../src/react/router/router'), import('../../src/react/router/managed-routes'),
    import(/* @vite-ignore */ ISLANDS_MODULE) as Promise<ShellIslands>,
  ]);
  return { ...history, ...router, ...routes, islands };
}
type Loaded = Awaited<ReturnType<typeof load>>;

const unmounts: Array<() => void> = [];
afterEach(async () => {
  (globalThis as ActFlag).IS_REACT_ACT_ENVIRONMENT = true;
  for (const unmount of unmounts.splice(0)) await act(async () => { unmount() });
  document.body.innerHTML = '';
  glyph.broken = false;
  vi.unstubAllGlobals();
  vi.restoreAllMocks();
});

function shellActions(): ShellActions {
  return {
    openItem: vi.fn(), openEntity: vi.fn(), openTag: vi.fn(), openTasteSignal: vi.fn(), navigate: vi.fn(),
    openManage: vi.fn(), managePath: vi.fn(() => ''), openFollow: vi.fn(), receipt: vi.fn(), toast: vi.fn(),
    failure: vi.fn(), revealSource: vi.fn(async () => ''), reopenTutorial: vi.fn(async () => {}),
    routeReview: vi.fn(),
    routeFollowManage: vi.fn(), saveFollowPreference: vi.fn(), srcBadge: () => '', routeIndex: vi.fn(),
    savePeopleLayout: vi.fn(), exitSelectMode: vi.fn(), personAvatar: vi.fn(() => ({ html: '', face: '' })),
    authorAvatar: vi.fn(() => ''), showIndexTags: vi.fn(), openFollowAuthor: vi.fn(), openFollowTag: vi.fn(),
    openPlaylist: vi.fn(), canFlip: vi.fn(() => true),
    surfaceChanged: vi.fn(), clearSearch: vi.fn(), openImmerse: vi.fn(), openOverlay: vi.fn(), closeStage: vi.fn(), grid: {} as ShellActions['grid'],
  };
}

/** 壳启动时先画路由树(根的选项与 `mountApplication` 同一份);接上取数单独一步,用例可以把它往后放。 */
async function mountRouter(r: Loaded) {
  unmounts.push(r.islands.connectApplication(() => {}));
  const root = createRoot(document.createElement('div'), r.ROUTER_ROOT_OPTIONS);
  await act(async () => { root.render(<r.RouterRoot actions={shellActions()} />) });
  unmounts.push(() => root.unmount());
}
async function connect(r: Loaded) {
  await act(async () => { r.connectManagedRoutes(Promise.resolve(r.prefetchManagedRoute)) });
}

const CATALOG = [['', '首页', 'home'], ['unseen', '未看', 'eye'], ['follow', '关注', 'rss'], ['stats', '统计', 'chart']] as const;

const chip = (value: string, n: number | null = 1, extra: Partial<SidebarChip> = {}): SidebarChip =>
  ({ value, label: value.toUpperCase(), n, ...extra });

const facets = (patch: Partial<SidebarFacets> = {}): SidebarFacets => ({
  locations: [chip('local', 3), chip('115', 2, { offline: '这块盘没挂上' })],
  regions: [], orientations: [], creators: [], tags: [chip('a', 5), chip('b', 4)], tech: [], followTags: [],
  duration: false, ...patch,
});

/** 壳 `index.html` 里的抽屉与滚动层,壳启动时同步写进导航骨架;`attached` 由用例按需换成壳的挪动。 */
function sidebarHost(order = ['', 'unseen', 'follow'], current = '', attached: () => void = () => {}) {
  const drawer = document.createElement('aside');
  drawer.setAttribute('data-sidebar-drawer', '');
  const scroll = document.createElement('div');
  scroll.setAttribute('data-sidebar-scroll', '');
  drawer.append(scroll);
  document.body.append(drawer);
  const store = createSettingsStore('peach.settings.v1', { sidebarOrder: order });
  let pressed = current;
  const host: SidebarHost = {
    scroll, store, navCatalog: CATALOG,
    navOn: (key) => key === pressed,
    navTo: vi.fn(), navToTop: vi.fn(), toggleChip: vi.fn(), setDuration: vi.fn(), openFollowTag: vi.fn(), selectFollowTag: vi.fn(),
    selectFollowProvider: vi.fn(), setFollowDuration: vi.fn(),
    attached: vi.fn(attached),
  };
  scroll.innerHTML = sidebarSkeletonHtml(order, CATALOG, host.navOn);
  return { drawer, scroll, store, host, press: (key: string) => { pressed = key } };
}

/** 照壳的启动顺序接上:路由树画好并接上取数,铺骨架,装载侧栏,拿到句柄。 */
async function setup(order?: string[], current?: string, attached?: () => void) {
  const r = await load();
  await mountRouter(r);
  await connect(r);
  const shell = sidebarHost(order, current, attached);
  let api!: SidebarApi;
  await act(async () => { api = await r.islands.loadSidebar(shell.host) });
  const render = (props: Partial<SidebarProps>) => act(() => { api.render({ content: null, filters: {}, latest: null, ...props }) });
  return { r, ...shell, api, render };
}

/** 收下每一次上报;`console.error` 只静音,不数条数。 */
function watchReports() {
  const reported = vi.fn();
  vi.stubGlobal('reportError', reported);
  vi.spyOn(console, 'error').mockImplementation(() => {});
  return reported;
}

const navKeys = (root: ParentNode) => [...root.querySelectorAll<HTMLElement>('[data-sidebar-nav] [data-nav]')].map((node) => node.dataset.nav);
const group = (root: ParentNode, title: string) => root.querySelector<HTMLDetailsElement>(`[data-sidebar-group="${title}"]`);
const chipOf = (root: ParentNode, key: string, value: string) =>
  root.querySelector<HTMLButtonElement>(`[data-sidebar-chip][data-key="${key}"][data-val="${value}"]`);

beforeEach(() => {
  sessionStorage.clear();
  localStorage.clear();
  document.body.replaceChildren();
});

describe('换手', () => {
  it('骨架与侧栏画的是同一列:顺序、按下态与首页记号一致;预取未接上时滚动层里是骨架、句柄为 null', async () => {
    const skeleton = document.createElement('div');
    skeleton.innerHTML = sidebarSkeletonHtml(['unseen', '', 'missing'], CATALOG, (key) => key === 'unseen');
    expect(navKeys(skeleton)).toEqual(['unseen', '']);
    expect(skeleton.querySelector('[data-nav="unseen"]')!.getAttribute('aria-pressed')).toBe('true');
    expect(skeleton.querySelector('[data-nav=""] [data-sidebar-home-logo]')).not.toBeNull();
    const r = await load();
    await mountRouter(r);
    const { scroll, host } = sidebarHost(['unseen', '', 'missing'], 'unseen');
    const html = scroll.innerHTML;
    let loaded: Promise<SidebarApi> | null = null;
    await act(async () => { loaded = r.islands.loadSidebar(host) });
    expect(scroll.innerHTML, '路由树还没接上取数,骨架原样').toBe(html);
    expect(r.islands.sidebarApi(), '画上之前没有句柄,壳继续接骨架上的点击').toBeNull();
    expect(host.attached).not.toHaveBeenCalled();

    await connect(r);
    let api: SidebarApi | null = null;
    await act(async () => { api = await loaded });
    expect(r.islands.sidebarApi()).toBe(api);
    expect(r.managedEntry(scroll)?.path).toBe('sidebar');
    expect(navKeys(scroll)).toEqual(navKeys(skeleton));
    expect(scroll.querySelector(':scope > [data-sidebar-head]')).not.toBeNull();
    expect(scroll.querySelector('[data-nav="unseen"]')!.getAttribute('aria-pressed')).toBe('true');
    expect(host.attached).toHaveBeenCalledTimes(1);
  });

  it('骨架与首帧在同一个任务里换掉:每个任务边界上滚动层里要么是骨架、要么是画好的导航,不多包 .peach-react', async () => {
    const r = await load();
    await mountRouter(r);
    await connect(r);
    const { scroll, host } = sidebarHost();
    const skeletonNav = scroll.querySelector('[data-nav]');
    /* 不包 act:act 会把 flushSync 推到它结束时,看不出换手发生在哪一拍。 */
    (globalThis as ActFlag).IS_REACT_ACT_ENVIRONMENT = false;
    let done = false;
    void r.islands.loadSidebar(host).then(() => { done = true });
    const state = () => (scroll.contains(skeletonNav) ? 'skeleton' : navKeys(scroll).length ? 'sidebar' : 'empty');
    const seen: string[] = [];
    for (let turn = 0; turn < 200 && !done; turn += 1) {
      seen.push(state());
      await new Promise((resolve) => { setTimeout(resolve, 0) });
    }
    seen.push(state());
    expect(done).toBe(true);
    expect(seen).not.toContain('empty');
    expect(seen.at(-1)).toBe('sidebar');
    expect(navKeys(scroll)).toEqual(['', 'unseen', 'follow']);
    expect(scroll.querySelector(':scope > .peach-react')).toBeNull();
    expect(scroll.firstElementChild?.hasAttribute('data-sidebar-head')).toBe(true);
  });

  it('attached 在首帧画上之后、句柄交出之前调一次,之后的重画不再调', async () => {
    const r = await load();
    await mountRouter(r);
    await connect(r);
    const seen: Array<{ skeleton: boolean; nav: Array<string | undefined>; head: boolean; api: SidebarApi | null }> = [];
    const shell = sidebarHost(undefined, undefined, () => {
      seen.push({
        skeleton: shell.scroll.contains(skeletonNav), nav: navKeys(shell.scroll),
        head: shell.scroll.querySelector(':scope > [data-sidebar-head]') !== null, api: r.islands.sidebarApi(),
      });
    });
    const skeletonNav = shell.scroll.querySelector('[data-nav]');
    let api!: SidebarApi;
    await act(async () => { api = await r.islands.loadSidebar(shell.host) });
    expect(seen).toEqual([{ skeleton: false, nav: ['', 'unseen', 'follow'], head: true, api: null }]);
    act(() => { api.render({ content: { kind: 'catalog', key: '1', facets: facets() }, filters: {}, latest: null }) });
    act(() => { api.navChanged() });
    act(() => { shell.store.value.sidebarOrder = ['follow', '']; shell.store.save() });
    expect(shell.host.attached).toHaveBeenCalledTimes(1);
  });

  it('骨架转义名称', async () => {
    const node = document.createElement('div');
    node.innerHTML = sidebarSkeletonHtml(['x'], [['x', '<img src=x>', 'a"b']], () => false);
    expect(node.querySelector('img')).toBeNull();
    expect(node.querySelector('button')!.getAttribute('aria-label')).toBe('<img src=x>');
  });
});

describe('导航', () => {
  it('完整词表按持久偏好画默认导航,沉浸模式可在关注后启用', async () => {
    const r = await load();
    await mountRouter(r);
    await connect(r);
    const { scroll, host, store } = sidebarHost([...DEFAULT_SIDEBAR_ORDER]);
    host.navCatalog = NAV_CATALOG;
    scroll.innerHTML = sidebarSkeletonHtml(store.value.sidebarOrder, NAV_CATALOG, host.navOn);
    await act(async () => { await r.islands.loadSidebar(host) });
    expect(navKeys(scroll)).toEqual(DEFAULT_SIDEBAR_ORDER);
    expect(scroll.querySelector('[data-nav="immerse"]')).toBeNull();
    await act(async () => {
      store.value.sidebarOrder = ['follow', 'immerse', ...DEFAULT_SIDEBAR_ORDER.filter((key) => key !== 'follow')];
      store.save();
    });
    expect(navKeys(scroll).slice(0, 2)).toEqual(['follow', 'immerse']);
    expect(scroll.querySelector('[data-nav="immerse"]')?.textContent).toContain('沉浸模式');
  });

  it('store 里的顺序一变(设置面板或另一台机器同步回来),这一列当场重排', async () => {
    const { scroll, store } = await setup();
    act(() => { store.value.sidebarOrder = ['follow', '', 'stats']; store.save() });
    expect(navKeys(scroll)).toEqual(['follow', '', 'stats']);
  });

  it('点一项交给壳的 navTo;按下态由壳说重读时才换', async () => {
    const { scroll, host, api, press } = await setup();
    await click(scroll.querySelector('[data-nav="unseen"]'));
    expect(host.navTo).toHaveBeenCalledWith('unseen');
    press('unseen');
    act(() => api.navChanged());
    expect(scroll.querySelector('[data-nav="unseen"]')!.getAttribute('aria-pressed')).toBe('true');
    expect(scroll.querySelector('[data-nav=""]')!.getAttribute('aria-pressed')).toBe('false');
  });

  it('双击导航只请求回顶,不重建栏目内容', async () => {
    const { scroll, host } = await setup();
    act(() => { scroll.querySelector('[data-nav=""]')!.dispatchEvent(new MouseEvent('dblclick', { bubbles: true })) });
    expect(host.navToTop).toHaveBeenCalledOnce();
  });

  it('键盘下移一项:先落本地 store,再写 /api/settings', async () => {
    const fetcher = fetchMock(200, { sidebarOrder: ['unseen', '', 'follow'] });
    vi.stubGlobal('fetch', fetcher);
    const { scroll, store } = await setup();
    act(() => { scroll.querySelector('[data-nav=""]')!.dispatchEvent(new KeyboardEvent('keydown',
      { key: 'ArrowDown', altKey: true, bubbles: true, cancelable: true })) });
    await settle();
    expect(store.value.sidebarOrder).toEqual(['unseen', '', 'follow']);
    expect(JSON.parse(localStorage.getItem('peach.settings.v1')!).sidebarOrder).toEqual(['unseen', '', 'follow']);
    expect(navKeys(scroll)).toEqual(['unseen', '', 'follow']);
    expect(scroll.querySelector('[data-dragging],[data-drop]')).toBeNull();
    expect(fetcher.mock.calls[0]?.[0]).toBe('/api/settings');
    expect(sentBody(fetcher)).toEqual({ sidebarOrder: ['unseen', '', 'follow'] });
  });

  it('挪不了的情形不产生新顺序', async () => {
    expect(moveSidebarKey(['a', 'b', 'c'], 'a', 'c', false)).toEqual(['b', 'a', 'c']);
    expect(moveSidebarKey(['a', 'b'], 'a', 'a', true)).toBeNull();
    expect(moveSidebarKey(['a', 'b'], 'x', 'a', true)).toBeNull();
  });
});

describe('筛选分组', async () => {
  it('按下态照当前语境的筛选画,点下去交给壳;脱盘的来源点不了', async () => {
    const { scroll, host, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets() }, filters: { loc: 'local', tag: 'b' } });
    expect(chipOf(scroll, 'loc', 'local')!.getAttribute('aria-pressed')).toBe('true');
    expect(chipOf(scroll, 'tag', 'b')!.getAttribute('aria-pressed')).toBe('true');
    expect(chipOf(scroll, 'tag', 'a')!.getAttribute('aria-pressed')).toBe('false');
    await click(chipOf(scroll, 'loc', 'local'));
    expect(host.toggleChip).toHaveBeenCalledWith('loc', 'local', true);
    await click(chipOf(scroll, 'tag', 'a'));
    expect(host.toggleChip).toHaveBeenLastCalledWith('tag', 'a', false);
    const offline = chipOf(scroll, 'loc', '115')!;
    expect(offline.disabled).toBe(true);
    expect(offline.hasAttribute('data-offline')).toBe(true);
    expect(offline.title).toBe('这块盘没挂上');
  });

  it('名字放不下被省略时悬停读得到全名:普通条目与关注标签都带 title', async () => {
    const { scroll, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets({ followTags: [chip('the_legend_of_zelda:_tears_of_the_kingdom', 2)] }) } });
    expect(chipOf(scroll, 'tag', 'a')!.title).toBe(chipOf(scroll, 'tag', 'a')!.querySelector('[data-sidebar-chip-label]')!.textContent);
    expect(scroll.querySelector<HTMLElement>('[data-follow-drawer-tag="the_legend_of_zelda:_tears_of_the_kingdom"]')!.title)
      .toBe(scroll.querySelector('[data-follow-drawer-tag="the_legend_of_zelda:_tears_of_the_kingdom"] [data-sidebar-chip-label]')!.textContent);
  });

  it('就地刷新的计数只改数字:名单里有、新聚合里没有的记 0', async () => {
    const { scroll, render } = await setup();
    const content = { kind: 'catalog' as const, key: '1', facets: facets() };
    render({ content });
    expect(chipOf(scroll, 'tag', 'a')!.querySelector('[data-sidebar-count]')!.textContent).toBe('5');
    render({ content, latest: facets({ tags: [chip('b', 9)] }) });
    expect(chipOf(scroll, 'tag', 'a')!.querySelector('[data-sidebar-count]')!.textContent).toBe('0');
    expect(chipOf(scroll, 'tag', 'b')!.querySelector('[data-sidebar-count]')!.textContent).toBe('9');
  });

  it('一进来只展开正在生效的组;人自己开合过的组按会话记住,换一份聚合也不改', async () => {
    const { scroll, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets() }, filters: { tag: 'a' } });
    expect(group(scroll, '内容标签')!.open).toBe(true);
    expect(group(scroll, '来源')!.open).toBe(false);
    const toggle = group(scroll, '来源')!.querySelector<HTMLElement>('[data-sidebar-toggle]')!;
    expect(document.getElementById(toggle.getAttribute('aria-controls')!)).not.toBeNull();
    await click(toggle);
    expect(toggle.getAttribute('aria-expanded')).toBe('true');
    render({ content: { kind: 'catalog', key: '2', facets: facets() }, filters: {} });
    expect(group(scroll, '来源')!.open).toBe(true);
    expect(group(scroll, '内容标签')!.open).toBe(false);
  });

  it('「展开全部」接在名单末尾,摊开照最新那一份聚合', async () => {
    const { scroll, render } = await setup();
    const tags = Array.from({ length: 32 }, (_, index) => chip(`t${index}`, 40 - index));
    const content = { kind: 'catalog' as const, key: '1', facets: facets({ tags }) };
    render({ content, latest: facets({ tags: [...tags, chip('late', 1)] }) });
    await click(group(scroll, '内容标签')!.querySelector('[data-sidebar-toggle]'));
    const body = group(scroll, '内容标签')!.querySelector('[data-sidebar-body]')!;
    expect(body.querySelectorAll('[data-sidebar-chip]')).toHaveLength(30);
    const more = body.lastElementChild as HTMLButtonElement;
    expect(more.getAttribute('data-sidebar-more')).toBe('tag');
    expect(more.getAttribute('aria-label')).toBe('展开全部内容标签');
    await click(more);
    expect(body.querySelectorAll('[data-sidebar-chip]')).toHaveLength(33);
    expect(more.getAttribute('aria-expanded')).toBe('true');
    expect(more.getAttribute('aria-label')).toBe('收起内容标签');
    /* 收起收的是整组:组标题当场报收起、正文不再可聚焦;`details.open` 等高度过渡走完才摘。 */
    await click(more);
    expect(group(scroll, '内容标签')!.querySelector('[data-sidebar-toggle]')!.getAttribute('aria-expanded')).toBe('false');
    expect(group(scroll, '内容标签')!.querySelector<HTMLElement>('[data-sidebar-collapse]')!.inert).toBe(true);
    expect(body.querySelectorAll('[data-sidebar-chip]')).toHaveLength(30);
  });

  it('换一份聚合时只有数字变了的徽标弹一下', async () => {
    const { scroll, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets({ tags: [chip('pa', 5), chip('pb', 4)] }) } });
    /* `popped` 加上又当场摘掉,回调到来时类名早已不在;摘掉那一笔的旧值里还留着它。 */
    const popped: string[] = [];
    const observer = new MutationObserver((records) => {
      for (const record of records) {
        if (/\bpopped\b/.test(record.oldValue ?? '')) popped.push((record.target as HTMLElement).dataset.countBadge!);
      }
    });
    observer.observe(scroll, { subtree: true, attributes: true, attributeFilter: ['class'], attributeOldValue: true });
    render({ content: { kind: 'catalog', key: '2', facets: facets({ tags: [chip('pa', 5), chip('pb', 7)] }) } });
    await settle();
    observer.disconnect();
    expect(popped).toEqual(['tag:pb']);
  });

  it('目录页的关注标签去关注页,关注页的内容标签换成只按这一枚筛', async () => {
    const { scroll, host, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets({ followTags: [chip('x', 2)] }) } });
    await click(scroll.querySelector('[data-follow-drawer-tag="x"]'));
    expect(host.openFollowTag).toHaveBeenCalledWith('x');
    render({ content: { kind: 'follow', tags: [chip('y', 3), chip('z', 1)], selected: ['z'] } });
    expect(group(scroll, '来源')).toBeNull();
    const z = scroll.querySelector('[data-follow-drawer-tag="z"]')!;
    expect(z.getAttribute('aria-pressed')).toBe('true');
    expect(z.querySelector('[data-sidebar-count]')!.textContent).toBe('1');
    await click(scroll.querySelector('[data-follow-drawer-tag="y"]'));
    expect(host.selectFollowTag).toHaveBeenCalledWith('y');
  });

  it('关注页的来源与时长回关注筛选,不回目录筛选;详情只给标签时只有内容标签一组', async () => {
    const { scroll, host, render } = await setup();
    const kemono = chip('kemono', null, { dot: { kind: 'image', src: '/source-icon?provider=kemono' } });
    render({
      content: { kind: 'follow', tags: [chip('y', 3)], selected: [], providers: [kemono, chip('fanbox', null)], duration: true },
      filters: { provider: 'fanbox', dur_min: 600, dur_max: '' },
    });
    expect([...scroll.querySelectorAll('[data-sidebar-group]')].map((node) => node.getAttribute('data-sidebar-group')))
      .toEqual(['来源', '时长', '内容标签']);
    expect(chipOf(scroll, 'provider', 'fanbox')!.getAttribute('aria-pressed')).toBe('true');
    expect(chipOf(scroll, 'provider', 'kemono')!.querySelector('[data-sidebar-count]')).toBeNull();
    expect(chipOf(scroll, 'provider', 'kemono')!.querySelector('img')!.getAttribute('src')).toBe('/source-icon?provider=kemono');
    expect(scroll.querySelector(`[data-range-end="min"]`)!.textContent).toBe('10 分钟');
    await click(chipOf(scroll, 'provider', 'kemono'));
    expect(host.selectFollowProvider).toHaveBeenCalledWith('kemono');
    expect(host.toggleChip).not.toHaveBeenCalled();
    const max = scroll.querySelector<HTMLInputElement>('#durMax')!;
    act(() => {
      Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!.call(max, '60');
      max.dispatchEvent(new Event('input', { bubbles: true }));
      max.dispatchEvent(new Event('change', { bubbles: true }));
    });
    expect(host.setFollowDuration).toHaveBeenCalledWith(10, 60);
    expect(host.setDuration).not.toHaveBeenCalled();

    render({ content: { kind: 'follow', tags: [chip('y', 1)], selected: [] } });
    expect([...scroll.querySelectorAll('[data-sidebar-group]')].map((node) => node.getAttribute('data-sidebar-group')))
      .toEqual(['内容标签']);
  });

  it('时长两端各有一枚读数,右端拉到头是「不限」;松手才提交', async () => {
    const { scroll, host, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets({ duration: true }) }, filters: { dur_min: '1200' } });
    const tip = (end: string) => scroll.querySelector(`[data-range-end="${end}"]`)!.textContent;
    expect(tip('min')).toBe('20 分钟');
    expect(tip('max')).toBe('不限');
    const max = scroll.querySelector<HTMLInputElement>('#durMax')!;
    act(() => {
      Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')!.set!.call(max, '60');
      max.dispatchEvent(new Event('input', { bubbles: true }));
    });
    expect(tip('max')).toBe('60 分钟');
    expect(host.setDuration).not.toHaveBeenCalled();
    act(() => { max.dispatchEvent(new Event('change', { bubbles: true })) });
    expect(host.setDuration).toHaveBeenCalledWith(20, 60);
  });

  it('content 为 null 时只画导航', async () => {
    const { scroll, render } = await setup();
    render({ content: { kind: 'catalog', key: '1', facets: facets() } });
    render({ content: null });
    expect(scroll.querySelector('[data-sidebar-group]')).toBeNull();
    expect(navKeys(scroll)).toEqual(['', 'unseen', 'follow']);
  });
});

describe('常驻组件', () => {
  it('句柄 render 与 navChanged 返回时 DOM 已画好,不等下一次渲染', async () => {
    const { scroll, api, press } = await setup();
    /* 不包 act:act 会把 flushSync 推到它结束时,看不出句柄自己同步没有。 */
    (globalThis as ActFlag).IS_REACT_ACT_ENVIRONMENT = false;
    api.render({ content: { kind: 'catalog', key: '1', facets: facets() }, filters: { tag: 'a' }, latest: null });
    expect(chipOf(scroll, 'tag', 'a')!.getAttribute('aria-pressed')).toBe('true');
    press('unseen');
    api.navChanged();
    expect(scroll.querySelector('[data-nav="unseen"]')!.getAttribute('aria-pressed')).toBe('true');
    expect(scroll.querySelector('[data-nav=""]')!.getAttribute('aria-pressed')).toBe('false');
  });

  it('壳挪进标题行的品牌与开合键经重画、换按下态与重排仍是挪进去的那两个节点', async () => {
    const brand = document.createElement('a'), toggle = document.createElement('button');
    const place = () => { document.querySelector('[data-sidebar-scroll] > [data-sidebar-head]')!.append(brand, toggle) };
    const { scroll, store, api, render, press } = await setup(undefined, undefined, place);
    const head = scroll.querySelector(':scope > [data-sidebar-head]')!;
    expect([...head.children]).toEqual([brand, toggle]);
    render({ content: { kind: 'catalog', key: '1', facets: facets() }, filters: { tag: 'a' } });
    render({ content: { kind: 'follow', tags: [chip('y', 3)], selected: [] } });
    press('unseen');
    act(() => { api.navChanged() });
    act(() => { store.value.sidebarOrder = ['follow', 'unseen', '']; store.save() });
    render({ content: null });
    expect(scroll.querySelector(':scope > [data-sidebar-head]')).toBe(head);
    expect([...head.children]).toEqual([brand, toggle]);
  });

  it('抛错只卸组件、滚动层还在,批量条照画;之后句柄是空操作、不抛,这一面空到刷新为止,只报一次', async () => {
    const reported = watchReports();
    const { r, drawer, scroll, api, render } = await setup();
    const dockRoot = document.createElement('div');
    dockRoot.setAttribute('data-batch-dock', '');
    document.body.append(dockRoot);
    let dock!: BatchDockApi;
    await act(async () => { dock = await r.islands.loadBatchDock({ root: dockRoot, run: vi.fn() }) });

    glyph.broken = true;
    render({ content: { kind: 'catalog', key: '1', facets: facets() } });
    await act(async () => {});
    expect(reported).toHaveBeenCalledTimes(1);
    expect(reported).toHaveBeenCalledWith(expect.objectContaining({ message: '侧栏画不出来' }));
    expect(scroll.isConnected && scroll.parentElement === drawer, '滚动层是壳的节点,不撤').toBe(true);
    expect(scroll.childNodes.length, '组件卸掉了').toBe(0);
    expect(drawer.querySelector('[data-sidebar-glide]'), '玻璃随组件一起卸').toBeNull();
    expect(r.managedTaken(scroll)).toBe(false);
    expect(r.managedEntries().map((entry) => entry.path), '别的面照画').toEqual(['batch-dock']);
    await act(async () => { dock.render({ count: 2, context: 'catalog', junkDismissed: false }) });
    expect(dockRoot.querySelector('[data-selection-dock] [role="status"]')?.textContent).toBe('已选 2 项');

    /* 壳照旧每次换页都推一份、换按下态:不抛、不重开、不再上报。 */
    await act(async () => {
      expect(() => api.render({ content: null, filters: {}, latest: null })).not.toThrow();
      expect(() => api.navChanged()).not.toThrow();
    });
    expect(reported, '确定性抛错只报那一次').toHaveBeenCalledTimes(1);
    glyph.broken = false;
    render({ content: null });
    expect(scroll.childNodes.length, '空到刷新为止,不自愈').toBe(0);
  });
});