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 type { ChangeRequestTerminology } from "@t3tools/client-runtime/source-control-clients"; |
| 2 | import { |
| 3 | EnvironmentId, |
| 4 | ProjectId, |
| 5 | type PullRequestListEntry, |
| 6 | type PullRequestSummary, |
| 7 | } from "@t3tools/contracts"; |
| 8 | import { RegistryContext, useAtomRefresh, useAtomValue } from "@effect/atom-react"; |
| 9 | import { Atom } from "effect/reactivity"; |
| 10 | import { useLocale, useMessages } from "gt-react-native"; |
| 11 | import { useContext, useLayoutEffect, useMemo, useState } from "react"; |
| 12 | |
| 13 | import { composerPullRequests } from "../../state/pull-requests"; |
| 14 | import { useEnvironmentQuery } from "../../state/query"; |
| 15 | import { usePullToRefresh } from "../../state/use-pull-to-refresh"; |
| 16 | import { |
| 17 | getCachedPullRequestDiffPages, |
| 18 | retainPullRequestDiffPage, |
| 19 | withWithheldFiles, |
| 20 | type PullRequestDiffPage, |
| 21 | type WithheldFileLoad, |
| 22 | } from "./pullRequestDiffPages"; |
| 23 | |
| 24 | export type PullRequestParams = { |
| 25 | readonly environmentId: string; |
| 26 | readonly projectId: string; |
| 27 | readonly repository: string; |
| 28 | readonly number: number; |
| 29 | readonly host?: string; |
| 30 | readonly navigationUrl?: string; |
| 31 | readonly navigationId?: number; |
| 32 | readonly initialSummary?: PullRequestListEntry | PullRequestSummary; |
| 33 | }; |
| 34 | |
| 35 | export type PullRequestDiffParams = PullRequestParams & { readonly commit?: string }; |
| 36 | |
| 37 | export function pullRequestTarget(params: PullRequestParams) { |
| 38 | return { |
| 39 | environmentId: EnvironmentId.make(params.environmentId), |
| 40 | input: { |
| 41 | projectId: ProjectId.make(params.projectId), |
| 42 | repository: params.repository, |
| 43 | number: params.number, |
| 44 | ...(params.host ? { host: params.host } : {}), |
| 45 | }, |
| 46 | }; |
| 47 | } |
| 48 | |
| 49 | const NO_PAGES: readonly PullRequestDiffPage[] = []; |
| 50 | const NO_PATHS: readonly string[] = []; |
| 51 | |
| 52 | type PullRequestDiffTarget = Parameters<typeof composerPullRequests.diff>[0]; |
| 53 | |
| 54 | // Keyed by the diff's serialized target, which the hook already holds as its scope. |
| 55 | const withheldFileDiff = (targetKey: string, path: string) => { |
| 56 | const target = JSON.parse(targetKey) as PullRequestDiffTarget; |
| 57 | return composerPullRequests.diff({ ...target, input: { ...target.input, path } }); |
| 58 | }; |
| 59 | |
| 60 | // One read per withheld file the reader asked for, so only that file's diff crosses the wire. |
| 61 | const withheldFileDiffsAtom = Atom.family((key: string) => { |
| 62 | const { targetKey, paths } = JSON.parse(key) as { |
| 63 | readonly targetKey: string; |
| 64 | readonly paths: readonly string[]; |
| 65 | }; |
| 66 | return Atom.make((get) => paths.map((path) => get(withheldFileDiff(targetKey, path)))).pipe( |
| 67 | Atom.withLabel(`mobile:pull-request-withheld-file-diffs:${key}`), |
| 68 | ); |
| 69 | }); |
| 70 | |
| 71 | export function usePullRequestDiffEntry(navigation: { |
| 72 | readonly addListener: ( |
| 73 | type: "transitionStart" | "transitionEnd", |
| 74 | listener: (event: { readonly data: { readonly closing: boolean } }) => void, |
| 75 | ) => () => void; |
| 76 | }) { |
| 77 | const [ready, setReady] = useState(false); |
| 78 | // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- subscribes to navigator transition events and frames to defer the diff until the opening transition ends |
| 79 | useLayoutEffect(() => { |
| 80 | if (ready) return; |
| 81 | let opening = false; |
| 82 | let closing = false; |
| 83 | const finish = () => { |
| 84 | if (!closing) setReady(true); |
| 85 | }; |
| 86 | const removeStart = navigation.addListener("transitionStart", ({ data }) => { |
| 87 | closing = data.closing; |
| 88 | if (!closing) opening = true; |
| 89 | }); |
| 90 | const removeEnd = navigation.addListener("transitionEnd", ({ data }) => { |
| 91 | closing = data.closing; |
| 92 | if (!closing) finish(); |
| 93 | }); |
| 94 | // Initial and unanimated presentations may have no transition events; let the shell paint first. |
| 95 | let frame = requestAnimationFrame(() => { |
| 96 | frame = requestAnimationFrame(() => { |
| 97 | if (!opening) finish(); |
| 98 | }); |
| 99 | }); |
| 100 | // A missing native completion must not strand the route on its loading state. |
| 101 | const fallback = setTimeout(finish, 1_000); |
| 102 | return () => { |
| 103 | removeStart(); |
| 104 | removeEnd(); |
| 105 | cancelAnimationFrame(frame); |
| 106 | clearTimeout(fallback); |
| 107 | }; |
| 108 | }, [navigation, ready]); |
| 109 | return ready; |
| 110 | } |
| 111 | |
| 112 | export function usePullRequestDiff( |
| 113 | params: PullRequestDiffParams, |
| 114 | terminology: ChangeRequestTerminology, |
| 115 | ) { |
| 116 | const reference = pullRequestTarget(params); |
| 117 | const target = { |
| 118 | ...reference, |
| 119 | input: { ...reference.input, ...(params.commit ? { commit: params.commit } : {}) }, |
| 120 | }; |
| 121 | const key = JSON.stringify(target); |
| 122 | const messages = useMessages(); |
| 123 | const locale = useLocale(); |
| 124 | const firstPageAtom = composerPullRequests.diff(target); |
| 125 | const refreshFirstPage = useAtomRefresh(firstPageAtom); |
| 126 | const { refreshing, onRefresh } = usePullToRefresh(firstPageAtom); |
| 127 | const [state, setState] = useState<{ |
| 128 | key: string; |
| 129 | cursor: string | null; |
| 130 | pages: readonly PullRequestDiffPage[]; |
| 131 | }>({ key, cursor: null, pages: NO_PAGES }); |
| 132 | const cursor = state.key === key ? state.cursor : null; |
| 133 | const query = useEnvironmentQuery( |
| 134 | composerPullRequests.diff({ |
| 135 | ...target, |
| 136 | input: { ...target.input, ...(cursor ? { cursor } : {}) }, |
| 137 | }), |
| 138 | ); |
| 139 | const pages = useMemo(() => { |
| 140 | const loaded = state.key === key ? state.pages : NO_PAGES; |
| 141 | return query.data ? retainPullRequestDiffPage(loaded, cursor, query.data) : loaded; |
| 142 | }, [cursor, key, query.data, state.key, state.pages]); |
| 143 | if (state.key !== key || state.pages !== pages) setState({ key, cursor, pages }); |
| 144 | |
| 145 | const [withheldLoads, setWithheldLoads] = useState<{ |
| 146 | readonly key: string; |
| 147 | readonly paths: readonly string[]; |
| 148 | }>({ key: "", paths: NO_PATHS }); |
| 149 | const withheldPaths = withheldLoads.key === key ? withheldLoads.paths : NO_PATHS; |
| 150 | const withheldResults = useAtomValue( |
| 151 | withheldFileDiffsAtom(JSON.stringify({ targetKey: key, paths: withheldPaths })), |
| 152 | ); |
| 153 | const registry = useContext(RegistryContext); |
| 154 | const refreshWithheldFiles = () => { |
| 155 | for (const path of withheldPaths) registry.refresh(withheldFileDiff(key, path)); |
| 156 | }; |
| 157 | const loadWithheldFile = (path: string) => { |
| 158 | // The read is keyed without the head, so even a first load must not reuse an older one. |
| 159 | registry.refresh(withheldFileDiff(key, path)); |
| 160 | if (!withheldPaths.includes(path)) setWithheldLoads({ key, paths: [...withheldPaths, path] }); |
| 161 | }; |
| 162 | // A refetch keeps showing the last patch, whose lines may not exist at the new head. |
| 163 | const withheldRefetching = withheldResults.some((result) => result.waiting); |
| 164 | const loads = new Map<string, WithheldFileLoad>(); |
| 165 | withheldPaths.forEach((path, index) => { |
| 166 | const result = withheldResults[index]; |
| 167 | if (result === undefined) return; |
| 168 | // A failed refetch still carries the last patch; show the failure instead. |
| 169 | loads.set( |
| 170 | path, |
| 171 | result._tag === "Failure" |
| 172 | ? { status: "error" } |
| 173 | : result._tag === "Success" |
| 174 | ? { status: "loaded", result: result.value } |
| 175 | : { status: "loading" }, |
| 176 | ); |
| 177 | }); |
| 178 | const pagesParsed = useMemo( |
| 179 | () => getCachedPullRequestDiffPages(pages, key, terminology, messages, locale), |
| 180 | [key, pages, terminology, messages, locale], |
| 181 | ); |
| 182 | // The server says whether a withheld file can be read alone; GitHub may refuse the whole diff. |
| 183 | const withheldFilesReadable = pages[0]?.result.withheldFilesReadable === true; |
| 184 | const parsed = withWithheldFiles( |
| 185 | pagesParsed, |
| 186 | loads, |
| 187 | withheldFilesReadable, |
| 188 | key, |
| 189 | messages, |
| 190 | locale, |
| 191 | ); |
| 192 | const patch = useMemo(() => pages.map((page) => page.result.patch).join("\n"), [pages]); |
| 193 | const nextCursor = pages.at(-1)?.result.nextCursor ?? null; |
| 194 | const canLoadMore = |
| 195 | nextCursor !== null && nextCursor !== cursor && !query.isPending && query.error === null; |
| 196 | const loadMore = () => { |
| 197 | if (!canLoadMore) return; |
| 198 | setState({ key, cursor: nextCursor, pages }); |
| 199 | }; |
| 200 | const { error, refresh: refreshPage } = query; |
| 201 | const refresh = () => { |
| 202 | if (cursor !== null && error !== null) { |
| 203 | refreshPage(); |
| 204 | return; |
| 205 | } |
| 206 | setState({ key, cursor: null, pages: NO_PAGES }); |
| 207 | refreshFirstPage(); |
| 208 | refreshWithheldFiles(); |
| 209 | }; |
| 210 | const onPullRefresh = () => { |
| 211 | setState({ key, cursor: null, pages: NO_PAGES }); |
| 212 | onRefresh(); |
| 213 | refreshWithheldFiles(); |
| 214 | }; |
| 215 | return { |
| 216 | ...query, |
| 217 | refresh, |
| 218 | parsed, |
| 219 | loadWithheldFile, |
| 220 | withheldRefetching, |
| 221 | patch, |
| 222 | nextCursor, |
| 223 | canLoadMore, |
| 224 | loadMore, |
| 225 | refreshing, |
| 226 | onPullRefresh, |
| 227 | }; |
| 228 | } |