The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import { useAtomValue } from "@effect/atom-react"; |
| 2 | import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/models"; |
| 3 | import { |
| 4 | isListedSettledThread, |
| 5 | settledShelfFrontier, |
| 6 | sortOlderSettledScopes, |
| 7 | unloadedOlderSettledCount, |
| 8 | wantedOlderSettledPages, |
| 9 | type OlderSettled, |
| 10 | type OlderSettledScope, |
| 11 | } from "@t3tools/client-runtime/state/threads"; |
| 12 | import type { EnvironmentId, ProjectId } from "@t3tools/contracts"; |
| 13 | import { Atom } from "effect/reactivity"; |
| 14 | import { useEffect, useMemo, useState } from "react"; |
| 15 | |
| 16 | import { appAtomRegistry } from "./atom-registry"; |
| 17 | import { olderSettledThreads, threadFamilies } from "./threads"; |
| 18 | |
| 19 | const NO_PAGES: ReadonlyMap<EnvironmentId, number> = new Map(); |
| 20 | const NO_OLDER_SETTLED: Atom.Atom<OlderSettled | null> = Atom.make(null); |
| 21 | |
| 22 | /** |
| 23 | * The Settled shelf for one scope when shells leave older settled threads out: which rows it may |
| 24 | * list, how many threads it holds in all, and the pages read below each environment's cut, whose |
| 25 | * rows merge into the thread list. `useOlderSettledShelfGrowth` reads the next pages. |
| 26 | */ |
| 27 | export function useOlderSettledShelf(input: { |
| 28 | readonly scopes: ReadonlyArray<OlderSettledScope>; |
| 29 | /** A collapsed shelf mounts no pages, so a reconnect reads none; expanding restores them. */ |
| 30 | readonly expanded: boolean; |
| 31 | /** Rows the shelf shows; pages are read until it lists that many. */ |
| 32 | readonly visibleCount: number; |
| 33 | }) { |
| 34 | const scopes = useMemo(() => sortOlderSettledScopes(input.scopes), [input.scopes]); |
| 35 | const scopeKey = JSON.stringify(scopes); |
| 36 | const [requested, setRequested] = useState({ scopeKey, pages: NO_PAGES }); |
| 37 | const pages = requested.scopeKey === scopeKey && input.expanded ? requested.pages : NO_PAGES; |
| 38 | const shelfScopes = scopes.map((scope) => ({ |
| 39 | scope, |
| 40 | pages: pages.get(scope.environmentId) ?? 0, |
| 41 | })); |
| 42 | const shelfKey = JSON.stringify(shelfScopes); |
| 43 | const shelf = useAtomValue(olderSettledThreads.shelfAtom(shelfScopes)); |
| 44 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- mounts older settled thread pages into the shared thread registry while the shelf shows them |
| 45 | useEffect(() => { |
| 46 | const releases = (JSON.parse(shelfKey) as typeof shelfScopes).flatMap(({ scope, pages }) => |
| 47 | pages === 0 |
| 48 | ? [] |
| 49 | : [ |
| 50 | threadFamilies.mountRows( |
| 51 | appAtomRegistry, |
| 52 | scope.environmentId, |
| 53 | olderSettledThreads.rowsKey(scope, pages), |
| 54 | olderSettledThreads.pageRowsAtom(scope, pages), |
| 55 | ), |
| 56 | ], |
| 57 | ); |
| 58 | return () => { |
| 59 | for (const release of releases) release(); |
| 60 | }; |
| 61 | }, [shelfKey]); |
| 62 | |
| 63 | const olderOf = (environmentId: EnvironmentId) => shelf.get(environmentId)?.older ?? null; |
| 64 | const pagesOf = (environmentId: EnvironmentId) => shelf.get(environmentId)?.pages; |
| 65 | const frontier = settledShelfFrontier([...shelf.values()]); |
| 66 | const loaded = shelfScopes.filter(({ pages }) => pages > 0); |
| 67 | return { |
| 68 | environments: shelf, |
| 69 | visibleCount: input.expanded ? input.visibleCount : 0, |
| 70 | pages, |
| 71 | grow: (next: ReadonlyMap<EnvironmentId, number>) => setRequested({ scopeKey, pages: next }), |
| 72 | isListed: (thread: EnvironmentThreadShell) => isListedSettledThread(thread.source, frontier), |
| 73 | /** Older settled threads in scope that are not local; add it to the local Settled rows. */ |
| 74 | unloadedCount: (threads: ReadonlyArray<EnvironmentThreadShell>) => |
| 75 | unloadedOlderSettledCount({ olderSettled: olderOf, scopes, threads }), |
| 76 | loading: loaded.some(({ scope }) => pagesOf(scope.environmentId)?.status === "pending"), |
| 77 | failed: loaded.some(({ scope }) => pagesOf(scope.environmentId)?.status === "failed"), |
| 78 | retry: () => { |
| 79 | for (const { scope, pages } of loaded) { |
| 80 | olderSettledThreads.retryPages(appAtomRegistry, scope, pages); |
| 81 | } |
| 82 | }, |
| 83 | }; |
| 84 | } |
| 85 | |
| 86 | /** Reads the next pages while the shelf lists fewer rows than it shows. */ |
| 87 | export function useOlderSettledShelfGrowth( |
| 88 | shelf: ReturnType<typeof useOlderSettledShelf>, |
| 89 | listedSettledThreads: ReadonlyArray<EnvironmentThreadShell>, |
| 90 | ) { |
| 91 | const wanted = wantedOlderSettledPages({ |
| 92 | requested: shelf.pages, |
| 93 | environments: shelf.environments, |
| 94 | listedCount: listedSettledThreads.length, |
| 95 | visibleCount: shelf.visibleCount, |
| 96 | }); |
| 97 | const { grow, pages } = shelf; |
| 98 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- requests more shelf pages when the loaded rows list fewer threads than the shelf shows |
| 99 | useEffect(() => { |
| 100 | if (wanted !== pages) grow(wanted); |
| 101 | }, [wanted, pages, grow]); |
| 102 | } |
| 103 | |
| 104 | /** |
| 105 | * Threads of these projects that this client does not hold (older settled threads), for counts |
| 106 | * shown outside the shelf, such as a removal confirm. |
| 107 | */ |
| 108 | export function readUnloadedThreadCount( |
| 109 | members: ReadonlyArray<{ readonly environmentId: EnvironmentId; readonly id: ProjectId }>, |
| 110 | threads: ReadonlyArray<EnvironmentThreadShell>, |
| 111 | ): number { |
| 112 | return unloadedOlderSettledCount({ |
| 113 | olderSettled: (environmentId) => |
| 114 | appAtomRegistry.get(olderSettledThreads.olderSettledAtom(environmentId)), |
| 115 | scopes: [...new Set(members.map((member) => member.environmentId))].map((environmentId) => ({ |
| 116 | environmentId, |
| 117 | projectIds: members.flatMap((member) => |
| 118 | member.environmentId === environmentId ? [member.id] : [], |
| 119 | ), |
| 120 | })), |
| 121 | threads: threads.filter((thread) => |
| 122 | members.some( |
| 123 | (member) => member.environmentId === thread.environmentId && member.id === thread.projectId, |
| 124 | ), |
| 125 | ), |
| 126 | }); |
| 127 | } |
| 128 | |
| 129 | /** How many older settled threads one project has, loaded or not, kept current for render. */ |
| 130 | export function useOlderSettledCount( |
| 131 | project: { readonly environmentId: EnvironmentId; readonly id: ProjectId } | null, |
| 132 | ): number { |
| 133 | const older = useAtomValue( |
| 134 | project === null |
| 135 | ? NO_OLDER_SETTLED |
| 136 | : olderSettledThreads.olderSettledAtom(project.environmentId), |
| 137 | ); |
| 138 | return project === null ? 0 : (older?.counts.get(project.id) ?? 0); |
| 139 | } |