tracker

23.3 KB

1. // lib/franchises.hl — FRANCHISES AND TIMELINES (tracker.worldapi.org#19, mission 066). The creator: "we have franchises, and
2. // timelines, and some franchises have multiple timelines ... make them sortable by timeline or release date at shows the
3. // release date of the last episode counts. in a show or movie page we show a franchise widget with < Prequel | TimelineName
4. // | Sequel > and if the timeline is part of a franchise that franchise is above it and when you click on it you get the
5. // franchise index."
6. //
7. // franchisesTable pk @id index !slug { name, slug, shortId (null: not given out yet), summary, created }
8. // timelinesTable pk @id index !slug { name, slug, franchise (@id | null), order [show @id …], source ('tmdb' |
9. // 'editor' | 'seed'), tmdbCollection (TMDB collection id | null), orderKind
10. // ('in-universe' | 'release' | null: not said, tracker#40), supersededBy (@id | null),
11. // created }
12. // storage/mpackdb/{franchises,timelines}.db (new tables; nothing in shows.db changes; the seed's collectionchecks.db is
13. // collections.hl's, the curated seed's franchiseseed.db franchiseseed.hl's)
14. //
15. // A TITLE MAY BE IN SEVERAL TIMELINES (Star Trek Prime and Kelvin, or a TMDB collection and a hand-made one): `byShow` (show
16. // @id → [timeline @id]) is built once at start (`ensureFranchises`, one scan of the timelines) and kept up to date by every
17. // edit — the show page's widget reads only its own timelines, never all of them.
18. //
19. // THE ORDER of a timeline is its in-world order (`order`, editable). The pages can sort it by RELEASE instead: a movie by its
20. // `release`, a SERIES by the release date of its LAST episode (the newest one already out; none out yet → the newest
21. // announced one; no episode dates at all → the series' own `release`). Titles without any date go last.
22. //
23. // SUPERSEDED (tracker#40): a TMDB collection timeline whose every title is in ONE curated (seed) timeline is hidden — no widget,
24. // not on /franchises or a franchise's index — but kept (its own page and the editor's finder still reach it): `supersededBy` =
25. // that curated timeline. Set by the collection seed when it makes one (collections.hl) and by the curated seed's build
26. // (franchiseseed.hl), which also lifts it when the cover is gone; `seededCoverOf` decides.
27. //
28. // PUBLIC LIKE THE OTHER LISTS (mission 054): the pages and the widget's prequel/sequel links show only titles with
29. // `adult == false` (shows.hl isPublicTitle); the order keeps them, they are just skipped.
30. //
31. // THE SEEDS: TMDB movie collections → timelines (collections.hl); the curated franchises of data/franchises.json, movies AND
32. // series (franchiseseed.hl, tracker#40) — both write through the functions here.
33. //
34. // ONE PROCESS PER STORAGE (hybriel#21): the tables are opened here, in the app's process only.
35. import { MPackDB } from 'hl:mpackdb'
36. import { env } from 'hl:proc'
37. import { now } from 'hl:time'
38. import { storageDir, newId, todayStr, dateOr, firstOf } from './util.hl'
39. import { showById, seasonsOfShow, episodesOfSeason, titleWithYear, posterUrlOf, isPublicTitle, titlePath } from './shows.hl'
40. import { userOfSession } from './users.hl'
41. import { dbSearch } from './search.hl'
42. import { slugBaseOf } from './search-helpers.hl'
44. static franchisesTable = new MPackDB(file = storageDir + '/franchises.db', primaryKey = '@id', indexes = ['!slug'])
45. static timelinesTable = new MPackDB(file = storageDir + '/timelines.db', primaryKey = '@id', indexes = ['!slug'])
47. // a name as typed: trimmed, null when there is none (the editor's names and summaries)
48. static trimmedOr = (&v) => { return v != null && hlTypeName(v) == 'String' && v.trim() != '' ? v.trim() : null }
50. // ---- who may edit: the creator (ident short id az5b2); TRACKER_EDITORS = a comma list of ident ids (the gate sets its own) ----
51. static editorIds = () => {
52. v = env('TRACKER_EDITORS')
53. raw = v != null && v.trim() != '' ? v : 'az5b2'
54. out = []
55. for (p of raw.split(',')) { if (p.trim() != '') { out.push(p.trim()) } }
56. return out
57. }
58. static editors = editorIds()
59. static isEditorSession = (&session) => {
60. if (session == null || hlTypeName(session) != 'Instance') { return false }
61. u = userOfSession(session)
62. return u != null && u.identity != null && editors.includes(u.identity)
63. }
65. // a list's index of x, -1 when it is not in it (hand-written: list helpers beyond includes/push are not trusted, hybriel#1)
66. static posOf = (&list, &x) => {
67. let i = 0
68. while (i < list.length) {
69. if (list[i] == x) { return i }
70. i = i + 1
71. }
72. return -1
73. }
75. // ---- slugs: "Star Trek" → "Star-Trek" (the shows' urlSegment form, search-helpers.hl slugBaseOf; none → 'timeline') -------
76. static freeSlug = (&table, &name) => {
77. base = slugBaseOf(name, 'timeline')
78. // 'edit' is the editor's own address (/franchises/edit)
79. if (firstOf(table.find('slug', base)) == null && base != 'edit') { return base }
80. let n = 2
81. while (firstOf(table.find('slug', base + '-' + n)) != null) { n = n + 1 }
82. return base + '-' + n
83. }
85. static franchiseBySlug = (&slug) => {
86. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
87. return firstOf(franchisesTable.find('slug', slug))
88. }
89. static timelineBySlug = (&slug) => {
90. if (slug == null || hlTypeName(slug) != 'String' || slug == '') { return null }
91. return firstOf(timelinesTable.find('slug', slug))
92. }
93. static franchiseById = (&id) => { return id == null || hlTypeName(id) != 'String' || id == '' ? null : franchisesTable.fetch(id) }
94. static timelineById = (&id) => { return id == null || hlTypeName(id) != 'String' || id == '' ? null : timelinesTable.fetch(id) }
96. // ---- byShow: show @id → [timeline @id] ------------------------------------------------------------------------------------
97. static byShow = {}
98. static state = { built = false timelines = 0 ms = 0 }
99. static indexAdd = (&showId, &timelineId) => {
100. let l = byShow[showId]
101. if (l == null) { l = [] }
102. if (!l.includes(timelineId)) { l.push(timelineId) }
103. byShow[showId] = l
104. return true
105. }
106. static indexRemove = (&showId, &timelineId) => {
107. l = byShow[showId]
108. if (l == null) { return true }
109. out = []
110. for (x of l) { if (x != timelineId) { out.push(x) } }
111. byShow[showId] = out
112. return true
113. }
114. static ensureFranchises = () => {
115. if (state.built) { return true }
116. state.built = true
117. t0 = now()
118. let n = 0
119. for (t of timelinesTable.find(null, null)) {
120. n = n + 1
121. if (t.order != null) { for (sid of t.order) { indexAdd(sid, t.id) } }
122. }
123. state.timelines = n
124. state.ms = now() - t0
125. console.log('franchises: ' + n + ' timelines, ' + franchisesTable.count() + ' franchises (' + state.ms + ' ms)')
126. return true
127. }
128. static timelineIdsOfShow = (&showId) => {
129. ensureFranchises()
130. l = byShow[showId]
131. return l != null ? l : []
132. }
134. // ---- a title as the pages list it ------------------------------------------------------------------------------------------
135. // the date the release sort uses: a movie's release; a series' LAST episode (newest out ≤ today, else newest announced, else
136. // its own release)
137. static releaseKeyOf = (&show) => {
138. if (show.type != 'series') { return dateOr(show.release) }
139. today = todayStr()
140. let lastOut = ''
141. let lastAny = ''
142. for (s of seasonsOfShow(show)) {
143. for (e of episodesOfSeason(s)) {
144. let d = dateOr(e.release)
145. if (d != '') {
146. if (d > lastAny) { lastAny = d }
147. if (d <= today && d > lastOut) { lastOut = d }
148. }
149. }
150. }
151. if (lastOut != '') { return lastOut }
152. if (lastAny != '') { return lastAny }
153. return dateOr(show.release)
154. }
155. static itemOf = (&show, pos) => {
156. series = show.type == 'series'
157. d = releaseKeyOf(show)
158. label = d == '' ? 'no date' : (series ? 'last episode ' + d : d)
159. return { id = show.id pos = pos title = titleWithYear(show) href = titlePath(show) posterUrl = posterUrlOf(show)
160. kind = series ? 'Series' : 'Movie' date = d dateLabel = label }
161. }
162. // the public titles of a timeline, in its order (`pos` = the place in the in-world order, 1-based)
163. static itemsOf = (&t) => {
164. out = []
165. let pos = 0
166. if (t.order == null) { return out }
167. for (sid of t.order) {
168. let s = showById(sid)
169. if (s != null && isPublicTitle(s)) {
170. pos = pos + 1
171. out.push(itemOf(s, pos))
172. }
173. }
174. return out
175. }
176. // release order: oldest first, no date last; equal dates keep the timeline order (a stable insertion)
177. static byReleaseOf = (&items) => {
178. let out = []
179. for (it of items) {
180. let next = []
181. let done = false
182. for (x of out) {
183. if (!done && it.date != '' && (x.date == '' || it.date < x.date)) { next.push(it) done = true }
184. next.push(x)
185. }
186. if (!done) { next.push(it) }
187. out = next
188. }
189. return out
190. }
191. // tracker#40: what the timeline's own order is, said beside its count ("23 titles · in-universe order"); none when not known
192. static orderNoteOf = (&t) => {
193. if (t.orderKind == 'in-universe') { return ' · in-universe order' }
194. if (t.orderKind == 'release') { return ' · release order' }
195. return ''
196. }
197. static blockOf = (&t) => {
198. items = itemsOf(t)
199. return { id = t.id name = t.name slug = t.slug href = '/timelines/' + t.slug items = items byRelease = byReleaseOf(items)
200. countText = (items.length == 1 ? '1 title' : items.length + ' titles') + orderNoteOf(t) first = items.length > 0 ? byReleaseOf(items)[0].date : '' }
201. }
203. // ---- the pages -------------------------------------------------------------------------------------------------------------
204. // /franchises: every franchise (name, how many timelines), then the timelines WITHOUT one (TMDB's collections, by name)
205. static byNameOf = (&rows) => {
206. let out = []
207. for (r of rows) {
208. let next = []
209. let done = false
210. let k = r.sortName
211. for (x of out) {
212. if (!done && k < x.sortName) { next.push(r) done = true }
213. next.push(x)
214. }
215. if (!done) { next.push(r) }
216. out = next
217. }
218. return out
219. }
220. static franchiseIndex = () => {
221. counts = {}
222. loose = []
223. for (t of timelinesTable.find(null, null)) {
224. let n = t.order != null ? t.order.length : 0
225. // tracker#40: a superseded collection timeline is not listed (nor counted for its franchise)
226. if (t.supersededBy != null) { n = 0 }
227. else if (t.franchise != null && t.franchise != '') { counts[t.franchise] = (counts[t.franchise] != null ? counts[t.franchise] : 0) + 1 }
228. else if (n > 0) { loose.push({ id = t.id name = t.name href = '/timelines/' + t.slug countText = n == 1 ? '1 title' : n + ' titles' sortName = ('' + t.name).toLowerCase() }) }
229. }
230. fr = []
231. for (f of franchisesTable.find(null, null)) {
232. let c = counts[f.id] != null ? counts[f.id] : 0
233. fr.push({ id = f.id name = f.name href = '/franchises/' + f.slug summary = f.summary != null ? f.summary : ''
234. countText = c == 1 ? '1 timeline' : c + ' timelines' sortName = ('' + f.name).toLowerCase() })
235. }
236. return { franchises = byNameOf(fr) timelines = byNameOf(loose) }
237. }
239. // /franchises/<slug>: the franchise and its timelines (oldest first by their first release) — or null
240. static franchisePage = (slug) => {
241. f = franchiseBySlug(slug)
242. if (f == null) { return null }
243. let blocks = []
244. for (t of timelinesTable.find(null, null)) {
245. if (t.franchise == f.id && t.supersededBy == null) {
246. let b = blockOf(t)
247. let next = []
248. let done = false
249. for (x of blocks) {
250. if (!done && b.first != '' && (x.first == '' || b.first < x.first)) { next.push(b) done = true }
251. next.push(x)
252. }
253. if (!done) { next.push(b) }
254. blocks = next
255. }
256. }
257. return { kind = 'franchise' name = f.name slug = f.slug summary = f.summary != null ? f.summary : '' franchiseName = '' franchiseHref = '' blocks = blocks editHref = '' }
258. }
259. // /timelines/<slug>: one timeline, its franchise above it — or null
260. static timelinePage = (slug) => {
261. t = timelineBySlug(slug)
262. if (t == null) { return null }
263. f = franchiseById(t.franchise)
264. return { kind = 'timeline' name = t.name slug = t.slug summary = '' franchiseName = f != null ? f.name : '' franchiseHref = f != null ? '/franchises/' + f.slug : ''
265. blocks = [blockOf(t)] editHref = '/timelines/' + t.slug + '/edit' }
266. }
268. // ---- the widget on a show / movie page: one per timeline the title is in ----------------------------------------------------
269. // { id, name, href, hasFranchise, franchiseName, franchiseHref, hasPrev, noPrev, prevHref, prevTitle, hasNext, noNext, … }:
270. // prequel / sequel = the nearest PUBLIC title before / after this one in the timeline's order
271. static widgetsOf = (&showId) => {
272. out = []
273. if (showId == null) { return out }
274. for (tid of timelineIdsOfShow(showId)) {
275. let t = timelinesTable.fetch(tid)
276. if (t != null && t.supersededBy == null && t.order != null && t.order.includes(showId)) {
277. let at = posOf(t.order, showId)
278. let prev = null
279. let i = at - 1
280. while (prev == null && i >= 0) {
281. let s = showById(t.order[i])
282. if (s != null && isPublicTitle(s)) { prev = s }
283. i = i - 1
284. }
285. let next = null
286. let j = at + 1
287. while (next == null && j < t.order.length) {
288. let s = showById(t.order[j])
289. if (s != null && isPublicTitle(s)) { next = s }
290. j = j + 1
291. }
292. let f = franchiseById(t.franchise)
293. out.push({ id = t.id name = t.name href = '/timelines/' + t.slug
294. hasFranchise = f != null franchiseName = f != null ? f.name : '' franchiseHref = f != null ? '/franchises/' + f.slug : ''
295. hasPrev = prev != null noPrev = prev == null prevHref = prev != null ? titlePath(prev) : '' prevTitle = prev != null ? titleWithYear(prev) : ''
296. hasNext = next != null noNext = next == null nextHref = next != null ? titlePath(next) : '' nextTitle = next != null ? titleWithYear(next) : '' })
297. }
298. }
299. return out
300. }
302. // ---- the editor (the creator only — every caller checks isEditorSession first) ----------------------------------------------
303. static createFranchise = (name, summary) => {
304. n = trimmedOr(name)
305. if (n == null || n.length > 120) { return { error = 'a franchise needs a name (at most 120 characters)' } }
306. s = trimmedOr(summary)
307. rec = { id = newId() name = n slug = freeSlug(franchisesTable, n) shortId = null summary = s != null ? s : '' created = now() }
308. if (franchisesTable.put(rec) == null) { return { error = 'not stored: ' + franchisesTable.lastError() } }
309. franchisesTable.persist()
310. console.log('franchises: new franchise "' + n + '" /franchises/' + rec.slug)
311. return { ok = true slug = rec.slug id = rec.id }
312. }
314. // a new timeline (the editor's, the collection seed's with its collection id, the curated seed's with its order kind)
315. static putTimeline = (name, &franchiseId, order, source, &collection, &orderKind) => {
316. rec = { id = newId() name = name slug = freeSlug(timelinesTable, name) franchise = franchiseId order = order source = source
317. tmdbCollection = collection orderKind = orderKind created = now() }
318. if (timelinesTable.put(rec) == null) { return null }
319. for (sid of order) { indexAdd(sid, rec.id) }
320. return rec
321. }
322. static createTimeline = (&name) => {
323. n = trimmedOr(name)
324. if (n == null || n.length > 120) { return { error = 'a timeline needs a name (at most 120 characters)' } }
325. rec = putTimeline(n, null, [], 'editor', null, null)
326. if (rec == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
327. timelinesTable.persist()
328. console.log('franchises: new timeline "' + n + '" /timelines/' + rec.slug)
329. return { ok = true slug = rec.slug id = rec.id }
330. }
332. // the editor's view of one timeline: every title in its order (adult ones too — the creator sees what is there)
333. static editRowsOf = (&t) => {
334. out = []
335. if (t == null || t.order == null) { return out }
336. let i = 0
337. last = t.order.length - 1
338. for (sid of t.order) {
339. let s = showById(sid)
340. if (s != null) {
341. out.push({ id = s.id pos = i + 1 title = titleWithYear(s) posterUrl = posterUrlOf(s) typeLabel = s.type == 'series' ? 'Series' : 'Movie'
342. upClass = i == 0 ? 'quiet mv off' : 'quiet mv' downClass = i == last ? 'quiet mv off' : 'quiet mv' })
343. }
344. i = i + 1
345. }
346. return out
347. }
348. static chipsOf = (&t) => {
349. out = [{ id = '' name = 'None' cls = t == null || t.franchise == null || t.franchise == '' ? 'chip on' : 'chip' }]
350. list = []
351. for (f of franchisesTable.find(null, null)) { list.push({ id = f.id name = f.name cls = t != null && t.franchise == f.id ? 'chip on' : 'chip' sortName = ('' + f.name).toLowerCase() }) }
352. for (c of byNameOf(list)) { out.push(c) }
353. return out
354. }
355. static editPageOf = (slug) => {
356. t = timelineBySlug(slug)
357. if (t == null) { return { found = false id = '' name = '' slug = '' viewHref = '' rows = [] chips = [] } }
358. return { found = true id = t.id name = t.name slug = t.slug viewHref = '/timelines/' + t.slug rows = editRowsOf(t) chips = chipsOf(t) }
359. }
361. static storeOrder = (t, order) => {
362. old = t.order != null ? t.order : []
363. rec = t
364. rec.order = order
365. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
366. timelinesTable.persist()
367. for (sid of old) { if (!order.includes(sid)) { indexRemove(sid, rec.id) } }
368. for (sid of order) { indexAdd(sid, rec.id) }
369. return { ok = true rows = editRowsOf(rec) }
370. }
371. // tracker#31 (merge.hl): a duplicate title merged into its keeper — in every timeline that lists it, the keeper takes its place
372. // (once: a timeline that already lists the keeper just drops it) → the number of timelines changed
373. static titleMerged = (&fromId, &toId) => {
374. ensureFranchises()
375. let n = 0
376. tids = []
377. if (byShow[fromId] != null) { for (x of byShow[fromId]) { tids.push(x) } }
378. for (tid of tids) {
379. let t = timelinesTable.fetch(tid)
380. if (t != null && t.order != null) {
381. let order = []
382. for (sid of t.order) {
383. let want = sid == fromId ? toId : sid
384. if (!order.includes(want)) { order.push(want) }
385. }
386. let r = storeOrder(t, order)
387. if (r.error != null) { console.log('merge: timeline ' + tid + ': ' + r.error) } else { n = n + 1 }
388. }
389. }
390. return n
391. }
392. static addToTimeline = (&timelineId, &showId) => {
393. t = timelineById(timelineId)
394. if (t == null) { return { error = 'no such timeline' } }
395. if (showById(showId) == null) { return { error = 'no such title' } }
396. order = []
397. for (sid of t.order) { order.push(sid) }
398. if (order.includes(showId)) { return { ok = true rows = editRowsOf(t) } }
399. order.push(showId)
400. return storeOrder(t, order)
401. }
402. static removeFromTimeline = (&timelineId, &showId) => {
403. t = timelineById(timelineId)
404. if (t == null) { return { error = 'no such timeline' } }
405. order = []
406. for (sid of t.order) { if (sid != showId) { order.push(sid) } }
407. return storeOrder(t, order)
408. }
409. // one place up (delta -1) or down (+1); at an end nothing changes
410. static moveInTimeline = (&timelineId, &showId, &delta) => {
411. t = timelineById(timelineId)
412. if (t == null) { return { error = 'no such timeline' } }
413. at = posOf(t.order, showId)
414. to = at + (delta < 0 ? -1 : 1)
415. if (at < 0 || to < 0 || to >= t.order.length) { return { ok = true rows = editRowsOf(t) } }
416. order = []
417. let i = 0
418. while (i < t.order.length) {
419. if (i == at) { order.push(t.order[to]) } else if (i == to) { order.push(t.order[at]) } else { order.push(t.order[i]) }
420. i = i + 1
421. }
422. return storeOrder(t, order)
423. }
424. static setTimelineFranchise = (&timelineId, franchiseId) => {
425. t = timelineById(timelineId)
426. if (t == null) { return { error = 'no such timeline' } }
427. let fid = null
428. if (franchiseId != null && franchiseId != '') {
429. if (franchiseById(franchiseId) == null) { return { error = 'no such franchise' } }
430. fid = franchiseId
431. }
432. rec = t
433. rec.franchise = fid
434. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
435. timelinesTable.persist()
436. return { ok = true chips = chipsOf(rec) }
437. }
438. // the editor's title search: our database (search.hl's index), the titles not in the timeline yet
439. static editSearch = (&timelineId, text) => {
440. t = timelineById(timelineId)
441. have = t != null && t.order != null ? t.order : []
442. out = []
443. r = dbSearch(text != null ? '' + text : '')
444. for (x of r.titles) {
445. let s = showById(x.id)
446. if (s != null && !have.includes(s.id)) { out.push({ id = s.id title = titleWithYear(s) posterUrl = posterUrlOf(s) typeLabel = s.type == 'series' ? 'Series' : 'Movie' }) }
447. }
448. return { text = text rows = out note = r.tooShort ? 'Type at least 2 letters.' : (out.length == 0 ? 'Nothing found.' : '') }
449. }
450. // the editor's timeline finder: by name, at most 30
451. static findTimelines = (&text) => {
452. q = text != null ? ('' + text).trim().toLowerCase() : ''
453. out = []
454. if (q.length < 2) { return out }
455. for (t of timelinesTable.find(null, null)) {
456. if (out.length < 30 && ('' + t.name).toLowerCase().includes(q)) {
457. let n = t.order != null ? t.order.length : 0
458. let hidden = t.supersededBy != null ? ' · hidden: all in ' + nameOfTimeline(t.supersededBy) : ''
459. out.push({ id = t.id name = t.name href = '/timelines/' + t.slug + '/edit' countText = (n == 1 ? '1 title' : n + ' titles') + hidden })
460. }
461. }
462. return out
463. }
465. // ---- the curated seed's reads and writes (franchiseseed.hl, tracker#40) ----------------------------------------------------
466. // a franchise / timeline by its name, any case — or null (the creator's own of that name is adopted by the seed, never doubled)
467. static franchiseByName = (&name) => {
468. q = ('' + name).toLowerCase()
469. let hit = null
470. for (f of franchisesTable.find(null, null)) { if (hit == null && ('' + f.name).toLowerCase() == q) { hit = f } }
471. return hit
472. }
473. static timelineByName = (&name) => {
474. q = ('' + name).toLowerCase()
475. let hit = null
476. for (t of timelinesTable.find(null, null)) { if (hit == null && ('' + t.name).toLowerCase() == q) { hit = t } }
477. return hit
478. }
479. // the timeline the collection seed made from TMDB collection `collection`, or null
480. static timelineOfCollection = (&collection) => {
481. let hit = null
482. for (t of timelinesTable.find(null, null)) { if (hit == null && t.tmdbCollection != null && '' + t.tmdbCollection == '' + collection) { hit = t } }
483. return hit
484. }
485. // a seeded timeline rewritten (the data file changed, or titles were imported since): its order and franchise in one update
486. static storeSeeded = (t, order, &franchiseId) => {
487. old = t.order != null ? t.order : []
488. rec = t
489. rec.order = order
490. rec.franchise = franchiseId
491. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
492. for (sid of old) { if (!order.includes(sid)) { indexRemove(sid, rec.id) } }
493. for (sid of order) { indexAdd(sid, rec.id) }
494. return { ok = true }
495. }
496. static persistFranchises = () => {
497. franchisesTable.persist()
498. timelinesTable.persist()
499. return true
500. }
502. // ---- superseded collection timelines (tracker#40) --------------------------------------------------------------------------------
503. static nameOfTimeline = (&id) => {
504. t = timelineById(id)
505. return t != null ? t.name : '?'
506. }
507. // for a collection's titles: `cover` = the curated (seed) timeline holding ALL of them, or null; `franchise` = the cover's
508. // franchise, else the franchise of a curated timeline holding at least ONE of them (a partly covered collection joins it), or null
509. static seededCoverOf = (&order) => {
510. let whole = null
511. let part = null
512. for (t of timelinesTable.find(null, null)) {
513. if (t.source == 'seed' && t.order != null) {
514. let all = order.length > 0
515. let any = false
516. for (sid of order) { if (t.order.includes(sid)) { any = true } else { all = false } }
517. if (all && whole == null) { whole = t }
518. if (any && part == null && t.franchise != null && t.franchise != '') { part = t.franchise }
519. }
520. }
521. // (locals not named like the answer's entries: inside a record literal an entry shadows that name for the entries after it)
522. return { cover = whole != null ? whole.id : null franchise = whole != null && whole.franchise != null ? whole.franchise : part }
523. }
524. // hidden behind `byId` (null: shown again)
525. static setSuperseded = (t, &byId) => {
526. rec = t
527. rec.supersededBy = byId
528. if (timelinesTable.update(rec.id, rec) == null) { return { error = 'not stored: ' + timelinesTable.lastError() } }
529. return { ok = true }
530. }