tracker

25.4 KB

1. // lib/shows.hl — READ-ONLY data access for a show's page (tracker.worldapi.org#4): shows, seasons,
2. // episodes, persons, genres (storage/mpackdb/, migrated by tools/migrate.hl, tracker.worldapi.org#2).
3. // Kept apart from watches.hl (the per-user watch state) and from components/show.hl (the page itself)
4. // so /unwatched and /schedule (tickets #5/#6, "reuse, don't copy") can import the same functions.
5. //
6. // No declared index beyond the migration's own ['!oldId'] (opening a table with indexes it wasn't
7. // created with is untested territory, hybriel#21 "opening a table rewrites its files") — a slug
8. // lookup is a linear scan of ~9500 shows, cheap for one page load.
9. import { MPackDB } from 'hl:mpackdb'
10. import { exists } from 'hl:fs'
11. import { storageDir, postersDir, hasId, dayStr } from './util.hl'
13. static genresTable = new MPackDB(file = storageDir + '/genres.db', primaryKey = '@id', indexes = ['!oldId'])
14. static personsTable = new MPackDB(file = storageDir + '/persons.db', primaryKey = '@id', indexes = ['!oldId'])
15. static showsTable = new MPackDB(file = storageDir + '/shows.db', primaryKey = '@id', indexes = ['!oldId'])
16. static seasonsTable = new MPackDB(file = storageDir + '/seasons.db', primaryKey = '@id', indexes = ['!oldId'])
17. static episodesTable = new MPackDB(file = storageDir + '/episodes.db', primaryKey = '@id', indexes = ['!oldId'])
19. // the show with this urlSegment (slug), or null. tracker#28: by a slug → id map (one scan, at the first call) — the old scan of
20. // every record per call (twice per show page) decoded every title's cast + crew: 82 ms per call on the live copy before the
21. // credits, growing with them. A slug the map does not know (a title added since: import, filmography) costs one scan as before
22. // and is remembered; slugs never change. (Flat static written key by key, like people.hl's maps.)
23. // tracker#31 (mission 026): a MERGED title's slug (a tombstone's, below) and a keeper's former slug (`oldSlugs`) answer the
24. // KEEPER — several records can share one slug (migrated duplicates did), so each slug has a rank: a live record's own slug (3)
25. // beats a live record's former one (2) beats a tombstone's (1).
26. static slugIds = {}
27. static slugRank = {}
28. static slugIdsBuilt = { yes = false }
30. // ---- merged titles (tracker#31, mission 026, merge.hl) ----------------------------------------------------------------------
31. // The old tracker left 68 titles as 2–6 records each (same type + TMDB id). The repair (merge.hl) keeps ONE record (the keeper)
32. // and turns the others into TOMBSTONES — never deleted: `mergedInto` = the keeper's id, `mergedTmdbId` (their `tmdbId` is
33. // null, so nothing looks them up by it), `mergedSeasons` (their `seasons` are empty). Every list skips them (isPublicTitle),
34. // every job skips them, a tombstone's slug and short id lead to the keeper.
35. static isMerged = (&show) => { return show != null && show.mergedInto != null }
36. // the record a page shows for this one: the keeper of a tombstone (a chain is followed, at most 5 steps), else itself
37. static liveShowOf = (&show) => {
38. let s = show
39. let n = 0
40. while (s != null && s.mergedInto != null && n < 5) {
41. s = showsTable.fetch(s.mergedInto)
42. n = n + 1
43. }
44. return s
45. }
46. static holdsSlug = (&s, &slug) => { return s.urlSegment == slug || (s.oldSlugs != null && s.oldSlugs.includes(slug)) }
47. // this record's slugs into the map (at the build, and by merge.hl after a merge changed a record)
48. static noteSlugsOf = (&s) => {
49. live = s.mergedInto == null
50. mine = []
51. if (s.urlSegment != null) { mine.push({ slug = s.urlSegment rank = live ? 3 : 1 }) }
52. if (live && s.oldSlugs != null) { for (o of s.oldSlugs) { mine.push({ slug = o rank = 2 }) } }
53. for (m of mine) {
54. let cur = slugRank[m.slug]
55. if (cur == null || m.rank >= cur || slugIds[m.slug] == s.id) {
56. slugIds[m.slug] = s.id
57. slugRank[m.slug] = m.rank
58. }
59. }
60. return null
61. }
62. static ensureSlugIds = () => {
63. if (!slugIdsBuilt.yes) {
64. for (s of showsTable.find(null, null)) { noteSlugsOf(s) }
65. slugIdsBuilt.yes = true
66. }
67. return true
68. }
69. static showBySlug = (&slug) => {
70. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
71. ensureSlugIds()
72. id = slugIds[slug]
73. if (id != null) {
74. hit = showsTable.fetch(id)
75. if (hit != null && holdsSlug(hit, slug)) { return liveShowOf(hit) }
76. }
77. let found = null
78. for (s of showsTable.find(null, null)) {
79. if (holdsSlug(s, slug) && (found == null || (found.mergedInto != null && s.mergedInto == null))) { found = s }
80. }
81. if (found != null) {
82. noteSlugsOf(found)
83. return liveShowOf(found)
84. }
85. return null
86. }
87. // project.hl at boot: every slug that is not a live title's own any more (a tombstone's, a keeper's former one) → the keeper's
88. // page, [{ slug, path }] — answered with a 301 (a component route cannot redirect; project.hl slugMoved asks `movedPathOf`)
89. static movedPaths = {}
90. static movedSlugs = () => {
91. ensureSlugIds()
92. out = []
93. for (slug of slugRank.keys()) {
94. if (slugRank[slug] < 3) {
95. let keeper = liveShowOf(showsTable.fetch(slugIds[slug]))
96. if (keeper != null && keeper.mergedInto == null && keeper.urlSegment != null && keeper.urlSegment != slug) {
97. let to = titlePath(keeper)
98. out.push({ slug = slug path = to })
99. movedPaths['/movies/' + slug] = to
100. movedPaths['/series/' + slug] = to
101. }
102. }
103. }
104. return out
105. }
106. static movedPathOf = (&path) => { return path != null ? movedPaths[path] : null }
108. static genreById = (&id) => { return id == null ? null : genresTable.fetch(id) }
109. // /genres/<genre> (mission 058): the genre with this urlSegment ('Action', 'Sci-Fi-Fantasy'), exact first, else ignoring case
110. // — a scan of the genres table (27 rows)
111. static genreBySlug = (&slug) => {
112. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
113. lower = slug.toLowerCase()
114. let loose = null
115. for (g of genresTable.find(null, null)) {
116. if (g.urlSegment == slug) { return g }
117. if (loose == null && g.urlSegment != null && ('' + g.urlSegment).toLowerCase() == lower) { loose = g }
118. }
119. return loose
120. }
121. static personById = (&id) => { return id == null ? null : personsTable.fetch(id) }
122. static seasonById = (&id) => { return id == null ? null : seasonsTable.fetch(id) }
123. static showById = (&id) => { return id == null ? null : showsTable.fetch(id) }
124. static episodeById = (&id) => { return id == null ? null : episodesTable.fetch(id) }
126. // EVERY show / episode (tracker.worldapi.org#13, catalog.hl): read ONCE when the app starts, to build the public lists —
127. // never per request
128. static allShows = () => { return showsTable.find(null, null) }
129. static allEpisodes = () => { return episodesTable.find(null, null) }
131. // insertion sort, hand-written (no list sort(), hybriel#1) — a show has a handful of seasons at most
132. static insertDesc = (&sorted, &s) => {
133. out = []
134. let inserted = false
135. for (x of sorted) {
136. if (!inserted && s.seasonNumber >= x.seasonNumber) { out.push(s) inserted = true }
137. out.push(x)
138. }
139. if (!inserted) { out.push(s) }
140. return out
141. }
142. static insertAsc = (&sorted, &e) => {
143. out = []
144. let inserted = false
145. for (x of sorted) {
146. if (!inserted && e.episodeNumber <= x.episodeNumber) { out.push(e) inserted = true }
147. out.push(x)
148. }
149. if (!inserted) { out.push(e) }
150. return out
151. }
153. // a show's seasons, latest (highest seasonNumber) first — creator: "all seasons in reverse order,
154. // latest on top"
155. static seasonsOfShow = (&show) => {
156. let sorted = []
157. for (id of show.seasons) {
158. let s = seasonsTable.fetch(id)
159. if (s != null) { sorted = insertDesc(sorted, s) }
160. }
161. return sorted
162. }
164. // a season's episodes, in episode-number order
165. static episodesOfSeason = (&season) => {
166. let sorted = []
167. for (id of season.episodes) {
168. let e = episodesTable.fetch(id)
169. if (e != null) { sorted = insertAsc(sorted, e) }
170. }
171. return sorted
172. }
174. // ---- labels shared by every list (tracker.worldapi.org#8) -------------------------------------
175. static pad2 = (&n) => {
176. let s = '' + n
177. while (s.length < 2) { s = '0' + s }
178. return s
179. }
181. // an episode as `S01E01` (creator: "write it like that: S01E01") — /my/shows, /my/unwatched, /my/schedule
182. static episodeCode = (&seasonNumber, &episodeNumber) => { return 'S' + pad2(seasonNumber) + 'E' + pad2(episodeNumber) }
184. // the show's year: `year`, else the first 4 characters of `release` ('YYYY-MM-DD'; 197 migrated shows have
185. // no year, a few of those an empty release) — null when neither gives one
186. static showYear = (&show) => {
187. if (show.year != null) { return '' + show.year }
188. if (show.release != null && hlTypeName(show.release) == 'String' && show.release.length >= 4) { return show.release.slice(0, 4) }
189. return null
190. }
192. // a show's title as every list shows it: `Doctor Who (2005)` (creator: so same-named shows can be told apart)
193. static titleWithYear = (&show) => {
194. y = showYear(show)
195. return y != null ? show.title + ' (' + y + ')' : show.title
196. }
198. // ---- the description (tracker#18) ---------------------------------------------------------------
199. // creator: "i put the summary in an own field for tmdb because some summaries i wanted to rewrite ... in that case the summary
200. // has priority over maze or tmdb" — `summary` (the creator's own text, never written by the sync), else TMDB's `tmdbSummary`,
201. // else TVmaze's `tvmazeSummary` (HTML stripped); '' when none
202. static hasText = (&v) => { return v != null && hlTypeName(v) == 'String' && v.trim() != '' }
203. static summaryOf = (&show) => {
204. if (show == null) { return '' }
205. if (hasText(show.summary)) { return show.summary }
206. if (hasText(show.tmdbSummary)) { return show.tmdbSummary }
207. if (hasText(show.tvmazeSummary)) { return show.tvmazeSummary }
208. return ''
209. }
211. // ---- a series' status (tracker#35, mission 030) -----------------------------------------------------------------------
212. // The page's status pill (components/show.hl) next to a series' or show's title: TVmaze's `tvmazeStatus` (Running, Ended, To Be
213. // Determined, In Development — stored by the sync and backfill.hl's status backfill) when there is one — creator: "this was also
214. // something tvmaze was better updated about" — else TMDB's `status` (Returning Series, In Production, Planned, Pilot, Ended,
215. // Canceled). TVmaze has no "canceled": its Ended + TMDB's Canceled shows Canceled (the same state, TMDB's word says more).
216. // tracker#35 follow-up (mission 033): TVmaze's "Running" reads stale to the creator (Twisted Metal between seasons) — its LABEL
217. // is "Returning", or "Airing" while an episode of the series aired in the last 7 days or airs in the next 7 (the stored episodes'
218. // `release`, `isAiring`). Only the label: the stored tvmazeStatus stays "Running"; every other word (Ended, Canceled, To Be
219. // Determined, TMDB's) is shown as before.
220. // { text, tone } — tone running | pending | ended | canceled | other (the pill's colour, styles.hl); text '' = no pill (a movie,
221. // or no status known).
222. static statusTones = { 'Running' = 'running' 'Returning Series' = 'running' 'To Be Determined' = 'pending' 'In Development' = 'pending'
223. 'In Production' = 'pending' 'Planned' = 'pending' 'Pilot' = 'pending' 'Ended' = 'ended' 'Canceled' = 'canceled' }
224. static statusOf = (&show) => {
225. if (show == null || show.type == 'movie') { return { text = '' tone = '' } }
226. let word = hasText(show.tvmazeStatus) ? show.tvmazeStatus : (hasText(show.status) ? show.status : '')
227. if (word == 'Ended' && show.status == 'Canceled') { word = 'Canceled' }
228. if (word == '') { return { text = '' tone = '' } }
229. tone = statusTones[word]
230. let text = word == 'Returning Series' ? 'Returning' : word
231. if (word == 'Running') { text = isAiring(show) ? 'Airing' : 'Returning' }
232. return { text = text tone = tone != null ? tone : 'other' }
233. }
234. // an episode released today-7 … today+7 (UTC days, both ends included); only the two newest numbered seasons are looked at (an
235. // airing episode is in one of them — The Simpsons has 36 seasons). Specials (season 0; the sync keeps them only for a show that
236. // already has one) do not count: Family Guy's special of 2026-10-05 between S24 and S25 is no "Airing".
237. static isAiring = (&show) => {
238. firstDay = dayStr(-7)
239. lastDay = dayStr(7)
240. seasons = []
241. for (se of seasonsOfShow(show)) { if (se.seasonNumber != 0 && seasons.length < 2) { seasons.push(se) } }
242. let k = 0
243. while (k < seasons.length) {
244. for (id of seasons[k].episodes) {
245. let e = episodesTable.fetch(id)
246. if (e != null && hasText(e.release)) {
247. let d = e.release.slice(0, 10)
248. if (d >= firstDay && d <= lastDay) { return true }
249. }
250. }
251. k = k + 1
252. }
253. return false
254. }
256. // ---- adult titles (mission 054) -----------------------------------------------------------------
257. // `adult` on every title: true / false from TMDB, null = not known yet (the migrated rows; the app's backfill, backfill.hl
258. // `backfillTitle`, asks TMDB). The PUBLIC lists (catalog.hl: homepage rows, /movies, /shows) and the search (search.hl) show
259. // ONLY a title TMDB says is not adult — unknown counts as hidden. A title the user follows stays on /my/* and its page.
260. // A merged tombstone (tracker#31) is never public.
261. static isPublicTitle = (&show) => { return show != null && show.adult == false && show.mergedInto == null }
263. // ---- incomplete titles (tracker.worldapi.org#26; details.hl completes them, credits.hl and dailysync.hl skip them) ------------
264. // COMPLETE = TMDB's details answer went through this app once: completed (`detailsAt`, details.hl) or synced (`tmdbSync`, the
265. // last step of sync.hl's sync — the daily run, a search import) — or given up on (`detailsCheck`: TMDB 404 / adult).
266. // INCOMPLETE = every other title with a TMDB id: a filmography title (`minimal`, #26) until it is completed, an import whose
267. // sync never finished, and (tracker#33, mission 029) the old tracker's MIGRATED rows that were never synced — #26 only looked
268. // at `minimal`/`imported`, so they passed: live copy 2026-10-03, 5,697 non-adult titles (4,206 movies, 1,491 series), 691
269. // series without a single season, 209 + 84 without a poster, 389 + 120 without genres (tools/count-incomplete.hl). Also a
270. // movie with a TV answer's leftovers (below). What a title still lacks that a page shows: `missingParts`.
271. static isIncomplete = (&s) => {
272. return s != null && s.tmdbId != null && s.detailsCheck == null
273. && ((s.detailsAt == null && (s.minimal == true || s.tmdbSync == null)) || hasTvLeftovers(s))
274. }
275. // tracker#33: what a title's page would miss — the parts a complete record has when TMDB has them: 'poster', 'summary',
276. // 'genres', 'cast', 'ids' (no IMDb id), 'release', 'seasons' (a series without any). The repair does these titles first
277. // (details.hl detailsRepairQueue); tools/count-incomplete.hl counts them. A complete title can still miss one — TMDB has none
278. // (The Remaining, a 7-minute Finnish short: no poster, no IMDb id on TMDB).
279. static missingParts = (&s) => {
280. out = []
281. if (s.image == null || s.image == '') { out.push('poster') }
282. if (summaryOf(s) == '') { out.push('summary') }
283. if (s.genres == null || s.genres.length == 0) { out.push('genres') }
284. if (s.cast == null || s.cast.length == 0) { out.push('cast') }
285. if (s.imdbId == null) { out.push('ids') }
286. if (s.release == null || s.release == '') { out.push('release') }
287. if (s.type != 'movie' && (s.seasons == null || s.seasons.length == 0)) { out.push('seasons') }
288. return out
289. }
290. // mission 025 (report 021's "wrong TMDB id"): the #9 sync once asked TMDB for every followed title as `/tv/<tmdbId>` — a movie's
291. // id is ANOTHER title there (fixed in mission 006: movies go to /movie/) and the TV title's overview, status and season/episode
292. // counts were stored on the movie. On the real data only Star Trek: First Contact: its tmdbId 199 IS the movie (/movie/199),
293. // tmdbSummary was TV 199's ("Kabuhayang Swak na Swak …"), status 'Ended', seasonsCount/episodesCount 0. The movie path never
294. // writes the counts, so a movie that has them is such a record: the repair asks /movie/<id> again (withDetailsFields: overview →
295. // tmdbSummary, status, …) and firstStep drops the counts — repaired once, then it no longer matches.
296. static hasTvLeftovers = (&s) => { return s.type == 'movie' && (s.seasonsCount != null || s.episodesCount != null) }
298. // ---- the kind of a title (tracker.worldapi.org#21, mission 068) ----------------------------------------------
299. // A TV title (`type = 'series'`) is either a SERIES (TMDB's TV type Scripted, Miniseries, Documentary) or a SHOW (Reality,
300. // Talk Show, News, Video — or one of our genres Reality / Talk / News, whatever the type). Stored on the title as `kind`
301. // ('series' | 'show') and TMDB's type as `tmdbType`: by the kind backfill (backfill.hl `kindTitle`, one TMDB request per
302. // title without a show genre), the daily sync and the search import. Until a title has `kind`, its genres decide (no
303. // type known yet = series). Movies are `type = 'movie'` and have no kind.
304. static showTmdbTypes = ['Reality', 'Talk Show', 'News', 'Video']
305. static showGenreNames = ['Reality', 'Talk', 'News']
306. static showGenreIdsOf = () => {
307. out = {}
308. for (g of genresTable.find(null, null)) { if (g.name != null && showGenreNames.includes('' + g.name)) { out[g.id] = true } }
309. return out
310. }
311. // the genre ids that make a title a show — read once (the genres table never changes while the app runs)
312. static showGenreIds = showGenreIdsOf()
313. static hasShowGenre = (&genres) => {
314. if (genres == null) { return false }
315. for (g of genres) { if (showGenreIds[g] == true) { return true } }
316. return false
317. }
318. // 'show' | 'series' from TMDB's type (null = not known) and the title's genre ids
319. static kindOfTitle = (&tmdbType, &genres) => {
320. if (hasShowGenre(genres)) { return 'show' }
321. if (tmdbType != null && showTmdbTypes.includes('' + tmdbType)) { return 'show' }
322. return 'series'
323. }
324. // 'movie' | 'series' | 'show' of a stored title
325. static titleKind = (&show) => {
326. if (show.type == 'movie') { return 'movie' }
327. if (show.kind == 'show' || show.kind == 'series') { return show.kind }
328. return kindOfTitle(show.tmdbType, show.genres)
329. }
330. // a title's own page: /movies/<slug>, /series/<slug>, /shows/<slug> (the old /shows/<slug> of a movie or series answers 301,
331. // project.hl showsRoute)
332. static titlePath = (&show) => {
333. k = titleKind(show)
334. return (k == 'movie' ? '/movies/' : (k == 'show' ? '/shows/' : '/series/')) + show.urlSegment
335. }
336. // `/shows/<slug>` (#21, mission 068; project.hl showsRoute): since the split only the game / reality / talk / news SHOWS live
337. // there — the page a series or a movie answers with a 301 instead (its own page), as does a merged duplicate's slug or a
338. // keeper's former one (tracker#31: the keeper's page); null = render the title page here (a show, or an unknown slug)
339. static showsMovedPath = (&slug) => {
340. show = showBySlug(slug)
341. return show != null && (titleKind(show) != 'show' || show.urlSegment != slug) ? titlePath(show) : null
342. }
343. // tracker.worldapi.org#20: the type word of a page heading / list label and its colour class (styles.hl `type-*`)
344. static kindWord = (&kind) => { return kind == 'movie' ? 'Movie' : (kind == 'show' ? 'Show' : 'Series') }
345. static typeWordOf = (&show) => { return kindWord(titleKind(show)) }
346. static typeClassOf = (&show) => { return 'type-word type-' + titleKind(show) }
348. // the poster file name (oldId + the migrated extension) — null when either is missing; served at
349. // /posters/<name> (images.hl), which falls back to a placeholder when the file itself isn't there
350. // yet (the real poster files are not part of the mongo export, see the report's `open`)
351. static posterName = (&show) => {
352. if (show.oldId == null || show.image == null || show.image == '') { return null }
353. return show.oldId + '.' + show.image
354. }
356. // the poster's URL for a LIST (/my/shows, tracker.worldapi.org#8): `/posters/<name>` only when the file really
357. // is in storage/mpackdb/posters/ (images.hl serves the same folder), else the ONE placeholder URL
358. // `/posters/none` — the real data has no poster files yet, and 128 different URLs all answering the same
359. // placeholder were 128 requests per page load (the browser can't cache them as one)
360. static posterUrlOf = (&show) => { return posterUrlOfName(posterName(show)) }
361. static posterUrlOfName = (&name) => { return name != null && exists(postersDir + '/' + name) ? '/posters/' + name : '/posters/none' }
363. // ---- slim per-title caches for the lists (tracker.worldapi.org#30, mission 025) ------------------------------------
364. // /my/series took 4.4 s on a process that had run the first-start jobs (0.4 s fresh): every load fetched each followed title's
365. // WHOLE record (cast + crew, up to 300 entries) and one episode per watch (11.7k fetches); /my/unwatched every season and
366. // episode of every followed title. Each fetch decodes a new object, and with a big live heap (after the jobs) every byte
367. // allocated feeds the byte-triggered GC. Now a list reads two small cached things per title:
368. // - `cardOf(id)`: { id type kind title year titleYear href posterName } — what a row shows;
369. // - `episodeRowsOf(id)`: every episode of the title as { id s e title release }, seasons latest first, episodes in order
370. // (the same order as seasonsOfShow/episodesOfSeason);
371. // - `episodeKeyOf(id)`: one episode as { show s e } — /my/series' last watched episode goes by the WATCHED episode's own
372. // `show` (as before): migrated episodes the sync left outside the title's seasons (a duplicate season, e.g. Reacher S03 on
373. // the real data) still count. project.hl warms every watched episode at boot.
374. // Filled at the first ask (project.hl warms the followed titles at boot) and kept in sync by catalog.hl `refreshCatalogShow`,
375. // which every writer of a title already calls after it changed one (daily sync, repair, kinds, adult backfill, imports):
376. // it calls `refreshTitleCaches(show)`, which rebuilds the entries that exist. Cached values are only ever RETURNED from a
377. // function (a `let x = map[k]` deep-copies the value; a return does not — measured: 3.7 ms per 20k-row copy).
378. static cardCache = {}
379. static episodeRowsCache = {}
380. static episodeKeyCache = {}
381. static cardFrom = (&show) => {
382. y = showYear(show)
383. return {
384. id = show.id type = show.type kind = titleKind(show) title = show.title year = y != null ? y : ''
385. titleYear = titleWithYear(show) href = titlePath(show) posterName = posterName(show)
386. }
387. }
388. static cardOf = (&id) => {
389. if (id == null) { return null }
390. if (cardCache[id] != null) { return cardCache[id] }
391. show = showsTable.fetch(id)
392. if (show == null) { return null }
393. cardCache[id] = cardFrom(show)
394. return cardCache[id]
395. }
396. static episodeRowsFrom = (&show) => {
397. out = []
398. if (show.seasons == null) { return out }
399. // loop names apart from the row's own `s`/`e` keys: inside an object literal a key set earlier shadows the variable
400. for (sn of seasonsOfShow(show)) {
401. for (ep of episodesOfSeason(sn)) {
402. out.push({ id = ep.id s = ep.seasonNumber e = ep.episodeNumber title = ep.title != null ? ep.title : '' release = ep.release })
403. }
404. }
405. return out
406. }
407. static episodeRowsOf = (&id) => {
408. if (id == null) { return [] }
409. if (episodeRowsCache[id] != null) { return episodeRowsCache[id] }
410. show = showsTable.fetch(id)
411. if (show == null) { return [] }
412. episodeRowsCache[id] = episodeRowsFrom(show)
413. return episodeRowsCache[id]
414. }
415. // an episode that is not stored is { show = null } (never fetched again)
416. static episodeKeyOf = (&id) => {
417. if (id == null) { return { show = null s = null e = null } }
418. if (episodeKeyCache[id] != null) { return episodeKeyCache[id] }
419. ep = episodesTable.fetch(id)
420. episodeKeyCache[id] = ep != null ? { show = ep.show s = ep.seasonNumber e = ep.episodeNumber } : { show = null s = null e = null }
421. return episodeKeyCache[id]
422. }
423. // a title changed (catalog.hl refreshCatalogShow): its cached entries again from the stored record; the episode keys of its
424. // episodes from the new rows (numbers the sync changed). Keys of a title nobody follows (no rows cached) are not refreshed —
425. // /my/series only reads followed titles, and warmTitleCaches covers every followed one at boot.
426. static refreshTitleCaches = (&show) => {
427. if (cardCache[show.id] != null) { cardCache[show.id] = cardFrom(show) }
428. if (episodeRowsCache[show.id] != null) {
429. episodeRowsCache[show.id] = episodeRowsFrom(show)
430. sid = show.id
431. for (r of episodeRowsOf(sid)) {
432. if (episodeKeyCache[r.id] != null) { episodeKeyCache[r.id] = { show = sid s = r.s e = r.e } }
433. }
434. }
435. return null
436. }
437. // project.hl at boot: the titles anyone follows and every watched episode, so the first /my/ load after a start is not the one
438. // that fills them
439. static warmTitleCaches = (&ids) => {
440. let n = 0
441. for (id of ids) {
442. if (cardOf(id) != null) { episodeRowsOf(id) n = n + 1 }
443. }
444. return n
445. }
446. static warmEpisodeKeys = (&ids) => {
447. for (id of ids) { episodeKeyOf(id) }
448. return ids.length
449. }
450. // merge.hl (tracker#31): an episode that moved to another title — its key is read again at the next ask
451. static forgetEpisodeKey = (&id) => {
452. episodeKeyCache[id] = null
453. return null
454. }
456. // ---- the show on other sites (tracker.worldapi.org#12) ------------------------------------------
457. // the header's link icons: TMDB, IMDb, TheTVDB, TVmaze — ONLY for the ids the show has; a movie (`type = 'movie'`)
458. // gets TMDB + IMDb. TheTVDB's id form is `/dereferrer/series/<id>` (checked 2026-10-01: it and the old
459. // `?tab=series&id=` both 301 to the slug page); the others are the sites' own id URLs (they too 301 to a slug).
460. static externalLinksOf = (&show) => {
461. out = []
462. movie = show.type == 'movie'
463. if (hasId(show.tmdbId)) { out.push({ site = 'tmdb' label = 'TMDB' title = 'On TMDB' href = 'https://www.themoviedb.org/' + (movie ? 'movie/' : 'tv/') + show.tmdbId }) }
464. if (hasId(show.imdbId)) { out.push({ site = 'imdb' label = 'IMDb' title = 'On IMDb' href = 'https://www.imdb.com/title/' + show.imdbId + '/' }) }
465. if (!movie && hasId(show.tvdbId)) { out.push({ site = 'tvdb' label = 'TVDB' title = 'On TheTVDB' href = 'https://thetvdb.com/dereferrer/series/' + show.tvdbId }) }
466. if (!movie && hasId(show.tvmzId)) { out.push({ site = 'tvmaze' label = 'TVmaze' title = 'On TVmaze' href = 'https://www.tvmaze.com/shows/' + show.tvmzId }) }
467. return out
468. }