Open History to see the last commit
1import { useAtomValue } from "@effect/atom-react";
2import { AuthOrchestrationOperateScope } from "@t3tools/contracts";
3import { Atom } from "effect/reactivity";
4import { useMemo } from "react";
5import { threadKey } from "@t3tools/client-runtime/state/entities";
6import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
7import {
8 buildPendingNewTasks,
9 isQueuedCreationSending,
10 type PendingNewTask,
11 type ThreadOutboxSendGate,
12} from "./pending-new-tasks-model";
13import { pendingThreadCreationOutcomesAtom, withLaunchingThreads } from "./pending-thread-creation";
14import { flattenQueuedThreadMessages } from "./thread-outbox-model";
15import { environmentThreadShells } from "./threads";
16import { newTaskComposerDraftsAtom } from "./use-composer-drafts";
17import {
18 retryingQueuedMessageIdsAtom,
19 threadOutboxShellStatusesAtom,
20 useThreadOutboxMessages,
21} from "./use-thread-outbox";
22import { environmentSession, sessionHasScope } from "./session";
23import { workspaceConnections } from "./workspace";
24
25export type {
26 PendingDraftTask,
27 PendingNewTask,
28 PendingQueuedTask,
29} from "./pending-new-tasks-model";
30
31const threadOutboxSendGateAtom = Atom.make((get): ThreadOutboxSendGate => {
32 const connected = get(workspaceConnections.environmentsAtom).flatMap((environment) =>
33 environment.connectionState === "connected" ? [environment.environmentId] : [],
34 );
35 return {
36 connectedEnvironmentIds: new Set(connected),
37 operableEnvironmentIds: new Set(
38 connected.filter((environmentId) =>
39 sessionHasScope(
40 get(environmentSession.sessionStateAtom(environmentId)),
41 AuthOrchestrationOperateScope,
42 ),
43 ),
44 ),
45 shellStatuses: get(threadOutboxShellStatusesAtom),
46 retryingMessageIds: get(retryingQueuedMessageIdsAtom),
47 };
48}).pipe(Atom.withLabel("mobile:pending-new-tasks:send-gate"));
49
50export function usePendingNewTasks(): ReadonlyArray<PendingNewTask> {
51 const queuedMessagesByThreadKey = useThreadOutboxMessages();
52 const drafts = useAtomValue(newTaskComposerDraftsAtom);
53 const hiddenKeys = useAtomValue(environmentThreadShells.hiddenThreadKeysAtom);
54 const sendGate = useAtomValue(threadOutboxSendGateAtom);
55 // A delivered creation can stay queued after its thread is live and hidden.
56 const queuedMessages = flattenQueuedThreadMessages(queuedMessagesByThreadKey).filter(
57 (message) => !hiddenKeys.has(threadKey(message)),
58 );
59 return buildPendingNewTasks({
60 queuedMessages,
61 drafts,
62 sendGate,
63 });
64}
65
66/** The list's threads, with creations the outbox is sending placed as working. */
67export function useLaunchingThreads(
68 threads: ReadonlyArray<EnvironmentThreadShell>,
69): ReadonlyArray<EnvironmentThreadShell> {
70 const queuedMessagesByThreadKey = useThreadOutboxMessages();
71 const outcomes = useAtomValue(pendingThreadCreationOutcomesAtom);
72 const hiddenThreadKeys = useAtomValue(environmentThreadShells.hiddenThreadKeysAtom);
73 const sendGate = useAtomValue(threadOutboxSendGateAtom);
74 return useMemo(() => {
75 const launches = [
76 ...flattenQueuedThreadMessages(queuedMessagesByThreadKey).filter((message) =>
77 isQueuedCreationSending(message, sendGate),
78 ),
79 ...Object.values(outcomes).flatMap((outcome) =>
80 outcome.kind === "delivered" ? [outcome.message] : [],
81 ),
82 ];
83 return withLaunchingThreads({ threads, launches, hiddenThreadKeys });
84 }, [threads, queuedMessagesByThreadKey, outcomes, hiddenThreadKeys, sendGate]);
85}