Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
/**
* mainListModel — 主列表混排模型(sidebar-redesign D 期)。
* ---------------------------------------------------------------------------
* 把「项目行 / 无项目对话 / 对话组」统一成一层顶层条目(MainListEntry),按同一
* 口径排序——项目不再是特权层级,与散排对话按活动时间(或优先级)平级竞争位置
* (docs/product-rules/sidebar-redesign-plan.md §2)。
*
* 本文件是纯函数(node 单测友好),渲染层(ProjectsSection)只消费产出的
* 有序条目;这**有意推翻**了旧 DialogueSection「对话是 Projects 的同级固定段、
* 固定显示在 Projects 之后」的裁决(设计文档 §9.1,2026-08-12 定稿)。
*
* 排序语义:
* - recency:顶层条目按组内最新活动倒序;项目 / 对话组内部同样按最近活动
* 倒序,不沿用 groupSessions 的 active-first。
* - custom project order:项目行按 manualProjectOrder 连续排在前面;散排对话 /
* 对话组排在项目之后,仍按当前 sortBy(recency / priority)。组内任务也走
* sortBy,不再把项目顺序和任务排序绑成同一档。
* - priority:等你处理(waiting)> 完成未读(unread)> 运行中 > 其余;同档内按
* recency。从完成未读切走时用离开时刻把它排到其余档最前;已读已完成任务
* 之间与按时间排序同口径,浏览不改序(2026-08-17 用户裁决)。正在看的任务
* 用 heldPriorityRanks 钉住打开时的档位。四档口径对齐 Codex 侧栏(waiting:0 / unread:1 /
* active:2 / idle:3,2026-08-13 用户裁决"参考 Codex"):此前三档把「等你
* 回答」和「跑完没看」混在同一档,完成未读一多就把真正要回应的淹掉。
*/
import type { Session } from '@/lib/ccAgent.types';
import { withProjectSessions } from './projectGrouping';
import { CINDY_MAKE_ENABLED } from '@cindy/maker-shared/cindy-make-feature';
import { isCindyMakeFamilySource } from '../../../../shared/cindyMakeMerge';
import {
MACHINE_ALL,
MACHINE_LOCAL,
type MachineSelection,
} from '@/features/device-link/selectedMachineStore';
import { LIVE_TASK_PRIORITY, liveTaskPriorityRank } from '../../../../shared/liveTaskPriority';
import type { FilterProjectOrder, FilterSortBy } from '../hooks/helpers/sidebarFilterCore';
import { normalizeManualProjectOrder } from '../hooks/helpers/sidebarFilterCore';
import {
groupAutomationSidebarEntries,
type AutomationScheduleSessionInfo,
type SidebarSessionEntry,
} from './automationSidebarGrouping';
import { sessionActivityMs, sessionCreatedMs } from './dateSessionGrouping';
import type { BotGroupNode, ProjectNode } from './projectGrouping';
export type MainListEntry =
| { kind: 'project'; project: ProjectNode }
| { kind: 'dialogue-group'; sessions: Session[] }
| { kind: 'cindy-make-group'; sessions: Session[] }
/** 一个伙伴名下的全部任务。与项目行并列 —— 项目是实体目录,伙伴名是用户起的。 */
| { kind: 'bot-group'; bot: BotGroupNode }
| SidebarSessionEntry;
/** 优先级排序的运行时上下文(组装层的运行中 / 需关注集合)。 */
export interface MainListPriorityContext {
/**
* 运行中档。组装层会把「刚发送、agent 还没 isRunning」的 starting 会话并进来,
* 让新任务立刻排在运行中档顶,而不是先沉到其余档再跳上来。
*/
runningSessionIds: ReadonlySet<string>;
/** 需关注(等待确认 / 完成未读等 attention 通知)的 sessionIds。 */
attentionSessionIds: ReadonlySet<string>;
/**
* attention 里「等你处理」的子集:等待回复 / 授权 / 计划审阅(awaiting)与
* 出错未处理(error)。attentionSessionIds 减去它 = 完成未读(done)。
* 可缺省(空集):此时全部 attention 落进 unread 档——排序仍然成立,只是
* 少了 waiting 细分(老调用方 / 测试夹具零迁移成本)。
*/
waitingSessionIds?: ReadonlySet<string>;
/**
* 正在看的任务打开时的档位。看的过程中 attention 被清掉后,自然档会掉到
* 「其余」;这里钉住较差方向。只有从完成未读切走时才写 recentlyViewedAtMs。
*/
heldPriorityRanks?: ReadonlyMap<string, number>;
/**
* 从完成未读切走的时刻(unix ms)。只给那一次回落写离开时间,让它排到其余档
* 最前;已读已完成任务之间仍按 sessionActivityMs,浏览不改序。
*/
recentlyViewedAtMs?: ReadonlyMap<string, number>;
}
const EMPTY_PRIORITY_CONTEXT: MainListPriorityContext = {
runningSessionIds: new Set<string>(),
attentionSessionIds: new Set<string>(),
};
/**
* 单会话优先级权重(对齐 Codex 的 waiting:0 / unread:1 / active:2 / idle:3):
* 等你处理 0 > 完成未读 1 > 运行中 2 > 其余 3。waiting 压过 unread:「要你回应
* 才能继续」比「跑完了等你看」急;unread 压过 running:running 不需要你动手,
* 而 unread 是已经可以处理的结果。
*/
export function naturalPriorityRankForId(
sessionId: string,
ctx: Pick<
MainListPriorityContext,
'runningSessionIds' | 'attentionSessionIds' | 'waitingSessionIds'
>,
): number {
const waiting = ctx.waitingSessionIds?.has(sessionId) === true;
const unread = ctx.attentionSessionIds.has(sessionId) && !waiting;
return liveTaskPriorityRank({
waiting,
unread,
running: ctx.runningSessionIds.has(sessionId),
});
}
export function sessionNaturalPriorityRank(session: Session, ctx: MainListPriorityContext): number {
return naturalPriorityRankForId(session.id, ctx);
}
function viewedPriorityRank(natural: number, held: number | undefined): number {
// 当前轮已经运行时,释放上一轮 unread / waiting 的 hold。否则看的过程中跑完后,
// 旧 hold 会再次把任务抬回高档位,直到点击离开才突然重排。
if (natural === LIVE_TASK_PRIORITY.running) return natural;
return held === undefined ? natural : Math.min(natural, held);
}
export function sessionPriorityRank(session: Session, ctx: MainListPriorityContext): number {
const natural = sessionNaturalPriorityRank(session, ctx);
const held = ctx.heldPriorityRanks?.get(session.id);
return viewedPriorityRank(natural, held);
}
export interface ViewedPriorityHoldState {
prevViewedId?: string;
heldPriorityRanks: Map<string, number>;
recentlyViewedAtMs: Map<string, number>;
}
/**
* 看的时候钉住打开时的档位。只有离开时仍钉着完成未读档,才写离开时刻——
* 已读已完成任务之间跟按时间排序一样,浏览不改序。
* 就地更新传入的 map,方便渲染层跨渲染保留。
*/
export function advanceViewedPriorityHold(
state: ViewedPriorityHoldState,
viewedSessionId: string | undefined,
ctx: Pick<
MainListPriorityContext,
'runningSessionIds' | 'attentionSessionIds' | 'waitingSessionIds'
>,
nowMs: number,
): ViewedPriorityHoldState {
if (state.prevViewedId && state.prevViewedId !== viewedSessionId) {
if (state.heldPriorityRanks.get(state.prevViewedId) === LIVE_TASK_PRIORITY.unread) {
state.recentlyViewedAtMs.set(state.prevViewedId, nowMs);
}
state.heldPriorityRanks.delete(state.prevViewedId);
}
if (viewedSessionId) {
const natural = naturalPriorityRankForId(viewedSessionId, ctx);
const held = state.heldPriorityRanks.get(viewedSessionId);
state.heldPriorityRanks.set(viewedSessionId, viewedPriorityRank(natural, held));
}
state.prevViewedId = viewedSessionId;
return state;
}
/**
* 点击清点会先于路由更新清掉 attention。必须在那之前按当前档位钉住,
* 否则首次 hold 只能读到 rest,刚打开的完成未读仍会立刻沉底。
*/
export function holdViewedPriorityRank(
state: ViewedPriorityHoldState,
sessionId: string,
ctx: Pick<
MainListPriorityContext,
'runningSessionIds' | 'attentionSessionIds' | 'waitingSessionIds'
>,
): void {
const natural = naturalPriorityRankForId(sessionId, ctx);
const held = state.heldPriorityRanks.get(sessionId);
state.heldPriorityRanks.set(sessionId, viewedPriorityRank(natural, held));
}
export function sessionPriorityRecencyMs(session: Session, ctx: MainListPriorityContext): number {
if (sessionPriorityRank(session, ctx) !== LIVE_TASK_PRIORITY.rest) {
return sessionActivityMs(session);
}
const viewedAt = ctx.recentlyViewedAtMs?.get(session.id) ?? 0;
return Math.max(sessionActivityMs(session), viewedAt);
}
export function getMainListEntrySessions(entry: MainListEntry): readonly Session[] {
if (entry.kind === 'project') return entry.project.sessions;
if (entry.kind === 'dialogue-group' || entry.kind === 'cindy-make-group') return entry.sessions;
if (entry.kind === 'bot-group') return entry.bot.sessions;
if (entry.kind === 'automation-group') return entry.group.sessions;
return [entry.session];
}
function entryTimeMs(entry: MainListEntry, sortBy: FilterSortBy = 'recency'): number {
const sessions = getMainListEntrySessions(entry);
let max = 0;
for (const s of sessions) {
const ms = sortBy === 'created' ? sessionCreatedMs(s) : sessionActivityMs(s);
if (ms > max) max = ms;
}
return max;
}
function sessionGroupPriorityRecencyMs(
sessions: readonly Session[],
ctx: MainListPriorityContext,
): number {
let max = 0;
for (const s of sessions) {
const ms = sessionPriorityRecencyMs(s, ctx);
if (ms > max) max = ms;
}
return max;
}
function sessionGroupPriorityRank(
sessions: readonly Session[],
ctx: MainListPriorityContext,
): number {
let min: number = LIVE_TASK_PRIORITY.rest;
for (const s of sessions) {
const rank = sessionPriorityRank(s, ctx);
if (rank < min) min = rank;
if (min === LIVE_TASK_PRIORITY.waiting) break;
}
return min;
}
/** 项目行与折叠侧栏共用的优先级比较:档位优先,同档再比最近活动。 */
export function compareSessionGroupsByPriority(
a: readonly Session[],
b: readonly Session[],
ctx: MainListPriorityContext,
): number {
return (
sessionGroupPriorityRank(a, ctx) - sessionGroupPriorityRank(b, ctx) ||
sessionGroupPriorityRecencyMs(b, ctx) - sessionGroupPriorityRecencyMs(a, ctx)
);
}
/**
* 组内(项目 / 对话组)会话排序的唯一入口。
* - priority:分档 + 同档 recency
* - recency:一律按最近活动倒序
* - created:按创建时间倒序,消息和状态更新不改序
* 自定义项目顺序只影响顶层项目行,组内仍走当前 sortBy。不得沿用 groupSessions 的
* active-first 入参序——状态=全部时,刚归档的任务必须能排在陈旧活跃任务前面。
*/
export function sortSessionsForMainList(
sessions: readonly Session[],
sortBy: FilterSortBy,
ctx: MainListPriorityContext = EMPTY_PRIORITY_CONTEXT,
): Session[] {
if (sortBy === 'priority') {
return sessions
.slice()
.sort(
(a, b) =>
sessionPriorityRank(a, ctx) - sessionPriorityRank(b, ctx) ||
sessionPriorityRecencyMs(b, ctx) - sessionPriorityRecencyMs(a, ctx),
);
}
if (sortBy === 'created') {
return sessions
.map((session, index) => ({ session, index, createdAt: sessionCreatedMs(session) }))
.sort(
(a, b) =>
b.createdAt - a.createdAt ||
a.session.id.localeCompare(b.session.id) ||
a.index - b.index,
)
.map(({ session }) => session);
}
return sessions
.map((session, index) => ({ session, index, activityAt: sessionActivityMs(session) }))
.sort((a, b) => b.activityAt - a.activityAt || a.index - b.index)
.map(({ session }) => session);
}
export interface BuildMainListEntriesInput {
/** 已过滤 / vendor 收窄后的可见项目(含各自 sessions)。 */
projects: readonly ProjectNode[];
/** 无项目归属(workspaceKind dialogue)的可见会话。 */
dialogues: readonly Session[];
/** 按伙伴分的组。平铺模式下与项目内会话一样摊成顶层条目。 */
bots?: readonly BotGroupNode[];
/** 未绑定目录的草稿。按设备分组时随条目进对应设备段。 */
unclassified?: readonly Session[];
/** 'project' = 项目行;'flat' = 项目内会话平铺为顶层条目。 */
groupBy: 'project' | 'flat';
/** true = 散排对话收进单个「对话组」条目。 */
groupDialogue: boolean;
sortBy: FilterSortBy;
projectOrder?: FilterProjectOrder;
manualProjectOrder: readonly string[];
priorityContext?: MainListPriorityContext;
notifications?: ReadonlySet<string>;
scheduleSessionIndex?: ReadonlyMap<string, AutomationScheduleSessionInfo>;
}
const EMPTY_SESSION_ID_SET: ReadonlySet<string> = new Set<string>();
export const CINDY_MAKE_GROUP_KEY = 'cindy-make';
/** Group by the task's source, never by a title or a guessed worktree path. */
export function partitionCindyMakeSessions({
projects,
dialogues,
unclassified,
}: {
projects: readonly ProjectNode[];
dialogues: readonly Session[];
unclassified: readonly Session[];
}): {
projects: ProjectNode[];
dialogues: Session[];
unclassified: Session[];
cindyMake: Session[];
} {
const cindyMake = new Map<string, Session>();
const regular = (sessions: readonly Session[]) =>
sessions.filter((session) => {
if (!isCindyMakeFamilySource(session.source)) return true;
cindyMake.set(session.id, session);
return false;
});
const regularProjects = projects.flatMap((project) => {
const sessions = regular(project.sessions);
if (sessions.length === project.sessions.length) return [project];
return sessions.length ? [{ ...project, sessions }] : [];
});
const regularDialogues = regular(dialogues);
const regularUnclassified = regular(unclassified);
return {
projects: regularProjects,
dialogues: regularDialogues,
unclassified: regularUnclassified,
cindyMake: [...cindyMake.values()],
};
}
function buildFlatSessionEntries(
sessions: readonly Session[],
sortBy: FilterSortBy,
priorityContext: MainListPriorityContext,
notifications: ReadonlySet<string>,
scheduleSessionIndex?: ReadonlyMap<string, AutomationScheduleSessionInfo>,
): SidebarSessionEntry[] {
const sortedSessions = sortSessionsForMainList(sessions, sortBy, priorityContext);
return groupAutomationSidebarEntries(sortedSessions, { notifications, scheduleSessionIndex });
}
/** 产出主列表的有序顶层条目。 */
export function buildMainListEntries({
projects,
dialogues,
bots = [],
unclassified = [],
groupBy,
groupDialogue,
sortBy,
projectOrder = 'activity',
manualProjectOrder,
priorityContext = EMPTY_PRIORITY_CONTEXT,
notifications = EMPTY_SESSION_ID_SET,
scheduleSessionIndex,
}: BuildMainListEntriesInput): MainListEntry[] {
const ctx = priorityContext;
if (!CINDY_MAKE_ENABLED) {
const keep = (session: Session) => !isCindyMakeFamilySource(session.source);
projects = projects.flatMap((project) => {
const sessions = project.sessions.filter(keep);
if (sessions.length === project.sessions.length) return [project];
return sessions.length ? [{ ...project, sessions }] : [];
});
dialogues = dialogues.filter(keep);
unclassified = unclassified.filter(keep);
bots = bots.flatMap((bot) => {
const sessions = bot.sessions.filter(keep);
if (sessions.length === bot.sessions.length) return [bot];
return sessions.length ? [{ ...bot, sessions }] : [];
});
}
const entries: MainListEntry[] = [];
const partitioned = partitionCindyMakeSessions({ projects, dialogues, unclassified });
projects = partitioned.projects;
dialogues = partitioned.dialogues;
unclassified = partitioned.unclassified;
if (partitioned.cindyMake.length) {
entries.push({
kind: 'cindy-make-group',
sessions: sortSessionsForMainList(partitioned.cindyMake, sortBy, ctx),
});
}
if (groupBy === 'flat') {
const flatEntries = buildFlatSessionEntries(
[
...projects.flatMap((project) => project.sessions),
...bots.flatMap((bot) => bot.sessions),
...dialogues,
...unclassified,
],
sortBy,
ctx,
notifications,
scheduleSessionIndex,
);
if (!groupDialogue) {
entries.push(...flatEntries);
} else {
const dialogueSessionIds = new Set(dialogues.map((session) => session.id));
const groupedDialogues: Session[] = [];
for (const entry of flatEntries) {
const sessions = getMainListEntrySessions(entry);
if (sessions.every((session) => dialogueSessionIds.has(session.id))) {
groupedDialogues.push(...sessions);
} else {
entries.push(entry);
}
}
if (groupedDialogues.length > 0) {
entries.push({
kind: 'dialogue-group',
sessions: sortSessionsForMainList(groupedDialogues, sortBy, ctx),
});
}
}
return sortMainListEntries(entries, sortBy, projectOrder, manualProjectOrder, ctx);
}
for (const project of projects) {
entries.push({
kind: 'project',
project: withProjectSessions(project, sortSessionsForMainList(project.sessions, sortBy, ctx)),
});
}
for (const bot of bots) {
entries.push({
kind: 'bot-group',
bot: { ...bot, sessions: sortSessionsForMainList(bot.sessions, sortBy, ctx) },
});
}
if (groupDialogue) {
if (dialogues.length > 0) {
entries.push({
kind: 'dialogue-group',
sessions: sortSessionsForMainList(dialogues, sortBy, ctx),
});
}
} else {
entries.push(
...buildFlatSessionEntries(dialogues, sortBy, ctx, notifications, scheduleSessionIndex),
);
}
entries.push(
...buildFlatSessionEntries(unclassified, sortBy, ctx, notifications, scheduleSessionIndex),
);
return sortMainListEntries(entries, sortBy, projectOrder, manualProjectOrder, ctx);
}
function compareEntriesBySortBy(
a: MainListEntry,
b: MainListEntry,
sortBy: FilterSortBy,
ctx: MainListPriorityContext,
): number {
if (sortBy === 'priority') {
return compareSessionGroupsByPriority(
getMainListEntrySessions(a),
getMainListEntrySessions(b),
ctx,
);
}
const timeDifference = entryTimeMs(b, sortBy) - entryTimeMs(a, sortBy);
if (timeDifference !== 0 || sortBy !== 'created') return timeDifference;
return (getMainListEntrySessions(a)[0]?.id ?? '').localeCompare(
getMainListEntrySessions(b)[0]?.id ?? '',
);
}
function sortMainListEntries(
entries: readonly MainListEntry[],
sortBy: FilterSortBy,
projectOrder: FilterProjectOrder,
manualProjectOrder: readonly string[],
ctx: MainListPriorityContext,
): MainListEntry[] {
// Cindy Make stays above ordinary entries in every sort mode and device section.
const makeGroups = entries.filter((entry) => entry.kind === 'cindy-make-group');
entries = entries.filter((entry) => entry.kind !== 'cindy-make-group');
if (projectOrder === 'custom') {
// 自定义项目序:项目行按 manualProjectOrder;不在序的新项目由 normalize
// 追加到已排序列之后。非项目条目排在项目之后,仍按当前任务排序。
const projectKeys = entries
.filter(
(entry): entry is Extract<MainListEntry, { kind: 'project' }> => entry.kind === 'project',
)
.map((entry) => entry.project.projectKey);
const normalized = normalizeManualProjectOrder(manualProjectOrder, projectKeys);
const rank = new Map(normalized.map((key, index) => [key, index]));
const sorted = entries.slice().sort((a, b) => {
const aProject = a.kind === 'project';
const bProject = b.kind === 'project';
if (aProject !== bProject) return aProject ? -1 : 1;
if (aProject && bProject) {
return (
(rank.get((a as Extract<MainListEntry, { kind: 'project' }>).project.projectKey) ??
Number.MAX_SAFE_INTEGER) -
(rank.get((b as Extract<MainListEntry, { kind: 'project' }>).project.projectKey) ??
Number.MAX_SAFE_INTEGER)
);
}
return compareEntriesBySortBy(a, b, sortBy, ctx);
});
return [...makeGroups, ...sorted];
}
return [
...makeGroups,
...entries.slice().sort((a, b) => compareEntriesBySortBy(a, b, sortBy, ctx)),
];
}
/* ============================== 设备分组(E 期) ============================== */
/** 一个设备段:本机(deviceId null)或某台 device-link 被控设备。 */
export interface MainListDeviceSection {
/** null = 本机。 */
deviceId: string | null;
entries: MainListEntry[];
}
/** Online device headers remain visible independently of task filters. */
export function onlineDeviceSectionIds(
devices: ReadonlyMap<string, { online: boolean }> | null | undefined,
selection: MachineSelection,
): Array<string | null> {
const ids: Array<string | null> = [];
if (selection === MACHINE_ALL || selection.includes(MACHINE_LOCAL)) ids.push(null);
for (const [id, device] of devices ?? []) {
if (device.online && (selection === MACHINE_ALL || selection.includes(id))) ids.push(id);
}
return ids;
}
/**
* 在线设备空段能否算作「侧栏已有内容」:本机段恒算;远程段只在其任务快照已就绪时算。
* 首次读取中 / 失败的远程设备只有一个空段头,不能遮掉整屏的加载或失败提示
* (单机范围选中一台正在加载的远程设备时尤其如此)。
*/
export function hasSettledOnlineDeviceSection(
devices: ReadonlyMap<string, { online: boolean }> | null | undefined,
selection: MachineSelection,
unsettledDeviceIds: ReadonlySet<string>,
): boolean {
return onlineDeviceSectionIds(devices, selection).some(
(id) => id === null || !unsettledDeviceIds.has(id),
);
}
function entryDeviceId(entry: MainListEntry): string | null {
if (entry.kind === 'project') return entry.project.deviceLinkDeviceId ?? null;
if (entry.kind === 'session') return entry.session.deviceLinkDeviceId ?? null;
if (entry.kind === 'automation-group') {
return entry.group.sessions[0]?.deviceLinkDeviceId ?? null;
}
// 对话组与伙伴组已经按成员设备拆分,此时首条会话代表整个片段。
if (entry.kind === 'bot-group') {
return entry.bot.sessions[0]?.deviceLinkDeviceId ?? null;
}
// 对话组同样已拆成单设备片段。
return entry.sessions[0]?.deviceLinkDeviceId ?? null;
}
/**
* 把有序顶层条目切成设备段(E 期「按设备分组」):
* - 段顺序:本机在前,远程设备按 deviceOrder(设备切换栏同序);
* 不在 deviceOrder 里的设备(断线缓存等)按段内最新活动排在其后。
* - 段内按当前 sortBy 重排(跨设备对话组拆开后,不能再沿用整组位置)。
* - 「对话归为一组」开启时,跨设备的对话组和伙伴组会被拆成每设备一组——调用方无需
* 预切分,分组身份不变,成员只保留本设备的任务。
*/
export function splitEntriesByDevice(
entries: readonly MainListEntry[],
deviceOrder: readonly string[],
options: {
onlineDeviceIds?: readonly (string | null)[];
sortBy?: FilterSortBy;
projectOrder?: FilterProjectOrder;
manualProjectOrder?: readonly string[];
priorityContext?: MainListPriorityContext;
} = {},
): MainListDeviceSection[] {
// 先把跨设备会话组拆开,再按每个片段的成员计算排序和设备聚合灯。
const flattened: MainListEntry[] = [];
for (const entry of entries) {
if (
entry.kind !== 'dialogue-group' &&
entry.kind !== 'cindy-make-group' &&
entry.kind !== 'bot-group'
) {
flattened.push(entry);
continue;
}
const byDevice = new Map<string | null, Session[]>();
for (const s of getMainListEntrySessions(entry)) {
const key = s.deviceLinkDeviceId ?? null;
const list = byDevice.get(key);
if (list) list.push(s);
else byDevice.set(key, [s]);
}
for (const sessions of byDevice.values()) {
if (entry.kind === 'bot-group')
flattened.push({ kind: 'bot-group', bot: { ...entry.bot, sessions } });
else flattened.push({ kind: entry.kind, sessions });
}
}
const sections = new Map<string | null, MainListEntry[]>(
(options.onlineDeviceIds ?? []).map((id) => [id, []]),
);
for (const entry of flattened) {
const key = entryDeviceId(entry);
const list = sections.get(key);
if (list) list.push(entry);
else sections.set(key, [entry]);
}
const orderedIds: Array<string | null> = [null, ...deviceOrder];
const result: MainListDeviceSection[] = [];
for (const id of orderedIds) {
const sectionEntries = sections.get(id);
if (sectionEntries) {
result.push({
deviceId: id,
entries: sortSectionEntries(sectionEntries, options),
});
sections.delete(id);
}
}
// 不在 deviceOrder 的残余设备(断线缓存):按段内最新活动追加。
const rest = [...sections.entries()]
.filter(([, sectionEntries]) => sectionEntries.length > 0)
.map(([deviceId, sectionEntries]) => ({
deviceId,
entries: sortSectionEntries(sectionEntries, options),
}))
.sort(
(a, b) =>
Math.max(...b.entries.map((entry) => entryTimeMs(entry, options.sortBy))) -
Math.max(...a.entries.map((entry) => entryTimeMs(entry, options.sortBy))),
);
result.push(...rest);
return result;
}
function sortSectionEntries(
entries: readonly MainListEntry[],
options: {
sortBy?: FilterSortBy;
projectOrder?: FilterProjectOrder;
manualProjectOrder?: readonly string[];
priorityContext?: MainListPriorityContext;
},
): MainListEntry[] {
if (!options.sortBy) return [...entries];
return sortMainListEntries(
entries,
options.sortBy,
options.projectOrder ?? 'activity',
options.manualProjectOrder ?? [],
options.priorityContext ?? EMPTY_PRIORITY_CONTEXT,
);
}