mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
Several everyday interactions re-rendered the entire shell (AppView, TopTabs,
TerminalLayer and every pane) even though nothing they show had changed:
- Clicking or focusing a split pane always replaced the workspaces array
(twice per click: onClick + onFocusCapture), cascading through the whole
app and re-saving the session restore snapshot. setWorkspaceFocusedSession
and moveFocusInWorkspace now keep the same array when focus is unchanged
(domain/workspace.ts setWorkspaceFocusedSessionId).
- Every window focus/visibility change resynced app lock and produced a new
runtime state object even when nothing changed, re-rendering the provider
tree. Equal states keep the current object and useAppLockState's result is
memoized.
- Quick switcher keystrokes went through AppSideEffects state and the
app-local UI store, re-rendering AppSideEffects, every host island, AppShell,
AppView and TopTabs per character. QuickSwitcherOverlay now owns the query
and host results; the overlay unmounts on close, which resets the query
exactly where setQuickSearch('') used to.
- Pressing/releasing Ctrl/Cmd (every ⌘C/⌘V/Ctrl+C) re-rendered the whole tab
bar to toggle shortcut number badges. The held flag now lives in a small
store read only by each tab's TabIconSlot.
- AppView passed fresh inline callbacks that defeated TopTabs' memo comparator
and every open editor tab; TextEditorTabView is now memoized. TopTabs
memoizes per-workspace session lists and hoists the root tab icons.
- Workspace drag previews only update state when the drop hint actually moves.
React commits / render time for 10 repetitions in the real app (profiling
build, 2 split panes, 300 hosts), main -> this change:
window focus 42 / 17.1 ms -> 2 / 0.4 ms
press/release Cmd 50 / 41.9 ms -> 22 / 6.6 ms
click focused pane 42 / 69.6 ms -> 3 / 0.4 ms
quick switcher typing 41 / 61.3 ms -> 16 / 34.8 ms
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
105 lines
3.8 KiB
TypeScript
105 lines
3.8 KiB
TypeScript
import { useCallback, useEffect, useState } from 'react';
|
|
|
|
export type RuntimeAppLockReason = 'startup' | 'idle' | 'manual' | 'background' | null;
|
|
|
|
export interface RuntimeAppLockState {
|
|
initialized: boolean;
|
|
locked: boolean;
|
|
reason: RuntimeAppLockReason;
|
|
version: number;
|
|
lastLockedAt: number | null;
|
|
lastUnlockedAt: number | null;
|
|
lastActivityAt: number | null;
|
|
}
|
|
|
|
export function normalizeRuntimeAppLockState(input: unknown): RuntimeAppLockState {
|
|
const record = input && typeof input === 'object' ? input as Record<string, unknown> : null;
|
|
const reason = record?.reason;
|
|
|
|
return {
|
|
initialized: record?.initialized === true,
|
|
locked: record?.locked === true,
|
|
reason:
|
|
reason === 'startup' ||
|
|
reason === 'idle' ||
|
|
reason === 'manual' ||
|
|
reason === 'background'
|
|
? reason
|
|
: null,
|
|
version: typeof record?.version === 'number' && Number.isFinite(record.version) ? record.version : 0,
|
|
lastLockedAt: typeof record?.lastLockedAt === 'number' && Number.isFinite(record.lastLockedAt) ? record.lastLockedAt : null,
|
|
lastUnlockedAt: typeof record?.lastUnlockedAt === 'number' && Number.isFinite(record.lastUnlockedAt) ? record.lastUnlockedAt : null,
|
|
lastActivityAt: typeof record?.lastActivityAt === 'number' && Number.isFinite(record.lastActivityAt) ? record.lastActivityAt : null,
|
|
};
|
|
}
|
|
|
|
const DEFAULT_RUNTIME_APP_LOCK_STATE: RuntimeAppLockState = normalizeRuntimeAppLockState(null);
|
|
|
|
export function selectPreferredRuntimeAppLockState(
|
|
current: RuntimeAppLockState,
|
|
incoming: RuntimeAppLockState,
|
|
): RuntimeAppLockState {
|
|
if (incoming.version > current.version) return incoming;
|
|
if (incoming.version < current.version) return current;
|
|
if (incoming.initialized && !current.initialized) return incoming;
|
|
if (!incoming.initialized && current.initialized) return current;
|
|
// Every window focus/visibility change resyncs; keep the current object when
|
|
// nothing changed so the gate (and the provider tree under it) does not
|
|
// re-render.
|
|
return isSameRuntimeAppLockState(current, incoming) ? current : incoming;
|
|
}
|
|
|
|
function isSameRuntimeAppLockState(left: RuntimeAppLockState, right: RuntimeAppLockState): boolean {
|
|
return left.initialized === right.initialized
|
|
&& left.locked === right.locked
|
|
&& left.reason === right.reason
|
|
&& left.version === right.version
|
|
&& left.lastLockedAt === right.lastLockedAt
|
|
&& left.lastUnlockedAt === right.lastUnlockedAt
|
|
&& left.lastActivityAt === right.lastActivityAt;
|
|
}
|
|
|
|
export function useAppLockRuntime(
|
|
bridge: Pick<
|
|
NonNullable<NetcattyBridge>,
|
|
'getAppLockRuntimeState' | 'onAppLockRuntimeStateChanged'
|
|
> | null | undefined,
|
|
) {
|
|
const [runtimeState, setRuntimeState] = useState<RuntimeAppLockState>(DEFAULT_RUNTIME_APP_LOCK_STATE);
|
|
const refreshRuntimeState = useCallback(async () => {
|
|
const nextState = await bridge?.getAppLockRuntimeState?.();
|
|
const normalized = normalizeRuntimeAppLockState(nextState);
|
|
setRuntimeState((current) => selectPreferredRuntimeAppLockState(current, normalized));
|
|
return normalized;
|
|
}, [bridge]);
|
|
|
|
useEffect(() => {
|
|
let cancelled = false;
|
|
|
|
const unsubscribe = bridge?.onAppLockRuntimeStateChanged?.((nextState) => {
|
|
if (cancelled) return;
|
|
const normalized = normalizeRuntimeAppLockState(nextState);
|
|
setRuntimeState((current) => selectPreferredRuntimeAppLockState(current, normalized));
|
|
}) ?? (() => {});
|
|
|
|
void refreshRuntimeState().catch(() => {
|
|
if (cancelled) return;
|
|
setRuntimeState((current) => selectPreferredRuntimeAppLockState(
|
|
current,
|
|
DEFAULT_RUNTIME_APP_LOCK_STATE,
|
|
));
|
|
});
|
|
|
|
return () => {
|
|
cancelled = true;
|
|
unsubscribe();
|
|
};
|
|
}, [bridge, refreshRuntimeState]);
|
|
|
|
return {
|
|
runtimeState,
|
|
setRuntimeState,
|
|
refreshRuntimeState,
|
|
};
|
|
}
|