tracker

25.1 KB

1. // lib/people.hl — THE PERSON PAGE's data (tracker.worldapi.org#16, components/person.hl `/person/<slug>`): a person by slug,
2. // their facts and filmography, and the ONE-TIME fetch of their whole filmography from TMDB on the first visit. Creator:
3. // "the movies come from artist scrolls. when one clicks on an artist that has no dataset yet the old version fetched that
4. // artist and its entire bibilogrqphy so its profile was complete".
5. //
6. // personBySlug(slug) the person (slug = `urlSegment`) — a slug → id map built once (15k people, one scan)
7. // personInfoOf(p) name, photo URL, born/died lines, bio
8. // filmographyOf(p) their credits (`p.shows`): poster, title, year, role, kind — newest first, adult titles hidden
9. // personFillStep(id) ONE step of the fetch, called again and again by the page until it answers `done`:
10. // 1st call: GET <TMDB>/person/<tmdbId>?append_to_response=combined_credits (ONE request: details +
11. // every cast/crew credit) + the photo (w185, like the posters); the person's facts are updated;
12. // every next call stores the next `fillBatch` titles; the last one links the credits and marks
13. // the person complete (`filmographyAt`, ms). hl:web serves one request at a time — between two
14. // steps every other request is served, so a person with 300 credits never holds the server.
15. // peoplePage(page) /people (tracker#37): everyone, the one updated last first, 24 per page — a view built once at boot
16. // personPhotoOf(p) the photo of a /people tile and a search row: our file, else TMDB's (`tmdbProfile`), else the placeholder
17. //
18. // COMPLETE = `filmographyAt` set: never fetched again (the daily sync may refresh followed people later — not built).
19. // Migrated people are NOT complete (153 of them carry the old tracker's credits — kept, the fetch adds the rest).
20. // A title we don't have → a MINIMAL show record (title, year, type, tmdbId, `adult`, overview, genres by TMDB id, language;
21. // no seasons, no poster file; `minimal = true` — details.hl completes it when it is opened or by the repair job, tracker#26), shaped like search.hl importTitle's
22. // (`oldId tmdb-<tv|movie>-<id>`, a free slug), indexed for the search and put into the public lists (catalog.hl).
23. // The person's credits (`shows`, the migrated field): [{ show, character, posterPath, adult }] — `character` is the role
24. // text (the characters, then crew jobs like "Director", " / " between them); `posterPath` = TMDB's, so the page can show
25. // TMDB's small poster (w92, like search's web rows) until we have the file. ADULT (TMDB's flag, mission 054): a row is
26. // shown only for a PUBLIC title (shows.hl `isPublicTitle`: `adult == false`, unknown hidden like the public lists) whose
27. // credit is not adult either (mission 056 merge).
28. // ONE PROCESS PER STORAGE (hybriel#21); new rows get self-assigned 16-hex ids (hybriel#113), like sync.hl.
29. import { now } from 'hl:time'
30. import { fetch } from 'hl:fetch'
31. import { writeFile, mkDir, exists } from 'hl:fs'
32. import { profilesDir, newId, textOr, listOr, sortDesc } from './util.hl'
33. import { personsTable, showsTable, genresTable, showById, showYear, posterUrlOf, isPublicTitle, titlePath, typeWordOf, typeClassOf, liveShowOf } from './shows.hl'
34. import { tmdbGet, tmdbImageBase } from './tmdb.hl'
35. import { titleIdByTmdb, indexShow, slugOf, indexPerson } from './search.hl'
36. import { slugBaseOf } from './search-helpers.hl'
37. import { refreshCatalogShow, pagesOf, pageNumberOf, pageSize } from './catalog.hl'
38. import { claimShortId } from './shortids.hl'
40. // titles stored per step (real data: see STATUS.md ticket #16 for the per-step time)
41. static fillBatch = 40
43. // ---- the person -------------------------------------------------------------------------------------------------
44. static slugIndex = { built = false ids = {} }
45. static ensureSlugIndex = () => {
46. if (!slugIndex.built) {
47. m = {}
48. for (p of personsTable.find(null, null)) { if (p.urlSegment != null) { m[p.urlSegment] = p.id } }
49. slugIndex.ids = m
50. slugIndex.built = true
51. }
52. return true
53. }
54. static personBySlug = (&slug) => {
55. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
56. ensureSlugIndex()
57. id = slugIndex.ids[slug]
58. return id == null ? null : personsTable.fetch(id)
59. }
61. static isComplete = (&p) => { return p.filmographyAt != null }
62. // the page asks TMDB for this person: not complete yet, and TMDB knows them
63. static needsFill = (&p) => { return !isComplete(p) && p.tmdbId != null }
65. // the photo: /profiles/<oldId>.<ext> (images.hl) — only when the file is there (the migrated `image` = 'jpg'
66. // of 129 people never came with a file)
67. static profileName = (&p) => {
68. if (p.oldId == null || p.image == null || p.image == '') { return null }
69. return p.oldId + '.' + p.image
70. }
71. static photoUrlOf = (&p) => {
72. name = profileName(p)
73. return name != null && exists(profilesDir + '/' + name) ? '/profiles/' + name : ''
74. }
76. static monthNames = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
77. // '1986-03-04' → '4 March 1986'; a bare year or anything else as it is
78. static dateText = (&d) => {
79. t = textOr(d)
80. if (t == null) { return null }
81. if (t.length < 10) { return t }
82. m = toNumber(t.slice(5, 7))
83. day = toNumber(t.slice(8, 10))
84. if (m == null || day == null || m < 1 || m > 12) { return t }
85. return day + ' ' + monthNames[m - 1] + ' ' + t.slice(0, 4)
86. }
88. // { name, photoUrl, born, died, bio } — every field a plain string ('' = none)
89. static personInfoOf = (&p) => {
90. born = dateText(p.birthDate)
91. place = textOr(p.birthPlace)
92. let bornText = ''
93. if (born != null && place != null) { bornText = 'Born ' + born + ' in ' + place } else if (born != null) { bornText = 'Born ' + born } else if (place != null) { bornText = 'Born in ' + place }
94. died = dateText(p.deathDate)
95. return { name = p.name != null ? p.name : '' photoUrl = photoUrlOf(p) born = bornText died = died != null ? 'Died ' + died : ''
96. bio = textOr(p.biography) != null ? p.biography : '' }
97. }
99. // ---- the filmography --------------------------------------------------------------------------------------------
100. // the credits, one row per title (a title twice — the migrated credit and TMDB's — is ONE row, roles merged), newest
101. // first by the title's release ('YYYY-MM-DD', else its year), undated last; only public titles (no adult/unknown)
102. static filmographyOf = (&p) => {
103. byShow = {}
104. order = []
105. for (c of listOr(p.shows)) {
106. if (c != null && c.show != null) {
107. let role = textOr(c.character)
108. let prev = byShow[c.show]
109. if (prev == null) {
110. byShow[c.show] = { role = role != null ? role : '' posterPath = textOr(c.posterPath) adult = c.adult == true }
111. order.push(c.show)
112. } else {
113. let x = prev
114. if (role != null && !(' / ' + x.role + ' / ').includes(' / ' + role + ' / ')) { x.role = x.role == '' ? role : x.role + ' / ' + role }
115. if (x.posterPath == null) { x.posterPath = textOr(c.posterPath) }
116. if (c.adult == true) { x.adult = true }
117. byShow[c.show] = x
118. }
119. }
120. }
121. list = []
122. listed = {}
123. for (sid of order) {
124. let c = byShow[sid]
125. // tracker#31: a credit on a merged tombstone is the keeper's (merge.hl repoints them; a keeper listed once)
126. let s = liveShowOf(showById(sid))
127. if (isPublicTitle(s) && !c.adult && listed[s.id] != true) {
128. listed[s.id] = true
129. let y = showYear(s)
130. let release = textOr(s.release)
131. let key = release != null && release.length >= 4 ? release : (y != null ? y : '')
132. let poster = posterUrlOf(s)
133. if (poster == '/posters/none' && c.posterPath != null) { poster = tmdbImageBase + '/w92' + c.posterPath }
134. list.push({ key = key id = s.id title = s.title year = y != null ? y : '' href = titlePath(s) posterUrl = poster
135. role = c.role typeLabel = typeWordOf(s) typeClass = typeClassOf(s) })
136. }
137. }
138. out = []
139. undated = []
140. for (r of sortDesc(list)) { if (r.key == '') { undated.push(r) } else { out.push(r) } }
141. for (r of undated) { out.push(r) }
142. return out
143. }
145. // ---- the fetch ------------------------------------------------------------------------------------------------
146. // person id → { items, pos, credits, added, requests, started, steps } while a fetch is under way (in memory: a restart
147. // loses it — the titles stored so far are found again by TMDB id, nothing is duplicated)
148. static jobs = {}
150. // TMDB genre id → ours (our genres carry TMDB's id)
151. static genreMap = { built = false ids = {} }
152. static genreIdsOfTmdb = (&tmdbIds) => {
153. if (!genreMap.built) {
154. m = {}
155. for (g of genresTable.find(null, null)) { if (g.tmdbId != null) { m['' + g.tmdbId] = g.id } }
156. genreMap.ids = m
157. genreMap.built = true
158. }
159. out = []
160. for (t of listOr(tmdbIds)) {
161. let id = genreMap.ids['' + t]
162. if (id != null && !out.includes(id)) { out.push(id) }
163. }
164. return out
165. }
167. // TMDB's combined_credits → one item per title (cast AND crew of the same title merged), TV + movies only
168. static creditItems = (&cc) => {
169. byKey = {}
170. order = []
171. all = []
172. if (cc != null) {
173. for (c of listOr(cc.cast)) { all.push({ credit = c role = textOr(c.character) }) }
174. for (c of listOr(cc.crew)) { all.push({ credit = c role = textOr(c.job) }) }
175. }
176. for (a of all) {
177. let c = a.credit
178. let kind = c.media_type
179. if ((kind == 'tv' || kind == 'movie') && c.id != null && hlTypeName(c.id) == 'Number') {
180. let k = kind + ':' + c.id
181. let known = byKey[k]
182. if (known == null) {
183. let name = kind == 'tv' ? textOr(c.name) : textOr(c.title)
184. if (name != null) {
185. byKey[k] = { kind = kind tmdbId = c.id title = name release = textOr(kind == 'tv' ? c.first_air_date : c.release_date)
186. overview = textOr(c.overview) language = textOr(c.original_language) genreIds = listOr(c.genre_ids)
187. posterPath = textOr(c.poster_path) adult = c.adult == true role = a.role != null ? a.role : '' }
188. order.push(k)
189. }
190. } else if (a.role != null && !(' / ' + known.role + ' / ').includes(' / ' + a.role + ' / ')) {
191. let x = known
192. x.role = x.role == '' ? a.role : x.role + ' / ' + a.role
193. byKey[k] = x
194. }
195. }
196. }
197. out = []
198. for (k of order) { out.push(byKey[k]) }
199. return out
200. }
202. // the photo: w185 → storage/mpackdb/profiles/<oldId>.<ext> — { requests, image, tmdbProfile, failed }
203. static syncProfile = (&p, profilePath) => {
204. out = { requests = 0 image = p.image tmdbProfile = p.tmdbProfile failed = null }
205. if (textOr(profilePath) == null || p.oldId == null) { return out }
206. parts = profilePath.split('.')
207. ext = parts[parts.length - 1].toLowerCase()
208. if (ext != 'jpg' && ext != 'jpeg' && ext != 'png' && ext != 'webp') { return out }
209. file = profilesDir + '/' + p.oldId + '.' + ext
210. if (exists(file) && p.tmdbProfile == profilePath && p.image == ext) { return out }
211. out.requests = 1
212. r = fetch(tmdbImageBase + '/w185' + profilePath, { headers = { 'user-agent' = 'tracker.worldapi.org (person page)' } timeoutMs = 20000 })
213. if (r == null || r.status != 200 || r.body == null || r.body.length == 0) {
214. out.failed = 'photo ' + profilePath + ': ' + (r == null ? 'no answer' : 'HTTP ' + r.status)
215. return out
216. }
217. mkDir(profilesDir)
218. writeFile(file, toBytes(r.body), 420)
219. out.image = ext
220. out.tmdbProfile = profilePath
221. return out
222. }
224. // step 1: TMDB's person + credits; the facts (a TMDB value that is empty never overwrites ours) and the photo
225. static startFill = (p) => {
226. t0 = now()
227. d = tmdbGet('/person/' + p.tmdbId + '?append_to_response=combined_credits')
228. if (d.failed != null) { return { error = 'TMDB: ' + d.failed } }
229. items = creditItems(d.combined_credits)
230. photo = syncProfile(p, d.profile_path)
231. x = p
232. if (textOr(d.biography) != null) { x.biography = d.biography }
233. if (textOr(d.birthday) != null) { x.birthDate = d.birthday }
234. if (textOr(d.deathday) != null) { x.deathDate = d.deathday }
235. if (textOr(d.place_of_birth) != null) { x.birthPlace = d.place_of_birth }
236. if (textOr(x.imdbId) == null && textOr(d.imdb_id) != null) { x.imdbId = d.imdb_id }
237. if (d.adult != null) { x.adult = d.adult == true }
238. x.image = photo.image
239. x.tmdbProfile = photo.tmdbProfile
240. x.updatedAt = now()
241. if (personsTable.update(x.id, x) == null) { return { error = 'could not store the person: ' + personsTable.lastError() } }
242. personTouched(x.id)
243. if (photo.failed != null) { console.log('person fill: ' + p.name + ': ' + photo.failed) }
244. jobs[p.id] = { items = items pos = 0 credits = [] added = 0 requests = 1 + photo.requests started = t0 steps = 1 tmdbMs = now() - t0 }
245. return { done = false pos = 0 total = items.length }
246. }
248. // a title we don't have: the minimal record (shape: search.hl importTitle) → its id, or null
249. static addMinimalTitle = (&cr, &pid, pname) => {
250. kindType = cr.kind == 'tv' ? 'series' : 'movie'
251. rel = cr.release
252. yr = rel != null && rel.length >= 4 ? toNumber(rel.slice(0, 4)) : null
253. slug = slugOf(cr.title, cr.tmdbId)
254. record = {
255. id = newId() title = cr.title summary = null tmdbSummary = cr.overview tmdbId = cr.tmdbId
256. language = cr.language type = kindType release = rel year = yr image = null
257. urlSegment = slug episodesCount = null homepage = null imdbId = null seasonsCount = null
258. status = null tagline = null tvdbId = null tvmzId = null genres = genreIdsOfTmdb(cr.genreIds)
259. cast = [{ person = pid character = cr.role actor = pname }] seasons = [] oldId = 'tmdb-' + cr.kind + '-' + cr.tmdbId
260. adult = cr.adult imported = now() minimal = true
261. }
262. // mission 060: its short id (shortids.hl — unique across shows and persons)
263. record.shortId = claimShortId('show', record.id, record.oldId)
264. if (showsTable.put(record) == null) {
265. console.log('person fill: "' + cr.title + '" not stored: ' + showsTable.lastError())
266. return null
267. }
268. indexShow(record)
269. refreshCatalogShow(record.id)
270. return record.id
271. }
273. // every next step: the next `fillBatch` titles; the last one links the credits and marks the person complete
274. static fillStep = (p, jobIn) => {
275. job = jobIn
276. total = job.items.length
277. let end = job.pos + fillBatch
278. if (end > total) { end = total }
279. credits = job.credits
280. let added = job.added
281. pid = p.id
282. pname = p.name
283. let i = job.pos
284. while (i < end) {
285. let item = job.items[i]
286. let sid = titleIdByTmdb(item.kind == 'tv' ? 'series' : 'movie', item.tmdbId)
287. if (sid == null) {
288. sid = addMinimalTitle(item, pid, pname)
289. if (sid != null) { added = added + 1 }
290. }
291. if (sid != null) { credits.push({ show = sid character = item.role posterPath = item.posterPath adult = item.adult }) }
292. i = i + 1
293. }
294. job.pos = end
295. job.credits = credits
296. job.added = added
297. job.steps = job.steps + 1
298. jobs[pid] = job
299. if (end < total) { return { done = false pos = end total = total } }
301. // done: the credits (+ the migrated ones TMDB no longer lists), complete
302. have = {}
303. all = []
304. for (c of credits) { have[c.show] = true all.push(c) }
305. for (c of listOr(p.shows)) { if (c != null && c.show != null && have[c.show] != true) { all.push(c) } }
306. x = p
307. x.shows = all
308. x.filmographyAt = now()
309. x.updatedAt = x.filmographyAt
310. if (personsTable.update(x.id, x) == null) { return { error = 'could not store the filmography: ' + personsTable.lastError() } }
311. personTouched(x.id)
312. personsTable.persist()
313. showsTable.persist()
314. jobs[pid] = null
315. console.log('person fill: ' + pname + ' (tmdb ' + p.tmdbId + ') credits=' + total + ' added=' + added + ' requests=' + job.requests + ' steps=' + job.steps + ' tmdbMs=' + job.tmdbMs + ' ms=' + (now() - job.started))
316. return { done = true pos = total total = total added = added }
317. }
319. // one step for the person with this id: { done, pos, total } or { error }
320. static personFillStep = (&personId) => {
321. p = personsTable.fetch(personId)
322. if (p == null) { return { error = 'no such person' } }
323. if (isComplete(p)) { return { done = true } }
324. if (p.tmdbId == null) { return { error = 'TMDB does not know this person' } }
325. job = jobs[personId]
326. if (job == null) { return startFill(p) }
327. return fillStep(p, job)
328. }
330. // ---- people from a title's cast (tracker#26, details.hl completeStep) ------------------------------------------
331. // TMDB person id → our person id, built once (15k people, one scan), kept up to date by castPersonId
332. // (flat statics, written key by key like search.hl's haveTmdb: `let m = …ids` would copy the whole map — plain data
333. // deep-copies on assignment)
334. static personTmdbBuilt = { yes = false }
335. static personTmdbIds = {}
336. static personIdByTmdb = (&tmdbId) => {
337. if (!personTmdbBuilt.yes) {
338. for (p of personsTable.find(null, null)) { if (p.tmdbId != null) { personTmdbIds['' + p.tmdbId] = p.id } }
339. personTmdbBuilt.yes = true
340. }
341. return personTmdbIds['' + tmdbId]
342. }
343. // a free person slug: "Maya-Rudolph", taken → "-2", … (the migrated people's form)
344. static personSlugOf = (&name, &tmdbId) => {
345. ensureSlugIndex()
346. base = slugBaseOf(name, 'person-' + tmdbId)
347. if (slugIndex.ids[base] == null) { return base }
348. let n = 2
349. while (slugIndex.ids[base + '-' + n] != null) { n = n + 1 }
350. return base + '-' + n
351. }
352. // how many people castPersonId added since the start (details.hl counts a title's new people by the difference, tracker#28)
353. static castPeopleAdded = { n = 0 }
354. static castPeopleCount = () => { return castPeopleAdded.n }
355. // our person for one cast entry of TMDB ({ tmdbId, name, character, gender, profile }) — the one we have by TMDB id, else a NEW
356. // person (name, tmdbId, a free slug, this one credit, TMDB's profile path as `tmdbProfile` (tracker#37: the photo of /people and
357. // the search); not complete: their page fetches the rest on the first visit like any migrated person). Answers the id, or null
358. // when it could not be stored. Also a CREW person (tracker#28: `character` = the job, "Director").
359. static castPersonId = (&c, &showId) => {
360. have = personIdByTmdb(c.tmdbId)
361. if (have != null) { return have }
362. record = { id = newId() name = c.name tmdbId = c.tmdbId urlSegment = personSlugOf(c.name, c.tmdbId) oldId = 'tmdb-person-' + c.tmdbId
363. gender = c.gender image = null tmdbProfile = textOr(c.profile) adult = false birthDate = null birthPlace = null deathDate = null imdbId = null
364. shows = showId != null ? [{ show = showId character = c.character }] : [] added = now() }
365. // mission 062 (tracker#27 for #26/#28): every person the app creates gets its short id at once (shortids.hl)
366. record.shortId = claimShortId('person', record.id, record.oldId)
367. if (personsTable.put(record) == null) {
368. console.log('details: person "' + c.name + '" not stored: ' + personsTable.lastError())
369. return null
370. }
371. personTmdbIds['' + c.tmdbId] = record.id
372. slugIndex.ids[record.urlSegment] = record.id
373. indexPerson(record)
374. personTouched(record.id)
375. castPeopleAdded.n = castPeopleAdded.n + 1
376. return record.id
377. }
379. // ---- GUEST STARS (mission 062): a series' guests are NOT person records — details.hl stores them on the title ({ tmdbId, actor,
380. // character, profile, episodes, guest }, `person` only when we have them already). 160k people (most of them one-episode guests)
381. // cost 3.3 GB of RSS at boot (w061). A guest's link is `/person/tmdb/<tmdbId>?show=<show id>` (project.hl guestRoute): the FIRST
382. // open creates the person (name + role from that title's guest entry; without one — an old link — TMDB's /person/<id>), with its
383. // short id, then the person page fills it like any other.
384. static guestOf = (&showId, &tmdbId) => {
385. s = showId != null && hlTypeName(showId) == 'String' && showId != '' ? showsTable.fetch(showId) : null
386. if (s == null) { return null }
387. for (c of listOr(s.cast)) { if (c != null && c.tmdbId == tmdbId && textOr(c.actor) != null) { return c } }
388. return null
389. }
390. // our person for this TMDB person (created now when we have none) → { id, created } or { error }
391. static guestPersonId = (tmdbId, showId) => {
392. have = personIdByTmdb(tmdbId)
393. if (have != null) { return { id = have created = false } }
394. g = guestOf(showId, tmdbId)
395. let c = null
396. let inShow = null
397. if (g != null) {
398. c = { tmdbId = tmdbId name = g.actor character = g.character gender = null }
399. inShow = showId
400. } else {
401. d = tmdbGet('/person/' + tmdbId)
402. if (d.failed != null) { return { error = 'TMDB: ' + d.failed } }
403. if (textOr(d.name) == null || d.adult == true) { return { error = 'no such person' } }
404. c = { tmdbId = tmdbId name = d.name character = null gender = d.gender }
405. }
406. pid = castPersonId(c, inShow)
407. if (pid == null) { return { error = 'could not store the person' } }
408. personsTable.persist()
409. console.log('guest opened: ' + c.name + ' (tmdb ' + tmdbId + ') → new person ' + pid + (inShow != null ? ' from show ' + inShow : ' from TMDB'))
410. return { id = pid created = true }
411. }
413. // ---- /people (tracker#37, mission 032): everyone we have, the one updated last first ------------------------------------------
414. // Creator: "/people just lists persons by last one updated with poster name and pagination". LAST UPDATED = the newest of
415. // `updatedAt` (stamped by the person page's fetch, startFill / fillStep), `filmographyAt` and `added` (a person the app created);
416. // the migrated people with none of them come last (newest stored first). No adult filter (tracker#32's /people had none either).
417. // A CACHED VIEW like tracker#30's list caches (mission 025): the order is built ONCE at boot (project.hl warmPeopleView: one pass
418. // over the people + one sort, and the cast photos below — 105k people, 3–4 s on the live copy), a page only slices its 24 ids and
419. // fetches those people (~15 ms server time, any page). Kept current without a rebuild: every person the app creates or updates is
420. // `personTouched` → `recent`; the next page read moves them to the front (one pass over the ids, ~50 ms, only after a change).
421. static peopleView = { built = false ids = [] recent = [] castProfiles = 0 }
422. static updatedKeyOf = (&p) => {
423. let k = p.updatedAt != null ? p.updatedAt : 0
424. if (p.filmographyAt != null && p.filmographyAt > k) { k = p.filmographyAt }
425. if (p.added != null && p.added > k) { k = p.added }
426. return k
427. }
428. static warmPeopleView = () => {
429. if (peopleView.built) { return peopleView.ids.length }
430. peopleView.castProfiles = castProfilesOf()
431. stored = []
432. for (p of personsTable.iterate(null, null)) { stored.push({ id = p.id key = updatedKeyOf(p) }) }
433. // newest stored first: the table is in the order the people were stored, so the list is nearly sorted already (util.hl sortDesc
434. // keeps runs) and equal keys (the migrated people: 0) end newest stored first
435. newestFirst = []
436. let i = stored.length - 1
437. while (i >= 0) { newestFirst.push(stored[i]) i = i - 1 }
438. ids = []
439. for (x of sortDesc(newestFirst)) { ids.push(x.id) }
440. peopleView.ids = ids
441. peopleView.built = true
442. return ids.length
443. }
444. // a person was created or updated: first in /people from the next page read on
445. static personTouched = (&id) => {
446. if (peopleView.built && id != null) { peopleView.recent.push(id) }
447. return null
448. }
449. static peopleViewCurrent = () => {
450. if (!peopleView.built) { warmPeopleView() }
451. if (peopleView.recent.length == 0) { return true }
452. seen = {}
453. out = []
454. let i = peopleView.recent.length - 1
455. while (i >= 0) {
456. let id = peopleView.recent[i]
457. if (seen[id] != true) { seen[id] = true out.push(id) }
458. i = i - 1
459. }
460. for (id of peopleView.ids) { if (seen[id] != true) { out.push(id) } }
461. peopleView.ids = out
462. peopleView.recent = []
463. return true
464. }
465. static peopleViewStats = () => { return { people = peopleView.ids.length castProfiles = peopleView.castProfiles } }
466. static peopleCount = () => {
467. peopleViewCurrent()
468. return peopleView.ids.length
469. }
471. // a person's photo for a tile or a search row: our file (photoUrlOf), else TMDB's (`tmdbProfile`, w185 — like the filmography's
472. // TMDB posters), else TMDB's from a title's cast entry (castProfiles), else the placeholder
473. static personPhotoOf = (&p) => {
474. local = photoUrlOf(p)
475. if (local != '') { return local }
476. path = textOr(p.tmdbProfile) != null ? p.tmdbProfile : castProfiles[p.id]
477. return path != null ? tmdbImageBase + '/w185' + path : '/profiles/none'
478. }
479. // person id → TMDB's profile path from a title's cast or crew entry (credits.hl stores `profile` there: cast since tracker#28, crew
480. // since tracker#37) — for the people the credits job created before castPersonId kept it as `tmdbProfile` (live copy 2026-10-04:
481. // 51,922 of 105,018 people; the crew entries had none yet). Built at boot with the view (one pass over the titles, ~1–3 s). IN
482. // MEMORY, not written to the people: 51,907 record updates took 511 s at a start (mission 032, measured on the live copy).
483. // (Flat static written key by key, like the maps above.)
484. static castProfiles = {}
485. static castProfilesOf = () => {
486. let n = 0
487. // iterate, not find: one title decoded at a time
488. for (s of showsTable.iterate(null, null)) {
489. for (c of listOr(s.cast)) {
490. if (c != null && c.person != null && textOr(c.profile) != null && castProfiles[c.person] == null) {
491. castProfiles[c.person] = c.profile
492. n = n + 1
493. }
494. }
495. for (c of listOr(s.crew)) {
496. if (c != null && c.person != null && textOr(c.profile) != null && castProfiles[c.person] == null) {
497. castProfiles[c.person] = c.profile
498. n = n + 1
499. }
500. }
501. }
502. return n
503. }
505. // one page: { page, pages, tiles } — a tile like the title grids' (components/tilelist.hl): photo, name, no year
506. static peoplePage = (&raw) => {
507. peopleViewCurrent()
508. pages = pagesOf(peopleView.ids.length)
509. page = pageNumberOf(raw, pages)
510. tiles = []
511. for (id of peopleView.ids.slice((page - 1) * pageSize, page * pageSize)) {
512. let p = personsTable.fetch(id)
513. if (p != null && p.urlSegment != null) {
514. tiles.push({ href = '/person/' + p.urlSegment posterUrl = personPhotoOf(p) title = p.name != null ? '' + p.name : '' year = '' })
515. }
516. }
517. return { page = page pages = pages tiles = tiles }
518. }