perf(frontend): 工具页分页/历史截断/轻量轮询/共享纯逻辑(审查 F5/F6/F9/F12/G3)

- F9 新增 useTablePaging composable 并接入 7 个工具页"匹配结果"表(只切渲染窗口,
  不加选择语义;每页 100 条)+ 深色分页样式
- F6 历史任务抽屉渲染截断(默认 50 条 + "显示全部/收起"),全选口径改为当前可见条目
- F5 新增 task-progress-polling 适配器:等待任务终态的紧循环走 /tasks/progress/light,
  异常或空响应回退重型 batch;已接入跟价/定时匹配的 waitForTaskTerminal
- F12 背景图 bg.jpg 251KB → 166KB(1920 宽 + quality 80,image-set 仍优先 webp)
- G3 抽出共享纯逻辑 task-queue-state(开始时间表序列化校验 + 记录缺失错误判定),
  5 个工具页删除逐字重复实现
- 新增 4 个单测文件(分页切片/历史截断/轻量轮询归一/任务队列纯逻辑)
This commit is contained in:
2026-09-14 06:23:46 +08:00
parent e76714c32e
commit 67223f8950
18 changed files with 684 additions and 69 deletions
@@ -0,0 +1,110 @@
import { getModuleProgressLight, type ProgressLightModule } from './progress-light.ts'
/**
* 轮询用进度适配器(2026-09 全维度审查 F5)。
*
* 后端 12 个模块都提供了 /tasks/progress/light 轻量端点(只回 status/fileReady 等白名单字段),
* 但此前全站仍在轮询 /tasks/progress/batch(回全量任务详情)。等待任务终态的紧循环
* (每几秒一次)只需要 status,用轻量端点可显著减小响应体。
*
* 安全前提(务必确认后再接入):
* 1. 调用方只用 task.id / task.status / missingTaskIds(轻量白名单覆盖的字段);
* 2. 调用方把结果**部分合并**到已有完整快照上(`{...prev.task, ...detail.task}`),
* 这样缺失字段由旧快照兜底,不会把页面数据抹空。
*
* 不满足上述前提的路径(如历史列表合并、首屏加载)请继续用重型 batch 端点。
*/
export interface LightPollingItem {
task?: {
id?: number
status?: string | null
statusCode?: string | null
fileStatus?: string | null
fileError?: string | null
fileReady?: boolean | null
updatedAt?: string | null
}
}
export function toBatchItems(lightItems: unknown[]): LightPollingItem[] {
const items: LightPollingItem[] = []
for (const raw of lightItems || []) {
const item = raw as { taskId?: number; status?: string | null; statusCode?: string | null
fileStatus?: string | null; fileError?: string | null; fileReady?: boolean | null
updatedAt?: string | null } | null
if (!item || typeof item.taskId !== 'number' || item.taskId <= 0) {
continue
}
// 归一为重型端点的嵌套形状(各模块 batch 项都是 { task: {...} }),
// 保证调用方的 detail.task?.xxx 读取与部分合并逻辑不变
items.push({
task: {
id: item.taskId,
status: item.status ?? null,
statusCode: item.statusCode ?? null,
fileStatus: item.fileStatus ?? null,
fileError: item.fileError ?? null,
fileReady: item.fileReady ?? null,
updatedAt: item.updatedAt ?? null,
},
})
}
return items
}
/**
* 各模块 batch 返回类型形状不同(`missingTaskIds` 可选/必填、明细类型各异),
* 这里按"带 items 与 missingTaskIds 的批次对象"约束,避免为每个模块写一份适配器。
*/
export interface PollingBatchLike<T> {
items?: T[]
missingTaskIds?: number[]
}
export interface PollingProgressOptions<TBatch> {
/** 重型端点兜底(轻量端点异常或返回空时调用),不传则不兜底 */
fallback?: () => Promise<TBatch>
}
/**
* 纯函数:把轻量响应判定为可用的策略结果。
* 既没有可用条目也没有 missing 列表时返回 null(调用方据此走重型兜底,
* 避免后端未上线该模块 light 路由时页面静默拿不到状态)。
*/
export function pickPollingBatch<T>(
lightItems: unknown[] | null | undefined,
missingTaskIds: number[] | null | undefined,
): PollingBatchLike<T> | null {
const items = toBatchItems(lightItems || [])
const missing = missingTaskIds || []
if (!items.length && !missing.length) {
return null
}
return { items: items as unknown as T[], missingTaskIds: missing }
}
/**
* 取任务进度:轻量端点优先,异常/空结果时回退重型端点。
* 轻量端点返回 empty(既没有 items 也没有 missingTaskIds)时也走兜底——
* 避免后端未上线该模块的 light 路由时页面静默拿不到状态。
*/
export async function getPollingProgressBatch<TBatch extends PollingBatchLike<unknown>>(
module: ProgressLightModule,
taskIds: number[],
options: PollingProgressOptions<TBatch> = {},
): Promise<TBatch> {
const fallback = options.fallback
try {
const light = await getModuleProgressLight(module, taskIds)
const picked = pickPollingBatch<unknown>(light.items, light.missingTaskIds)
if (picked) {
return picked as TBatch
}
} catch {
// 落回重型端点(下面统一处理)
}
if (fallback) {
return fallback()
}
return { items: [], missingTaskIds: [] } as unknown as TBatch
}
@@ -23,7 +23,7 @@
<div v-if="!items.length" class="empty-tasks">{{ emptyText }}</div>
<ul v-else class="history-list">
<li v-for="item in items" :key="item.key" class="history-item-row" :class="{ 'is-selected': isSelected(item.key) }">
<li v-for="item in visibleHistoryItems" :key="item.key" class="history-item-row" :class="{ 'is-selected': isSelected(item.key) }">
<label v-if="onBatchDelete" class="row-check" @click.stop>
<input v-model="selectedSet" type="checkbox" :value="item.key" :disabled="batchDeleting" />
</label>
@@ -39,6 +39,13 @@
</div>
</li>
</ul>
<!-- 渲染截断(F6):超上限时只渲染前 N 条,避免历史很多时打开抽屉即产生大量 DOM -->
<div v-if="historySlice.capped || showAll" class="history-paging">
<button v-if="historySlice.capped" type="button" class="btn-more" @click="showAll = true">
显示全部(还有 {{ historySlice.hiddenCount }} 条)
</button>
<button v-else type="button" class="btn-more" @click="showAll = false">收起</button>
</div>
</div>
</el-drawer>
</div>
@@ -50,6 +57,7 @@ import { ElMessageBox } from 'element-plus'
import TaskItemCard from './TaskItemCard.vue'
import type { TaskItemView } from './types'
import { sliceHistoryItems } from '../../utils/history-paging.ts'
const props = withDefaults(defineProps<{
/** 历史任务数量(按钮角标) */
@@ -71,14 +79,21 @@ const open = ref(false)
const batchDeleting = ref(false)
/** 勾选集合:以 TaskItemView.key 为维度 */
const selectedSet = ref<Set<string>>(new Set())
/** 是否展开全部历史(默认只渲染前 HISTORY_VISIBLE_LIMIT 条) */
const showAll = ref(false)
const historySlice = computed(() => sliceHistoryItems(props.items, showAll.value))
const visibleHistoryItems = computed(() => historySlice.value.visible)
const selectedKeys = computed(() => selectedSet.value)
const allSelected = computed({
get: () => Boolean(props.items.length) && selectedSet.value.size === props.items.length,
// 全选口径=当前可见条目(截断状态下就是屏幕上这几条),避免"全选"选中看不见的条目
get: () => Boolean(visibleHistoryItems.value.length)
&& visibleHistoryItems.value.every((item) => selectedSet.value.has(item.key)),
set: (checked: boolean) => {
const next = new Set<string>()
if (checked) {
props.items.forEach((item) => next.add(item.key))
visibleHistoryItems.value.forEach((item) => next.add(item.key))
}
selectedSet.value = next
},
@@ -87,6 +102,8 @@ const allSelected = computed({
watch(open, (value) => {
if (!value) {
selectedSet.value = new Set()
// 关闭后回到"只渲染前 N 条",下次打开不会因为上次展开过而全量渲染
showAll.value = false
}
})
@@ -133,6 +150,27 @@ async function confirmBatchDelete() {
white-space: nowrap;
}
.history-paging {
display: flex;
justify-content: center;
padding: 8px 0 4px;
}
.btn-more {
padding: 5px 14px;
border: 1px solid #3e4a62;
border-radius: 6px;
background: #242424;
color: #9fb0c8;
font-size: 12px;
cursor: pointer;
}
.btn-more:hover {
background: #2b3447;
color: #f5f8fc;
}
.history-btn:hover {
background: #2b3447;
color: #f5f8fc;
@@ -0,0 +1,62 @@
import { computed, ref, watch, type ComputedRef, type Ref } from 'vue'
/**
* 表格分页(2026-09 全维度审查 F9)。
*
* 工具页的"匹配结果"表此前把整份数据绑到 el-table 的 :data 上,全量行常驻 DOM
* (每行 8+ 节点,几百行就会明显拖慢打开/滚动)。这里提供共用的分页切片:
* 只改变渲染的数据窗口,不改动数据源本身,因此挑选/删除/提交等逻辑不受影响。
*/
/** 默认每页条数:足够一屏展示,又不会让 DOM 随列表规模线性膨胀。 */
export const DEFAULT_TABLE_PAGE_SIZE = 100
/** 纯函数切片:page 从 1 开始,越界自动收敛到有效范围。 */
export function paginateSlice<T>(items: T[] | null | undefined, page: number, pageSize: number): T[] {
const list = Array.isArray(items) ? items : []
const size = Number.isFinite(pageSize) && pageSize > 0 ? Math.floor(pageSize) : DEFAULT_TABLE_PAGE_SIZE
const pageCount = Math.max(1, Math.ceil(list.length / size))
const safePage = Math.min(Math.max(1, Math.floor(Number.isFinite(page) ? page : 1)), pageCount)
const start = (safePage - 1) * size
return list.slice(start, start + size)
}
/** 有效页码(把越界页码收敛到 [1, pageCount])。 */
export function clampPage(page: number, total: number, pageSize: number): number {
const size = Number.isFinite(pageSize) && pageSize > 0 ? Math.floor(pageSize) : DEFAULT_TABLE_PAGE_SIZE
const pageCount = Math.max(1, Math.ceil((Number.isFinite(total) ? total : 0) / size))
return Math.min(Math.max(1, Math.floor(Number.isFinite(page) ? page : 1)), pageCount)
}
export interface TablePaging<T> {
/** 当前页码(可 v-model:current-page 绑定) */
page: Ref<number>
/** 每页条数 */
pageSize: number
/** 数据总条数 */
total: ComputedRef<number>
/** 当前页数据(绑定到 el-table 的 :data) */
paged: ComputedRef<T[]>
}
/**
* 基于响应式数据源的分页状态。数据源变化(新增/删除行)时自动收敛页码,
* 避免删到空页后表格显示空白且无法回到有效页。
*/
export function useTablePaging<T>(
source: Ref<T[]> | ComputedRef<T[]>,
pageSize: number = DEFAULT_TABLE_PAGE_SIZE,
): TablePaging<T> {
const page = ref(1)
const total = computed(() => (Array.isArray(source.value) ? source.value.length : 0))
const paged = computed(() => paginateSlice(source.value, page.value, pageSize))
watch([total, () => pageSize], () => {
const next = clampPage(page.value, total.value, pageSize)
if (next !== page.value) {
page.value = next
}
})
return { page, pageSize, total, paged }
}
@@ -0,0 +1,32 @@
/**
* 历史任务抽屉的渲染截断(2026-09 全维度审查 F6)。
*
* 历史条目由页面从后端/本地缓存整批传入,抽屉此前全量渲染:条目多时(每卡 8+ 节点)
* 打开即产生大量 DOM,关闭后虽然 destroy-on-close 会销毁,但打开期间的首屏渲染成本
* 与内存占用仍随条数线性增长。这里统一按上限截断渲染,由 UI 提供「显示全部」入口。
*/
/** 首屏渲染条数上限 */
export const HISTORY_VISIBLE_LIMIT = 50
export interface HistorySlice<T> {
/** 实际渲染的条目 */
visible: T[]
/** 被截断的条数(0 表示未截断) */
hiddenCount: number
/** 是否处于截断状态 */
capped: boolean
}
export function sliceHistoryItems<T>(
items: T[] | null | undefined,
showAll: boolean,
limit: number = HISTORY_VISIBLE_LIMIT,
): HistorySlice<T> {
const list = Array.isArray(items) ? items : []
const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : HISTORY_VISIBLE_LIMIT
if (showAll || list.length <= safeLimit) {
return { visible: list, hiddenCount: 0, capped: false }
}
return { visible: list.slice(0, safeLimit), hiddenCount: list.length - safeLimit, capped: true }
}
@@ -0,0 +1,64 @@
/**
* 任务队列在工具页之间的共享纯逻辑(2026-09 全维度审查 G3)。
*
* 7 个工具页(query-asin / withdraw / price-track / product-risk / patrol-delete / shop-match /
* shop-data-crawl)各有一份逐字重复的「任务开始时间 localStorage 持久化 + 记录缺失错误判定」实现。
* 这里先收敛**无副作用、无页面状态依赖**的部分:序列化/反序列化校验、开始时间表增删、
* 记录缺失错误判定。队列 worker 的状态机(谁在跑、防抖、轮询句柄)仍留在各页,
* 那部分抽取需要真机走一遍队列流程,另行处理。
*/
/** 反序列化:只保留正整数 taskId 与非空字符串时间戳,形状不符的条目丢弃。 */
export function parseTaskStartTimes(raw: string | null | undefined): Record<number, string> {
if (!raw) {
return {}
}
let parsed: unknown
try {
parsed = JSON.parse(raw)
} catch {
return {}
}
const next: Record<number, string> = {}
for (const [taskId, value] of Object.entries((parsed || {}) as Record<string, unknown>)) {
const numericTaskId = Number(taskId)
if (!Number.isFinite(numericTaskId) || numericTaskId <= 0) continue
if (typeof value !== 'string' || !value.trim()) continue
next[numericTaskId] = value
}
return next
}
/** 写入/覆盖某个任务的开始时间(返回新对象,不修改入参)。 */
export function upsertTaskStartTime(
current: Record<number, string> | null | undefined,
taskId: number,
startedAt: string,
): Record<number, string> {
if (!Number.isFinite(taskId) || taskId <= 0) {
return { ...(current || {}) }
}
return { ...(current || {}), [taskId]: startedAt }
}
/** 移除某个任务的开始时间(不存在时返回原对象的浅拷贝)。 */
export function removeTaskStartTime(
current: Record<number, string> | null | undefined,
taskId?: number | null,
): Record<number, string> {
const base = { ...(current || {}) }
if (!taskId || !(taskId in base)) {
return base
}
delete base[taskId]
return base
}
/**
* 后端「记录不存在」类错误的判定:历史/任务已被删除时,各页据此清理本地缓存并停止轮询。
* 匹配口径与各页原实现一致(含中文关键词与 HTTP 404 / not found)。
*/
export function isRecordMissingError(error: unknown): boolean {
const message = error instanceof Error ? error.message : String(error || '')
return /记录不存在|任务不存在|不存在|已删除|not\s*found|404/i.test(message)
}