1import { fetchTweetDetail } from "./graphql.js";
2 
3type TweetEntry = {
4  tweet: any;
5  user?: any;
6};
7 
8type ParsedEntries = {
9  entries: TweetEntry[];
10  moreCursor?: string;
11  topCursor?: string;
12  bottomCursor?: string;
13};
14 
15type ThreadResult = {
16  requestedId: string;
17  rootId: string;
18  tweets: any[];
19  totalTweets: number;
20  user?: any;
21  responses?: unknown[];
22};
23 
24function unwrapTweetResult(result: any): any {
25  if (!result) return null;
26  if (result.__typename === "TweetWithVisibilityResults" && result.tweet) {
27    return result.tweet;
28  }
29  return result;
30}
31 
32function extractTweetEntry(itemContent: any): TweetEntry | null {
33  const result = itemContent?.tweet_results?.result;
34  if (!result) return null;
35  const resolved = unwrapTweetResult(result?.tweet ?? result);
36  if (!resolved) return null;
37  const user = resolved?.core?.user_results?.result?.legacy;
38  return { tweet: resolved, user };
39}
40 
41function parseInstruction(instruction?: any): ParsedEntries {
42  const { entries: entities, moduleItems } = instruction || {};
43  const entries: TweetEntry[] = [];
44  let moreCursor: string | undefined;
45  let topCursor: string | undefined;
46  let bottomCursor: string | undefined;
47 
48  const parseItems = (items: any[]) => {
49    items?.forEach((item) => {
50      const itemContent = item?.item?.itemContent ?? item?.itemContent;
51      if (!itemContent) {
52        return;
53      }
54 
55      if (
56        itemContent.cursorType &&
57        ["ShowMore", "ShowMoreThreads"].includes(itemContent.cursorType) &&
58        itemContent.itemType === "TimelineTimelineCursor"
59      ) {
60        moreCursor = itemContent.value;
61        return;
62      }
63 
64      const entry = extractTweetEntry(itemContent);
65      if (entry) {
66        entries.push(entry);
67      }
68    });
69  };
70 
71  if (moduleItems) {
72    parseItems(moduleItems);
73  }
74 
75  for (const entity of entities ?? []) {
76    if (entity?.content?.clientEventInfo?.component === "you_might_also_like") {
77      continue;
78    }
79 
80    const { itemContent, items, cursorType, entryType, value } = entity?.content ?? {};
81    if (cursorType === "Bottom" && entryType === "TimelineTimelineCursor") {
82      bottomCursor = value;
83    }
84 
85    if (
86      itemContent?.cursorType === "Bottom" &&
87      itemContent?.itemType === "TimelineTimelineCursor"
88    ) {
89      bottomCursor = bottomCursor ?? itemContent?.value;
90    }
91 
92    if (cursorType === "Top" && entryType === "TimelineTimelineCursor") {
93      topCursor = topCursor ?? value;
94    }
95 
96    if (itemContent) {
97      const entry = extractTweetEntry(itemContent);
98      if (entry) {
99        entries.push(entry);
100      }
101      if (
102        itemContent.cursorType &&
103        ["ShowMore", "ShowMoreThreads"].includes(itemContent.cursorType) &&
104        itemContent.itemType === "TimelineTimelineCursor"
105      ) {
106        moreCursor = moreCursor ?? itemContent.value;
107      }
108 
109      if (itemContent.cursorType === "Top" && itemContent.itemType === "TimelineTimelineCursor") {
110        topCursor = topCursor ?? itemContent.value;
111      }
112    }
113 
114    if (items) {
115      parseItems(items);
116    }
117  }
118 
119  return { entries, moreCursor, topCursor, bottomCursor };
120}
121 
122function parseTweetsAndToken(response: any): ParsedEntries {
123  const instruction =
124    response?.data?.threaded_conversation_with_injections_v2?.instructions?.find(
125      (ins: any) => ins?.type === "TimelineAddEntries" || ins?.type === "TimelineAddToModule"
126    ) ??
127    response?.data?.threaded_conversation_with_injections?.instructions?.find(
128      (ins: any) => ins?.type === "TimelineAddEntries" || ins?.type === "TimelineAddToModule"
129    );
130 
131  return parseInstruction(instruction);
132}
133 
134function toTimestamp(value: string | undefined): number {
135  if (!value) return 0;
136  const parsed = Date.parse(value);
137  return Number.isNaN(parsed) ? 0 : parsed;
138}
139 
140export async function fetchTweetThread(
141  tweetId: string,
142  cookieMap: Record<string, string>,
143  includeResponses = false
144): Promise<ThreadResult | null> {
145  const responses: unknown[] = [];
146  const res = await fetchTweetDetail(tweetId, cookieMap);
147  if (includeResponses) {
148    responses.push(res);
149  }
150 
151  let { entries, moreCursor, topCursor, bottomCursor } = parseTweetsAndToken(res);
152  if (!entries.length) {
153    const errorMessage = res?.errors?.[0]?.message;
154    if (errorMessage) {
155      throw new Error(errorMessage);
156    }
157    return null;
158  }
159 
160  let allEntries = entries.slice();
161  const root = allEntries.find((entry) => entry.tweet?.legacy?.id_str === tweetId);
162  if (!root) {
163    throw new Error("Can not fetch the root tweet");
164  }
165 
166  let rootEntry = root.tweet.legacy;
167 
168  const isSameThread = (entry: TweetEntry) => {
169    const tweet = entry.tweet?.legacy;
170    if (!tweet) return false;
171    return (
172      tweet.user_id_str === rootEntry.user_id_str &&
173      tweet.conversation_id_str === rootEntry.conversation_id_str &&
174      (tweet.id_str === rootEntry.id_str ||
175        tweet.in_reply_to_user_id_str === rootEntry.user_id_str ||
176        tweet.in_reply_to_status_id_str === rootEntry.conversation_id_str ||
177        !tweet.in_reply_to_user_id_str)
178    );
179  };
180 
181  const inThread = (items: TweetEntry[]) => items.some(isSameThread);
182 
183  let hasThread = inThread(entries);
184  let maxRequestCount = 1000;
185  let topHasThread = true;
186 
187  while (topCursor && topHasThread && maxRequestCount > 0) {
188    const newRes = await fetchTweetDetail(tweetId, cookieMap, topCursor);
189    if (includeResponses) {
190      responses.push(newRes);
191    }
192 
193    const parsed = parseTweetsAndToken(newRes);
194    topHasThread = inThread(parsed.entries);
195    topCursor = parsed.topCursor;
196    allEntries = parsed.entries.concat(allEntries);
197    maxRequestCount--;
198  }
199 
200  async function checkMoreTweets(focalId: string) {
201    while (moreCursor && hasThread && maxRequestCount > 0) {
202      const newRes = await fetchTweetDetail(focalId, cookieMap, moreCursor);
203      if (includeResponses) {
204        responses.push(newRes);
205      }
206 
207      const parsed = parseTweetsAndToken(newRes);
208      moreCursor = parsed.moreCursor;
209      bottomCursor = bottomCursor ?? parsed.bottomCursor;
210 
211      hasThread = inThread(parsed.entries);
212      allEntries = allEntries.concat(parsed.entries);
213      maxRequestCount--;
214    }
215 
216    if (bottomCursor) {
217      const newRes = await fetchTweetDetail(focalId, cookieMap, bottomCursor);
218      if (includeResponses) {
219        responses.push(newRes);
220      }
221 
222      const parsed = parseTweetsAndToken(newRes);
223      allEntries = allEntries.concat(parsed.entries);
224      bottomCursor = undefined;
225    }
226  }
227 
228  await checkMoreTweets(tweetId);
229 
230  const allThreadEntries = allEntries.filter(
231    (entry) => entry.tweet?.legacy?.id_str === tweetId || isSameThread(entry)
232  );
233  const lastEntity = allThreadEntries[allThreadEntries.length - 1];
234  if (lastEntity?.tweet?.legacy?.id_str) {
235    const lastRes = await fetchTweetDetail(lastEntity.tweet.legacy.id_str, cookieMap);
236    if (includeResponses) {
237      responses.push(lastRes);
238    }
239 
240    const parsed = parseTweetsAndToken(lastRes);
241    hasThread = inThread(parsed.entries);
242    allEntries = allEntries.concat(parsed.entries);
243    moreCursor = parsed.moreCursor;
244    bottomCursor = parsed.bottomCursor;
245    maxRequestCount--;
246 
247    await checkMoreTweets(lastEntity.tweet.legacy.id_str);
248  }
249 
250  const distinctEntries: TweetEntry[] = [];
251  const entriesMap = allEntries.reduce((acc, entry) => {
252    const id = entry.tweet?.legacy?.id_str ?? entry.tweet?.rest_id;
253    if (id && !acc.has(id)) {
254      distinctEntries.push(entry);
255      acc.set(id, entry);
256    }
257    return acc;
258  }, new Map<string, TweetEntry>());
259  allEntries = distinctEntries;
260 
261  while (rootEntry.in_reply_to_status_id_str) {
262    const parent = entriesMap.get(rootEntry.in_reply_to_status_id_str)?.tweet?.legacy;
263    if (
264      parent &&
265      parent.user_id_str === rootEntry.user_id_str &&
266      parent.conversation_id_str === rootEntry.conversation_id_str &&
267      parent.id_str !== rootEntry.id_str
268    ) {
269      rootEntry = parent;
270    } else {
271      break;
272    }
273  }
274 
275  allEntries = allEntries.sort((a, b) => {
276    const aTime = toTimestamp(a.tweet?.legacy?.created_at);
277    const bTime = toTimestamp(b.tweet?.legacy?.created_at);
278    return aTime - bTime;
279  });
280 
281  const rootIndex = allEntries.findIndex(
282    (entry) => entry.tweet?.legacy?.id_str === rootEntry.id_str
283  );
284  if (rootIndex > 0) {
285    allEntries = allEntries.slice(rootIndex);
286  }
287 
288  const threadEntries = allEntries.filter(
289    (entry) => entry.tweet?.legacy?.id_str === tweetId || isSameThread(entry)
290  );
291 
292  if (!threadEntries.length) {
293    return null;
294  }
295 
296  const tweets = threadEntries.map((entry) => entry.tweet);
297  const user = threadEntries[0].user ?? threadEntries[0].tweet?.core?.user_results?.result?.legacy;
298  const result: ThreadResult = {
299    requestedId: tweetId,
300    rootId: rootEntry.id_str ?? tweetId,
301    tweets,
302    totalTweets: tweets.length,
303    user,
304  };
305 
306  if (includeResponses) {
307    result.responses = responses;
308  }
309 
310  return result;
311}
312