From 9f7b390cd4314fa43d4a61373c7c6f38eab7d644 Mon Sep 17 00:00:00 2001 From: Tunglies Date: Tue, 17 Nov 2026 02:26:00 +0000 Subject: [PATCH] perf(proxies): reduce delay-driven list and card churn (#8621) * perf(proxies): reduce delay-driven list and card churn * remove test * no need changelog --- src/components/home/current-proxy-card.tsx | 24 ++++--- src/components/proxy/proxy-groups.tsx | 8 ++- src/components/proxy/use-filter-sort.ts | 3 + src/components/proxy/use-render-list.ts | 75 +++++++++++++++++----- src/hooks/use-group-delays.ts | 20 ++++-- 5 files changed, 96 insertions(+), 34 deletions(-) diff --git a/src/components/home/current-proxy-card.tsx b/src/components/home/current-proxy-card.tsx index cf41a67d3..0b8f81ed2 100644 --- a/src/components/home/current-proxy-card.tsx +++ b/src/components/home/current-proxy-card.tsx @@ -605,12 +605,14 @@ export const CurrentProxyCard = () => { [getProfileStorageKey], ) - const { select } = useProxySelection({ - onError: (error) => { + const onSelectionError = useCallback( + (error: unknown) => { console.error('代理切换失败', error) refreshProxy() }, - }) + [refreshProxy], + ) + const { select } = useProxySelection({ onError: onSelectionError }) const mode = clashConfig?.mode?.toLowerCase() || 'rule' const isGlobalMode = mode === 'global' @@ -673,7 +675,6 @@ export const CurrentProxyCard = () => { if (proxyView && lastGroupName !== selectedGroupName) { setLastGroupName(selectedGroupName) } - const delays = useGroupDelays(selectedGroupName || null) const selectedGroup = useMemo(() => { if (!proxyView || isDirectMode) return null @@ -767,10 +768,17 @@ export const CurrentProxyCard = () => { const currentProxy = currentMember ? memberDetails(currentMember) : undefined const selectedProxyName = currentMember?.ref.name ?? '' + const delays = useGroupDelays( + selectedGroupName, + currentMember, + openSelect === 'proxy', + ) const currentDelay = - currentMember && selectedGroupName - ? delayManager.getDelayFix(currentMember, selectedGroupName) - : -1 + typeof delays === 'number' + ? delays + : currentMember + ? delays.of(currentMember) + : -1 const signalInfo = currentProxy && selectedGroupName @@ -892,7 +900,7 @@ export const CurrentProxyCard = () => { const proxyOptions = useMemo( () => - isDirectMode || openSelect !== 'proxy' + isDirectMode || openSelect !== 'proxy' || typeof delays === 'number' ? [] : sortProxyOptions( unsortedProxyOptions, diff --git a/src/components/proxy/proxy-groups.tsx b/src/components/proxy/proxy-groups.tsx index f115966cb..8c308e75b 100644 --- a/src/components/proxy/proxy-groups.tsx +++ b/src/components/proxy/proxy-groups.tsx @@ -469,12 +469,14 @@ function NormalProxyGroups(props: { mode: string }) { } }, [handleScroll]) - const { select } = useProxySelection({ - onError: (error) => { + const onSelectionError = useCallback( + (error: unknown) => { console.error('代理切换失败', error) onProxies() }, - }) + [onProxies], + ) + const { select } = useProxySelection({ onError: onSelectionError }) const handleChangeProxy = useCallback( (group: ProxyGroupView, member: ResolvedProxyMember) => { diff --git a/src/components/proxy/use-filter-sort.ts b/src/components/proxy/use-filter-sort.ts index fcde83f58..ef1463718 100644 --- a/src/components/proxy/use-filter-sort.ts +++ b/src/components/proxy/use-filter-sort.ts @@ -29,6 +29,9 @@ export function filterSort( const regex1 = /delay([=<>])(\d+|timeout|error)/i const regex2 = /type=(.*)/i +export const isDelayFilter = (filterText: string) => + regex1.test(filterText.trim()) + function filterProxies( proxies: ResolvedMemberOccurrence[], groupName: string, diff --git a/src/components/proxy/use-render-list.ts b/src/components/proxy/use-render-list.ts index c1f971b10..24f1a182e 100644 --- a/src/components/proxy/use-render-list.ts +++ b/src/components/proxy/use-render-list.ts @@ -17,7 +17,7 @@ import { } from '@/types/proxy-view' import { debugLog } from '@/utils/debug' -import { filterSort } from './use-filter-sort' +import { filterSort, isDelayFilter } from './use-filter-sort' import { DEFAULT_STATE, useHeadStateNew, @@ -60,14 +60,14 @@ export const hasRenderableItems = ( ): boolean => renderList.some((item) => item.type !== 0 || !item.group.hidden) type GroupCache = { - now: string | undefined - members: ProxyGroupView['members'] + group: ProxyGroupView headState: HeadState col: number latencyTimeout: number | undefined /// This group's own delays. Compared by identity so that a test settling in one group /// does not throw away every other group's sorted order. delays: DelaySnapshot | undefined + occurrences: ResolvedMemberOccurrence[] | undefined items: IRenderItem[] } @@ -222,19 +222,51 @@ export const useRenderList = ( return current?.kind === 'group' ? [global, current.group] : [global] }, [mode, proxyView]) - // Every group this list draws, so a test settling in any of them re-sorts that group. + const repeatedNameGroups = useMemo(() => { + const repeated = new Set() + if (isChainMode) return repeated + for (const group of renderGroups) { + const names = new Set() + if ( + group.members.some(({ name }) => { + if (names.has(name)) return true + names.add(name) + return false + }) + ) { + repeated.add(group.name) + } + } + return repeated + }, [isChainMode, renderGroups]) + + // Rows own delay updates unless repeated names share the current item listener. const renderedGroupNames = useMemo(() => { - if (!proxyView) return [] - if (isChainMode) - return selectedGroup ? [selectedGroup] : [CHAIN_DELAY_GROUP] - return renderGroups.map(({ name }) => name) - }, [isChainMode, proxyView, renderGroups, selectedGroup]) + if (!proxyView || isChainMode) return [] + return renderGroups + .filter((group) => { + const state = headStates[group.name] || DEFAULT_STATE + return ( + (state.open || group === proxyView.global) && + (state.sortType === 1 || + isDelayFilter(state.filterText) || + repeatedNameGroups.has(group.name)) + ) + }) + .map(({ name }) => name) + }, [headStates, isChainMode, proxyView, renderGroups, repeatedNameGroups]) const groupDelays = useGroupsDelays(renderedGroupNames) - const groupCacheRef = useRef>(new Map()) + const groupCacheRef = useRef | null>(null) + const cachedViewRef = useRef(proxyView) const prevListRef = useRef([]) const renderList = useMemo(() => { + const cache = (groupCacheRef.current ??= new Map()) + if (cachedViewRef.current !== proxyView) { + cache.clear() + cachedViewRef.current = proxyView + } if (!proxyView) return [] if (isChainMode) { @@ -269,16 +301,13 @@ export const useRenderList = ( })) } - const cache = groupCacheRef.current - const retList = renderGroups.flatMap((group) => { const isFlat = group === proxyView.global const headState = headStates[group.name] || DEFAULT_STATE const cached = cache.get(group.name) if ( cached && - cached.now === group.now && - cached.members === group.members && + cached.group === group && cached.headState === headState && cached.col === col && cached.latencyTimeout === latencyTimeout && @@ -300,9 +329,18 @@ export const useRenderList = ( }, ] + // Duplicate names share one item listener until the delay-store fix lands. + const refreshRepeated = + repeatedNameGroups.has(group.name) && + cached?.delays !== groupDelays.get(group.name) + let resolved = + cached?.group === group && !refreshRepeated + ? cached.occurrences + : undefined if (headState.open || isFlat) { + resolved ??= resolveOccurrences(proxyView, group) const occurrences = filterSort( - resolveOccurrences(proxyView, group), + resolved, group.name, headState.filterText, headState.sortType, @@ -337,15 +375,17 @@ export const useRenderList = ( })), ) } + } else { + resolved = undefined } cache.set(group.name, { - now: group.now!, - members: group.members, + group, headState, col, latencyTimeout: latencyTimeout!, delays: groupDelays.get(group.name), + occurrences: resolved, items: ret, }) return ret @@ -371,6 +411,7 @@ export const useRenderList = ( mode, proxyView, renderGroups, + repeatedNameGroups, selectedGroup, ]) diff --git a/src/hooks/use-group-delays.ts b/src/hooks/use-group-delays.ts index f8e3ce6c0..6a051923a 100644 --- a/src/hooks/use-group-delays.ts +++ b/src/hooks/use-group-delays.ts @@ -1,19 +1,27 @@ import { useCallback, useSyncExternalStore } from 'react' import delayManager, { type DelaySnapshot } from '@/services/delay' +import type { ResolvedProxyMember } from '@/types/proxy-view' -const NO_DELAYS: DelaySnapshot = { of: () => -1 } - -/** Exposes the external delay store to React, updating sort order only after a test settles. */ -export const useGroupDelays = (group: string | null): DelaySnapshot => { +/** A closed menu observes only its current member, not every settled group delay. */ +export const useGroupDelays = ( + group: string | null, + member: ResolvedProxyMember | undefined, + menuOpen: boolean, +): DelaySnapshot | number => { const subscribe = useCallback( (onSettle: () => void) => group ? delayManager.addGroupListener(group, onSettle) : () => {}, [group], ) const read = useCallback( - () => (group ? delayManager.groupDelays(group) : NO_DELAYS), - [group], + () => + group && menuOpen + ? delayManager.groupDelays(group) + : group && member + ? delayManager.getDelayFix(member, group) + : -1, + [group, member, menuOpen], ) return useSyncExternalStore(subscribe, read, read)