BlueGit

timfa hfy-novels

Files

hfy-novels / plugin / hfy-novels.js

hfy-novels.js

hfy-novels.js 53.2 KiB Download Raw
1"use strict";
2
3/**
4 * LNReader-plugin voor r/HFY.
5 *
6 * De catalogus wordt live opgebouwd op de telefoon, met de Reddit-sessie
7 * uit de LNReader-WebView (elk account heeft zijn eigen cookies):
8 * - popularNovels: de wiki-serie-index, plus 'Nieuw' / Latest met recente OC-posts
9 * - searchNovels: r/HFY/search.json (restrict_sr=1), plus hits uit de wiki,
10 * waarbij series en losse Part-1-posts tot één novel worden gegroepeerd
11 * - parseNovel: wiki-inhoudsopgave, anders next-links met titelgelijkenis
12 *
13 * Covers zijn drie vaste PNGs in .dist/covers/ (gewone https-URL, geen
14 * data-URI, geen titelgeneratie op het toestel): r/HFY-logo in het midden
15 * en rechtsonder een bronbadge. De badge volgt de bron die de data
16 * leverde: reddit.png, arctic-shift.png, of index.png (statische index).
17 * Bij twijfel gebruiken we de Reddit-cover.
18 *
19 * Bij een fout, 403 of login-/blokpagina valt alles terug op Arctic Shift,
20 * en daarna op de statische metadata-index (ook bruikbaar zonder login).
21 * parseChapter probeert eerst Reddit-JSON, daarna Arctic Shift.
22 *
23 * Dit bestand is CommonJS, zoals de officiële gecompileerde plugins:
24 * require(...) uit de LNReader-allowlist, en `exports.default = instance`.
25 */
26
27Object.defineProperty(exports, "__esModule", { value: true });
28
29const { fetchApi } = require("@libs/fetch");
30const { FilterTypes } = require("@libs/filterInputs");
31const { defaultCover } = require("@libs/defaultCover");
32const { NovelStatus } = require("@libs/novelStatus");
33const { storage } = require("@libs/storage");
34
35const DEFAULT_INDEX_BASE =
36 "https://git.timfalken.com/timfa/hfy-novels/-/raw/public";
37const RAW_PLUGIN_BASE = "https://git.timfalken.com/timfa/hfy-novels/-/raw";
38const LIVE_COVER_REDDIT = RAW_PLUGIN_BASE + "/.dist/covers/reddit.png?rev=master";
39const LIVE_COVER_ARCTIC = RAW_PLUGIN_BASE + "/.dist/covers/arctic-shift.png?rev=master";
40const LIVE_COVER_INDEX = RAW_PLUGIN_BASE + "/.dist/covers/index.png?rev=master";
41const DEFAULT_INDEX_REV = "master";
42const DEFAULT_CHAPTER_SOURCE = "https://arctic-shift.photon-reddit.com";
43const PAGE_FALLBACK_SIZE = 50;
44// v2: ongeldig verklaart caches uit 0.3.2/0.3.3 die een Arctic-fallback
45// zes uur vasthielden terwijl hoofdstukken intussen via Reddit werkten.
46const WIKI_CACHE_KEY = "wikiSeriesIndex.v2";
47const WIKI_CACHE_MS_REDDIT = 6 * 60 * 60 * 1000;
48const WIKI_CACHE_MS_ARCTIC = 5 * 60 * 1000;
49const REDDIT_WWW = "https://www.reddit.com";
50const REDDIT_OLD = "https://old.reddit.com";
51const WIKI_INDEX_PATH = "/r/HFY/wiki/series";
52
53function setting(key, fallback) {
54 try {
55 const value = storage.get(key);
56 if (value === undefined || value === null || value === "") {
57 return fallback;
58 }
59 return value;
60 } catch (err) {
61 return fallback;
62 }
63}
64
65function joinUrl(base, path, query) {
66 const trimmedBase = String(base || "").replace(/\/+$/, "");
67 const trimmedPath = String(path || "").replace(/^\/+/, "");
68 let url = trimmedBase + "/" + trimmedPath;
69 const params = [];
70 if (query && typeof query === "object") {
71 for (const [k, v] of Object.entries(query)) {
72 if (v !== undefined && v !== null && v !== "") {
73 params.push(encodeURIComponent(k) + "=" + encodeURIComponent(String(v)));
74 }
75 }
76 }
77 if (params.length) {
78 url += (url.includes("?") ? "&" : "?") + params.join("&");
79 }
80 return url;
81}
82
83function statusFrom(text) {
84 switch (text) {
85 case "Completed":
86 return NovelStatus.Completed;
87 case "Ongoing":
88 return NovelStatus.Ongoing;
89 case "On Hiatus":
90 return NovelStatus.OnHiatus;
91 default:
92 return NovelStatus.Unknown;
93 }
94}
95
96async function readJson(url, label) {
97 const res = await fetchApi(url);
98 if (!res || res.ok === false) {
99 const status = res && res.status != null ? res.status : "?";
100 throw new Error("HFY Novels: kon " + label + " niet laden (HTTP " + status + ")");
101 }
102 if (typeof res.json === "function") {
103 return await res.json();
104 }
105 const text = await res.text();
106 return JSON.parse(text);
107}
108
109function toNovelItem(entry, plugin) {
110 return {
111 name: entry.name,
112 path: entry.path,
113 cover: plugin.coverFor(entry),
114 };
115}
116
117function coverSourceOf(postSource, wikiSource) {
118 if (postSource === "reddit" || wikiSource === "reddit") {
119 return "reddit";
120 }
121 if (postSource === "arctic" || wikiSource === "arctic") {
122 return "arctic";
123 }
124 return "reddit";
125}
126
127class HFYNovelsPlugin {
128 constructor() {
129 this.id = "hfyNovels";
130 this.name = "HFY Novels";
131 this.version = "0.3.4";
132 this.site = "https://www.reddit.com/r/HFY/";
133 this.icon = "icon.png";
134 // Geen webStorageUtilized: Reddit-login zit in cookies. LNReader's
135 // fetchApi (native fetch) stuurt de WebView-cookies automatisch mee
136 // voor hetzelfde domein; localStorage is daarvoor niet nodig.
137 this.filters = {
138 catalog: {
139 value: "wiki",
140 label: "Overzicht",
141 options: [
142 { label: "Wiki-series", value: "wiki" },
143 { label: "Nieuw", value: "new" },
144 ],
145 type: FilterTypes.Picker,
146 },
147 kind: {
148 value: "all",
149 label: "Type",
150 options: [
151 { label: "Alles", value: "all" },
152 { label: "Reeksen", value: "series" },
153 { label: "Oneshots", value: "oneshot" },
154 ],
155 type: FilterTypes.Picker,
156 },
157 nsfw: {
158 value: "hide",
159 label: "NSFW",
160 options: [
161 { label: "Verbergen", value: "hide" },
162 { label: "Tonen", value: "show" },
163 ],
164 type: FilterTypes.Picker,
165 },
166 };
167 this.pluginSettings = {
168 indexBaseUrl: {
169 value: DEFAULT_INDEX_BASE,
170 label: "Basis-URL van de statische index (laatste fallback)",
171 type: "Text",
172 },
173 indexRev: {
174 value: DEFAULT_INDEX_REV,
175 label: "Git-revisie van de index (rev=)",
176 type: "Text",
177 },
178 chapterSource: {
179 value: "auto",
180 label: "Bron voor catalogus en hoofdstukken",
181 type: "Select",
182 options: [
183 { label: "Automatisch (Reddit, anders Arctic Shift, anders index)", value: "auto" },
184 { label: "Alleen Reddit", value: "reddit" },
185 { label: "Alleen Arctic Shift (daarna index)", value: "arctic" },
186 ],
187 },
188 chapterSourceUrl: {
189 value: DEFAULT_CHAPTER_SOURCE,
190 label: "Arctic Shift-basis-URL (fallback)",
191 type: "Text",
192 },
193 };
194 }
195
196 indexQuery() {
197 const rev = setting("indexRev", DEFAULT_INDEX_REV);
198 return { rev: rev };
199 }
200
201 indexUrl(path) {
202 const base = setting("indexBaseUrl", DEFAULT_INDEX_BASE);
203 return joinUrl(base, path, this.indexQuery());
204 }
205
206 coverFor(entry) {
207 // Per-titelcovers uit de statische index worden niet meer gebruikt.
208 const source = entry && entry.source;
209 if (source === "arctic") {
210 return LIVE_COVER_ARCTIC;
211 }
212 if (source === "index") {
213 return LIVE_COVER_INDEX;
214 }
215 // reddit, of bij twijfel (ontbrekende/onbekende bron).
216 return LIVE_COVER_REDDIT;
217 }
218
219 coverUrl(cover) {
220 if (!cover) {
221 return defaultCover;
222 }
223 if (/^https?:\/\//i.test(cover)) {
224 return cover;
225 }
226 let url = this.indexUrl(cover);
227 // BlueGit serveert SVG pas als afbeelding met ?as=img.
228 if (/\.svg$/i.test(cover) && url.indexOf("as=img") === -1) {
229 url += (url.indexOf("?") === -1 ? "?" : "&") + "as=img";
230 }
231 return url;
232 }
233
234 chapterSource() {
235 return String(setting("chapterSourceUrl", DEFAULT_CHAPTER_SOURCE)).replace(/\/+$/, "");
236 }
237
238 chapterMode() {
239 const mode = String(setting("chapterSource", "auto") || "auto").toLowerCase();
240 if (mode === "reddit" || mode === "arctic") {
241 return mode;
242 }
243 return "auto";
244 }
245
246 /**
247 * Maakt "Open in WebView" op een reeks of hoofdstuk tot een Reddit-URL,
248 * zodat je daar kunt inloggen. Zonder deze functie zou LNReader
249 * site+path plakken (bijv. /r/HFY/series/id), wat geen geldige Reddit-pagina is.
250 * Het reeks-id is de oudste post (eerste deel), of een wiki-slug.
251 */
252 resolveUrl(path, isNovel) {
253 const raw = String(path || "").trim();
254 if (/^https?:\/\//i.test(raw)) {
255 return raw;
256 }
257 const wikiSlug = wikiSlugFromPath(raw);
258 if (wikiSlug) {
259 return REDDIT_WWW + "/r/HFY/wiki/series/" + wikiSlug + "/";
260 }
261 const id = chapterIdFromPath(raw) || chapterIdFromPath(raw.replace(/^series\//, "chapter/"));
262 if (id) {
263 return REDDIT_WWW + "/r/HFY/comments/" + id + "/";
264 }
265 return this.site;
266 }
267
268 matchesFilters(entry, filters) {
269 const kind = filters && filters.kind ? filters.kind.value : "all";
270 const nsfw = filters && filters.nsfw ? filters.nsfw.value : "hide";
271 if (kind === "oneshot" && !entry.oneshot) {
272 return false;
273 }
274 if (kind === "series" && entry.oneshot) {
275 return false;
276 }
277 if (nsfw === "hide" && entry.nsfw) {
278 return false;
279 }
280 return true;
281 }
282
283 async loadMeta() {
284 return await readJson(this.indexUrl("catalog-meta.json"), "catalogus-meta");
285 }
286
287 async popularNovels(pageNo, options) {
288 const opts = options || {};
289 const filters = opts.filters || {};
290 const showLatest = !!opts.showLatestNovels || (filters.catalog && filters.catalog.value === "new");
291 const page = Math.max(1, parseInt(pageNo, 10) || 1);
292 const mode = this.chapterMode();
293
294 if (showLatest) {
295 const live = await this.liveLatestNovels(page, filters, mode);
296 if (live && live.ok) {
297 return live.items;
298 }
299 if (mode === "reddit") {
300 throw new Error(
301 "HFY Novels: Reddit gaf geen nieuwe posts (" +
302 ((live && live.reason) || "onbekende fout") +
303 "). Log in via Open in WebView op reddit.com en probeer het opnieuw.",
304 );
305 }
306 return await this.staticPopular(page, opts);
307 }
308
309 const live = await this.liveWikiNovels(page, filters, mode);
310 if (live && live.ok) {
311 return live.items;
312 }
313 if (mode === "reddit") {
314 throw new Error(
315 "HFY Novels: Reddit gaf de wiki-index niet (" +
316 ((live && live.reason) || "onbekende fout") +
317 "). Log in via Open in WebView op reddit.com en probeer het opnieuw.",
318 );
319 }
320 return await this.staticPopular(page, opts);
321 }
322
323 async searchNovels(searchTerm, pageNo) {
324 const term = String(searchTerm || "").trim();
325 if (!term) {
326 return [];
327 }
328 const page = Math.max(1, parseInt(pageNo, 10) || 1);
329 const mode = this.chapterMode();
330 const live = await this.liveSearchNovels(term, page, mode);
331 if (live && live.ok) {
332 return live.items;
333 }
334 if (mode === "reddit") {
335 throw new Error(
336 "HFY Novels: Reddit-zoeken mislukte (" +
337 ((live && live.reason) || "onbekende fout") +
338 "). Log in via Open in WebView op reddit.com en probeer het opnieuw.",
339 );
340 }
341 return await this.staticSearch(term, page);
342 }
343
344 seriesFileFor(novelPath) {
345 const id = String(novelPath || "")
346 .replace(/^series\//, "")
347 .replace(/\/+$/, "");
348 if (!id) {
349 throw new Error("HFY Novels: leeg reeks-pad");
350 }
351 const prefix = id.charAt(0).toLowerCase() || "x";
352 return "series/" + prefix + "/" + id + ".json";
353 }
354
355 async parseNovel(novelPath) {
356 const mode = this.chapterMode();
357 let live;
358 try {
359 live = await this.liveParseNovel(novelPath, mode);
360 } catch (err) {
361 // Een throw (bijv. ontbrekende posts-array bij een 502) mag de
362 // statische fallback niet blokkeren en niet als "unable to load novel"
363 // eindigen als de index het verhaal wel kent.
364 live = { ok: false, reason: err && err.message ? err.message : String(err) };
365 }
366 if (mode === "reddit" && (!live || !live.ok)) {
367 throw new Error(
368 "HFY Novels: Reddit gaf de hoofdstuklijst niet (" +
369 ((live && live.reason) || "onbekende fout") +
370 "). Log in via Open in WebView op reddit.com en probeer het opnieuw.",
371 );
372 }
373 let novel = live && live.ok ? live.novel : null;
374 const finish = (item) => {
375 if (!item) {
376 return item;
377 }
378 // LNReader verwacht dat SourceNovel.path gelijk is aan het aangevraagde pad.
379 item.path = novelPath;
380 return item;
381 };
382 if (!wikiSlugFromPath(novelPath)) {
383 try {
384 const fallback = await this.staticParseNovel(novelPath);
385 if (!novel) {
386 return finish(fallback);
387 }
388 // De statische index kan een langere inhoudsopgave hebben dan een
389 // enkele live-post zonder werkende next-link; neem dan die lijst.
390 if ((fallback.chapters || []).length > (novel.chapters || []).length) {
391 novel.chapters = fallback.chapters;
392 if (!novel.summary && fallback.summary) {
393 novel.summary = fallback.summary;
394 }
395 }
396 // Statische indexcovers overschrijven een live broncover, zodat een
397 // bibliotheek-refresh een eerdere data-URI of logo kan vervangen.
398 // Live data houdt de live-broncover (reddit/arctic). De indexcover
399 // geldt alleen als de reeks uitsluitend uit de statische index komt.
400 return finish(novel);
401 } catch (err) {
402 if (novel) {
403 return finish(novel);
404 }
405 throw err;
406 }
407 }
408 if (novel) {
409 return finish(novel);
410 }
411 throw new Error(
412 "HFY Novels: kon de reeks " +
413 novelPath +
414 " niet live bepalen (" +
415 ((live && live.reason) || "geen bron") +
416 ").",
417 );
418 }
419
420 async parseChapter(chapterPath) {
421 const id = chapterIdFromPath(chapterPath);
422 if (!id) {
423 throw new Error("HFY Novels: ongeldig hoofdstuk-id");
424 }
425 const mode = this.chapterMode();
426 let redditError = "";
427 if (mode !== "arctic") {
428 const reddit = await tryRedditChapter(id);
429 if (reddit.ok) {
430 return renderChapter(reddit.post, "Reddit");
431 }
432 redditError = reddit.reason || "onbekende fout";
433 if (mode === "reddit") {
434 throw new Error(
435 "HFY Novels: Reddit gaf geen hoofdstuk (" +
436 redditError +
437 "). Log in via Open in WebView op reddit.com en probeer het opnieuw.",
438 );
439 }
440 }
441 const arctic = await tryArcticChapter(this.chapterSource(), id);
442 if (arctic.ok) {
443 const suffix = mode === "arctic" ? "Arctic Shift" : "Arctic Shift (fallback)";
444 return renderChapter(arctic.post, suffix);
445 }
446 if (redditError) {
447 throw new Error(
448 "HFY Novels: Reddit (" +
449 redditError +
450 ") en Arctic Shift (" +
451 (arctic.reason || "geen tekst") +
452 ") faalden allebei.",
453 );
454 }
455 throw new Error("HFY Novels: kon hoofdstuk " + id + " niet laden (" + (arctic.reason || "geen tekst") + ")");
456 }
457
458 async staticPopular(pageNo, options) {
459 const opts = options || {};
460 const filters = opts.filters || {};
461 const showLatest = !!opts.showLatestNovels || (filters.catalog && filters.catalog.value === "new");
462 const page = Math.max(1, parseInt(pageNo, 10) || 1);
463 const usePagedCatalog =
464 !showLatest &&
465 (!filters.kind || filters.kind.value === "all") &&
466 (!filters.nsfw || filters.nsfw.value === "hide");
467
468 if (usePagedCatalog) {
469 const meta = await this.loadMeta();
470 const pages = meta.pages || [];
471 const spec = pages[page - 1];
472 if (!spec) {
473 return [];
474 }
475 const payload = await readJson(this.indexUrl(spec.path), "cataloguspagina " + page);
476 const novels = (payload.novels || []).filter((n) => !n.nsfw);
477 return novels.map((n) => toNovelItem(Object.assign({}, n, { source: "index" }), this));
478 }
479
480 const search = await readJson(this.indexUrl("search-index.json"), "zoekindex");
481 const items = (search.novels || []).filter((n) => this.matchesFilters(n, filters));
482 const size = (await this.loadMeta()).pageSize || PAGE_FALLBACK_SIZE;
483 const start = (page - 1) * size;
484 return items.slice(start, start + size).map((n) => toNovelItem(Object.assign({}, n, { source: "index" }), this));
485 }
486
487 async staticSearch(searchTerm, pageNo) {
488 const term = String(searchTerm || "").trim().toLowerCase();
489 if (!term) {
490 return [];
491 }
492 const page = Math.max(1, parseInt(pageNo, 10) || 1);
493 const search = await readJson(this.indexUrl("search-index.json"), "zoekindex");
494 const hits = (search.novels || []).filter((n) => {
495 const name = String(n.name || "").toLowerCase();
496 const author = String(n.author || "").toLowerCase();
497 return name.includes(term) || author.includes(term);
498 });
499 const start = (page - 1) * PAGE_FALLBACK_SIZE;
500 return hits.slice(start, start + PAGE_FALLBACK_SIZE).map((n) => toNovelItem(Object.assign({}, n, { source: "index" }), this));
501 }
502
503 async staticParseNovel(novelPath) {
504 const data = await readJson(this.indexUrl(this.seriesFileFor(novelPath)), "reeks " + novelPath);
505 return {
506 path: data.path || novelPath,
507 name: data.name || "Untitled",
508 author: data.author || "Anonymous",
509 artist: undefined,
510 cover: this.coverFor({ name: data.name, source: "index" }),
511 genres: data.genres || "HFY",
512 status: statusFrom(data.status),
513 summary: data.summary || "",
514 chapters: (data.chapterList || []).map((ch) => ({
515 name: ch.name,
516 path: ch.path,
517 releaseTime: ch.releaseTime || null,
518 chapterNumber: ch.chapterNumber,
519 })),
520 };
521 }
522
523 async liveWikiNovels(page, filters, mode) {
524 const fetched = await this.loadWikiIndex(mode);
525 if (!fetched.ok) {
526 return fetched;
527 }
528 let items = fetched.entries.map((entry) => wikiEntryToItem(entry, this, fetched.source));
529 items = items.filter((entry) => this.matchesFilters(entry, filters));
530 const start = (page - 1) * PAGE_FALLBACK_SIZE;
531 return { ok: true, items: items.slice(start, start + PAGE_FALLBACK_SIZE), source: fetched.source };
532 }
533
534 async liveLatestNovels(page, filters, mode) {
535 const fetched = await this.loadRecentOcPosts(page, mode);
536 if (!fetched.ok) {
537 return fetched;
538 }
539 const grouped = groupPostsIntoNovels(fetched.posts || [], fetched.wikiEntries || []);
540 const items = grouped
541 .filter((entry) => this.matchesFilters(entry, filters))
542 .map((entry) => toNovelItem(Object.assign({}, entry, { source: fetched.source }), this));
543 return { ok: true, items: items, source: fetched.source };
544 }
545
546 async liveSearchNovels(term, page, mode) {
547 const wiki = await this.loadWikiIndex(mode === "reddit" ? "reddit" : "auto");
548 const wikiHits = (wiki.ok ? wiki.entries : []).filter((entry) => wikiEntryMatches(entry, term));
549 const postsRes = await this.loadSearchPosts(term, page, mode);
550 if (!postsRes.ok && !wiki.ok) {
551 return postsRes.ok === false ? postsRes : wiki;
552 }
553 const grouped = groupPostsIntoNovels(postsRes.ok ? postsRes.posts : [], wiki.ok ? wiki.entries : []);
554 const byKey = {};
555 const items = [];
556 function addItem(entry) {
557 const key = (entry.path || "") + "|" + normalizeTitle(entry.name);
558 if (byKey[key]) {
559 return;
560 }
561 byKey[key] = true;
562 items.push(toNovelItem(entry, this));
563 }
564 const add = addItem.bind(this);
565 wikiHits.forEach((entry) => add(wikiEntryToItem(entry, this, wiki.source)));
566 grouped.forEach((entry) => add(Object.assign({}, entry, { source: postsRes.ok ? postsRes.source : wiki.source })));
567 if (!items.length && !postsRes.ok) {
568 return { ok: false, reason: postsRes.reason || (wiki.ok ? "geen treffers" : wiki.reason) };
569 }
570 const start = (page - 1) * PAGE_FALLBACK_SIZE;
571 return { ok: true, items: items.slice(start, start + PAGE_FALLBACK_SIZE) };
572 }
573
574 async liveParseNovel(novelPath, mode) {
575 const wikiSlug = wikiSlugFromPath(novelPath);
576 const startId = chapterIdFromPath(novelPath) || chapterIdFromPath(String(novelPath).replace(/^series\//, "chapter/"));
577 let entry = null;
578 let reason = "";
579 let source = "";
580
581 if (wikiSlug) {
582 const page = await this.loadWikiPage(wikiSlug, mode);
583 if (page.ok) {
584 entry = page.entry;
585 source = page.source || source;
586 } else {
587 reason = page.reason || "wiki-subpagina ontbreekt";
588 if (mode === "reddit") {
589 return { ok: false, reason: reason };
590 }
591 }
592 }
593
594 const seedId = (entry && (entry.firstId || (entry.chapterIds && entry.chapterIds[0]))) || startId;
595 const wanted = uniqueIds([].concat((entry && entry.chapterIds) || [], seedId ? [seedId] : []));
596 const fetched = await this.loadPostsByIds(wanted, mode);
597 const posts = fetched && Array.isArray(fetched.posts) ? fetched.posts : [];
598 if (!posts.length) {
599 return { ok: false, reason: reason || (fetched && fetched.reason) || "geen posts" };
600 }
601 const byId = {};
602 posts.forEach((post) => {
603 const id = postId(post);
604 if (id) {
605 byId[id] = post;
606 }
607 });
608 const toc = wanted.map((id) => byId[id]).filter(Boolean);
609 let members = toc.slice();
610 const startPost = toc.length ? toc[toc.length - 1] : byId[seedId];
611 if (startPost) {
612 const tail = await this.followChain(startPost, byId, mode);
613 const seen = {};
614 members.forEach((p) => {
615 seen[postId(p)] = true;
616 });
617 tail.forEach((p) => {
618 const id = postId(p);
619 if (id && !seen[id]) {
620 seen[id] = true;
621 members.push(p);
622 }
623 });
624 }
625 if (!members.length) {
626 return { ok: false, reason: reason || fetched.reason || "geen hoofdstukken" };
627 }
628 members = members.slice().sort(comparePosts);
629 const first = members[0];
630 const name = (entry && entry.title) || guessTitle(members.map((p) => p.title)) || first.title || "Untitled";
631 const author = (entry && entry.author) || first.author || "Anonymous";
632 const path = startId ? "series/" + postId(first) : wikiSlug ? "wiki/" + wikiSlug : "series/" + postId(first);
633 const nsfw = members.some((p) => p.over_18 || p.over18);
634 const oneshot = members.length <= 1;
635 return {
636 ok: true,
637 novel: {
638 path: path,
639 name: name,
640 author: author,
641 artist: undefined,
642 cover: this.coverFor({ name: name, source: coverSourceOf(fetched && fetched.source, source) }),
643 genres: nsfw ? "HFY, NSFW" : "HFY",
644 status: oneshot ? NovelStatus.Completed : NovelStatus.Unknown,
645 summary: author ? "HFY-serie van u/" + author + "." : "",
646 chapters: members.map((p, i) => ({
647 name: p.title || "Chapter " + (i + 1),
648 path: "chapter/" + postId(p),
649 releaseTime: releaseTimeOf(p),
650 chapterNumber: i + 1,
651 })),
652 },
653 };
654 }
655
656 async loadWikiIndex(mode) {
657 const cached = readWikiCache();
658 const haveCached = cached && cached.entries && cached.entries.length;
659 // Alleen een Reddit-cache is lang geldig. Een Arctic-fallback cachen we
660 // kort, en we proberen Reddit altijd opnieuw (bijv. na WebView-login).
661 if (haveCached && cached.source === "reddit") {
662 return { ok: true, entries: cached.entries, source: "reddit" };
663 }
664 if (mode !== "arctic") {
665 const reddit = await fetchRedditWikiMarkdown(WIKI_INDEX_PATH);
666 if (reddit.ok) {
667 const entries = parseSeriesIndex(reddit.markdown);
668 if (entries.length) {
669 writeWikiCache(entries, "reddit");
670 return { ok: true, entries: entries, source: "reddit" };
671 }
672 }
673 if (mode === "reddit") {
674 return { ok: false, reason: (reddit && reddit.reason) || "lege wiki-index" };
675 }
676 }
677 if (haveCached) {
678 return { ok: true, entries: cached.entries, source: cached.source || "arctic" };
679 }
680 const arctic = await fetchArcticWikiPage(this.chapterSource(), WIKI_INDEX_PATH);
681 if (arctic.ok) {
682 const entries = parseSeriesIndex(arctic.markdown);
683 if (entries.length) {
684 writeWikiCache(entries, "arctic");
685 return { ok: true, entries: entries, source: "arctic" };
686 }
687 }
688 return { ok: false, reason: (arctic && arctic.reason) || "wiki-index niet beschikbaar" };
689 }
690
691 async loadWikiPage(slug, mode) {
692 const path = WIKI_INDEX_PATH + "/" + slug;
693 if (mode !== "arctic") {
694 const reddit = await fetchRedditWikiMarkdown(path);
695 if (reddit.ok) {
696 return { ok: true, entry: parseSeriesPage(reddit.markdown, path), source: "reddit" };
697 }
698 if (mode === "reddit") {
699 return reddit;
700 }
701 }
702 const arctic = await fetchArcticWikiPage(this.chapterSource(), path);
703 if (arctic.ok) {
704 return { ok: true, entry: parseSeriesPage(arctic.markdown, path), source: "arctic" };
705 }
706 return { ok: false, reason: (arctic && arctic.reason) || "wiki-subpagina niet beschikbaar" };
707 }
708
709 async loadSearchPosts(term, page, mode) {
710 if (mode !== "arctic") {
711 const reddit = await fetchRedditSearch(term, page);
712 if (reddit.ok) {
713 return reddit;
714 }
715 if (mode === "reddit") {
716 return reddit;
717 }
718 }
719 return await fetchArcticSearch(this.chapterSource(), term);
720 }
721
722 async loadRecentOcPosts(page, mode) {
723 const wiki = await this.loadWikiIndex(mode === "reddit" ? "reddit" : "auto");
724 if (mode !== "arctic") {
725 const reddit = await fetchRedditListing("/r/HFY/new.json", page);
726 if (reddit.ok) {
727 return {
728 ok: true,
729 posts: (reddit.posts || []).filter(isStoryPost),
730 wikiEntries: wiki.ok ? wiki.entries : [],
731 source: "reddit",
732 };
733 }
734 if (mode === "reddit") {
735 return reddit;
736 }
737 }
738 const arctic = await fetchArcticRecent(this.chapterSource());
739 if (arctic.ok) {
740 return {
741 ok: true,
742 posts: (arctic.posts || []).filter(isStoryPost),
743 wikiEntries: wiki.ok ? wiki.entries : [],
744 source: "arctic",
745 };
746 }
747 return arctic;
748 }
749
750 async loadPostsByIds(ids, mode) {
751 const wanted = uniqueIds(ids);
752 if (!wanted.length) {
753 return { ok: true, posts: [], source: "none" };
754 }
755 if (mode !== "arctic") {
756 const reddit = await fetchRedditPostsByIds(wanted);
757 if (reddit.ok) {
758 return reddit;
759 }
760 if (mode === "reddit") {
761 return reddit;
762 }
763 }
764 return await fetchArcticPostsByIds(this.chapterSource(), wanted);
765 }
766
767 async followChain(seed, byId, mode) {
768 const chain = [];
769 const visited = {};
770 let current = seed;
771 let guard = 0;
772 while (current && guard < 400) {
773 const id = postId(current);
774 if (!id || visited[id]) {
775 break;
776 }
777 visited[id] = true;
778 chain.push(current);
779 const nxt = pickNextLink(current);
780 if (!nxt || visited[nxt]) {
781 break;
782 }
783 if (!byId[nxt]) {
784 const fetched = await this.loadPostsByIds([nxt], mode);
785 (fetched.posts || []).forEach((p) => {
786 const pid = postId(p);
787 if (pid) {
788 byId[pid] = p;
789 }
790 });
791 }
792 const candidate = byId[nxt];
793 if (!candidate) {
794 break;
795 }
796 if (!titlesBelongTogether(current.title, candidate.title, current.author, candidate.author, nxt === pickNextLink(current))) {
797 // Expliciete next van dezelfde auteur mag iets lager scoren; anders stoppen.
798 if (!sameAuthor(current, candidate) || titleSimilarity(current.title, candidate.title) < 0.4) {
799 break;
800 }
801 }
802 current = candidate;
803 guard += 1;
804 }
805 return chain;
806 }
807}
808
809function wikiSlugFromPath(novelPath) {
810 const raw = String(novelPath || "").trim();
811 const m = raw.match(/^(?:wiki\/|series\/wiki\/)?(?:r\/hfy\/wiki\/series\/)?([a-z0-9][a-z0-9_-]{1,80})$/i);
812 if (!m) {
813 return "";
814 }
815 const slug = m[1];
816 if (/^[0-9a-z]{4,10}$/i.test(slug) && raw.indexOf("wiki/") === -1) {
817 return "";
818 }
819 if (raw.indexOf("wiki/") === 0 || raw.indexOf("/wiki/series/") !== -1) {
820 return slug;
821 }
822 return "";
823}
824
825function wikiEntryToItem(entry, plugin, source) {
826 const first = entry.firstId || (entry.chapterIds && entry.chapterIds[0]) || "";
827 const path = first ? "series/" + first : "wiki/" + entry.slug;
828 return {
829 name: entry.title,
830 path: path,
831 cover: plugin.coverFor({ name: entry.title, cover: null, source: source }),
832 author: entry.author || "",
833 oneshot: false,
834 nsfw: false,
835 };
836}
837
838function wikiEntryMatches(entry, term) {
839 const q = String(term || "").trim().toLowerCase();
840 if (!q) {
841 return false;
842 }
843 const title = String(entry.title || "").toLowerCase();
844 const author = String(entry.author || "").toLowerCase();
845 const slug = String(entry.slug || "").toLowerCase().replace(/_/g, " ");
846 return title.indexOf(q) !== -1 || author.indexOf(q) !== -1 || slug.indexOf(q) !== -1;
847}
848
849function wikiCacheTtl(source) {
850 return source === "reddit" ? WIKI_CACHE_MS_REDDIT : WIKI_CACHE_MS_ARCTIC;
851}
852
853function readWikiCache() {
854 try {
855 const value = storage.get(WIKI_CACHE_KEY);
856 if (!value) {
857 return null;
858 }
859 let parsed = value;
860 if (Array.isArray(value)) {
861 parsed = { entries: value, source: "reddit" };
862 }
863 if (!parsed.entries || !Array.isArray(parsed.entries) || !parsed.entries.length) {
864 return null;
865 }
866 const source = parsed.source || "reddit";
867 const fetchedAt = Number(parsed.fetchedAt || 0);
868 if (fetchedAt && Date.now() - fetchedAt > wikiCacheTtl(source)) {
869 return null;
870 }
871 return parsed;
872 } catch (err) {
873 return null;
874 }
875}
876
877function writeWikiCache(entries, source) {
878 try {
879 const src = source || "arctic";
880 const expires = Date.now() + wikiCacheTtl(src);
881 storage.set(WIKI_CACHE_KEY, { fetchedAt: Date.now(), entries: entries, source: src }, expires);
882 } catch (err) {
883 // cache is optioneel
884 }
885}
886
887function parseSeriesIndex(markdown) {
888 const text = String(markdown || "");
889 const out = [];
890 const seen = {};
891 const re = /^\s*[\*\-]\s*\[([^\]]+)\]\(([^)]+)\)(.*)$/gm;
892 let m;
893 while ((m = re.exec(text))) {
894 const title = cleanHeading(m[1]);
895 const path = normalizeWikiPath(m[2]);
896 if (!path || path.toLowerCase().indexOf("/wiki/series/") === -1) {
897 continue;
898 }
899 const key = path.toLowerCase();
900 if (seen[key]) {
901 continue;
902 }
903 seen[key] = true;
904 const slug = path.split("/").filter(Boolean).pop();
905 out.push({
906 title: title || slug.replace(/_/g, " "),
907 wikiPath: path,
908 slug: slug,
909 author: authorFromRest(m[3] || ""),
910 chapterIds: [],
911 firstId: "",
912 });
913 }
914 return out;
915}
916
917function parseSeriesPage(markdown, wikiPath) {
918 const text = String(markdown || "");
919 const path = normalizeWikiPath(wikiPath) || String(wikiPath || "");
920 const slug = path.split("/").filter(Boolean).pop() || "";
921 const heading = text.match(/^#{1,4}\s*(.+)$/m);
922 let title = heading ? cleanHeading(heading[1]) : slug.replace(/_/g, " ");
923 if (title && /^(all series|series|one shots|oneshots)$/i.test(title)) {
924 title = slug.replace(/_/g, " ");
925 }
926 const ids = [];
927 const seen = {};
928 extractLabeledLinks(text).forEach((link) => {
929 if (!seen[link.id]) {
930 seen[link.id] = true;
931 ids.push(link.id);
932 }
933 });
934 extractIds(text).forEach((id) => {
935 if (!seen[id]) {
936 seen[id] = true;
937 ids.push(id);
938 }
939 });
940 return {
941 title: title,
942 wikiPath: path,
943 slug: slug,
944 author: authorFromPage(text),
945 chapterIds: ids,
946 firstId: ids[0] || "",
947 };
948}
949
950function normalizeWikiPath(href) {
951 if (!href) {
952 return "";
953 }
954 let raw = String(href).trim().split(")")[0].split(/\s+/)[0];
955 raw = raw.replace(/\/wiki\/settings\/series\//i, "/wiki/series/");
956 const m = raw.match(/(?:https?:\/\/(?:www\.)?reddit\.com)?(\/r\/[^/]+\/wiki\/(?:series)\/[^)#\s]+)/i);
957 if (!m) {
958 return "";
959 }
960 const parts = m[1].split("/");
961 if (parts.length >= 3 && parts[1].toLowerCase() === "r") {
962 parts[2] = "hfy";
963 }
964 return parts.join("/").replace(/\/+$/, "").replace(/\/r\/HFY\//i, "/r/hfy/");
965}
966
967function cleanHeading(raw) {
968 let text = String(raw || "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
969 text = text.replace(/[*_`]+/g, "");
970 return text.replace(/\s+/g, " ").trim();
971}
972
973function authorFromRest(rest) {
974 const m = String(rest || "").match(/\[\s*\*([^*]+)\*\s*\]/);
975 if (!m) {
976 return "";
977 }
978 return m[1].replace(/^u\//, "").trim();
979}
980
981function authorFromPage(markdown) {
982 const wiki = String(markdown || "").match(
983 /\[(?:\*\*)?([^\]*]+)(?:\*\*)?\]\((?:https?:\/\/(?:www\.)?reddit\.com)?\/r\/[^/]+\/wiki\/authors\/([^)\s/]+)/i,
984 );
985 if (wiki) {
986 return (wiki[1] || wiki[2] || "").trim();
987 }
988 const by = String(markdown || "").match(/(?:a\s+story\s+by|author)\s*[:.\-–—]?\s*\[(?:\*\*)?([^\]*]+)(?:\*\*)?\]/i);
989 if (by) {
990 return by[1].trim();
991 }
992 const user = String(markdown || "").slice(0, 2000).match(/(?:https?:\/\/(?:www\.)?reddit\.com)?\/u(?:ser)?\/([A-Za-z0-9_-]+)|(?<![/\w])u\/([A-Za-z0-9_-]+)/i);
993 if (user) {
994 return (user[1] || user[2] || "").trim();
995 }
996 return "";
997}
998
999function extractIds(text) {
1000 const ids = [];
1001 const re = /(?:redd\.it\/|\/(?:r\/[^/]+\/)?comments\/)([0-9a-z]{4,10})\b/gi;
1002 let m;
1003 while ((m = re.exec(String(text || "")))) {
1004 ids.push(m[1].toLowerCase());
1005 }
1006 return ids;
1007}
1008
1009function extractLabeledLinks(text) {
1010 const links = [];
1011 const re = /\[([^\]]+)\]\(([^)]+)\)/g;
1012 let m;
1013 while ((m = re.exec(String(text || "")))) {
1014 const id = extractIds(m[2])[0];
1015 if (!id) {
1016 continue;
1017 }
1018 const label = String(m[1] || "").toLowerCase();
1019 let kind = "other";
1020 if (/\b(next|nxt|continue|volgende)\b/.test(label)) {
1021 kind = "next";
1022 } else if (/\b(prev|previous|vorige)\b/.test(label)) {
1023 kind = "prev";
1024 } else if (/\b(first|index|eerste)\b/.test(label)) {
1025 kind = "first";
1026 }
1027 links.push({ id: id, kind: kind, label: m[1] });
1028 }
1029 return links;
1030}
1031
1032function postId(post) {
1033 if (!post) {
1034 return "";
1035 }
1036 let id = String(post.id || "").replace(/^t3_/, "").toLowerCase();
1037 if (/^[0-9a-z]{4,10}$/.test(id)) {
1038 return id;
1039 }
1040 const fromUrl = extractIds(post.permalink || post.url || "")[0];
1041 return fromUrl || "";
1042}
1043
1044function comparePosts(a, b) {
1045 const ua = Number(a.created_utc || a.createdUtc || 0);
1046 const ub = Number(b.created_utc || b.createdUtc || 0);
1047 if (ua !== ub) {
1048 return ua - ub;
1049 }
1050 return postId(a) < postId(b) ? -1 : 1;
1051}
1052
1053function releaseTimeOf(post) {
1054 const utc = Number(post && (post.created_utc || post.createdUtc) || 0);
1055 if (!utc) {
1056 return null;
1057 }
1058 return new Date(utc * 1000).toISOString();
1059}
1060
1061function sameAuthor(a, b) {
1062 return String((a && a.author) || "").toLowerCase() === String((b && b.author) || "").toLowerCase();
1063}
1064
1065function pickNextLink(post) {
1066 const text = String((post && (post.selftext || post.selftext_html || post.body)) || "");
1067 const links = extractLabeledLinks(text);
1068 const next = links.find((l) => l.kind === "next");
1069 if (next) {
1070 return next.id;
1071 }
1072 const other = links.find((l) => l.kind === "other");
1073 return other ? other.id : "";
1074}
1075
1076function isStoryPost(post) {
1077 if (!post) {
1078 return false;
1079 }
1080 const isSelf = post.is_self !== false && post.isSelf !== false;
1081 if (!isSelf && !(post.selftext || post.selftext_html)) {
1082 return false;
1083 }
1084 const flair = String(post.link_flair_text || post.flair || "")
1085 .trim()
1086 .toLowerCase()
1087 .replace(/\s+/g, "");
1088 if (["meta", "mod", "media", "art", "video", "misc"].indexOf(flair) !== -1) {
1089 return false;
1090 }
1091 const title = String(post.title || "").toLowerCase();
1092 if (title.indexOf("[meta]") === 0 || title.indexOf("[mod]") === 0) {
1093 return false;
1094 }
1095 return true;
1096}
1097
1098function isSeedPost(post) {
1099 const flair = String(post.link_flair_text || post.flair || "")
1100 .trim()
1101 .toLowerCase()
1102 .replace(/\s+/g, "");
1103 if (flair.indexOf("firstofseries") !== -1) {
1104 return true;
1105 }
1106 if (flair.indexOf("oneshot") !== -1) {
1107 return true;
1108 }
1109 return isStartTitle(post.title);
1110}
1111
1112function isStartTitle(title) {
1113 return /(?:^|[\s:\-–—|\[\(])(?:(?:part|chapter|ch|pt|episode|ep)\.?\s*(?:1|i|one|first)\b|#\s*1\b|\(\s*1\s*(?:\/\s*(?:\d+|\?))?\s*\)|prologue)\b/i.test(
1114 String(title || ""),
1115 );
1116}
1117
1118function normalizeTitle(title) {
1119 let text = String(title || "");
1120 try {
1121 text = text.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
1122 } catch (err) {
1123 // oudere JS zonder normalize
1124 }
1125 text = text.replace(
1126 /\[\s*(?:oc|pi|hfy|ff|fic|meta|chapter|ch|part|pt|oneshot|one[-\s]?shot)(?:[^\]]*)\]/gi,
1127 " ",
1128 );
1129 text = text.replace(/^\s*(?:oc|pi|hfy|ff)\s*[:|\-–—]\s*/i, " ");
1130 text = text.replace(
1131 /(?:^|[\s,;:\-–—|\[\(])(?:part|chapter|chapters|ch|pt|episode|ep|update|book|vol|volume)\.?\s*(?:[0-9]+(?:\s*[./]\s*[0-9]+)?)|#\s*[0-9]+[\]\)]?/gi,
1132 " ",
1133 );
1134 text = text.replace(/[\s:\-–—|]*\(\s*[0-9]{1,4}\s*(?:\/\s*(?:[0-9]{1,4}|\?)\s*)?\)/g, " ");
1135 text = text.replace(/[\s:\-–—|]+(?:[0-9]{1,4})(?:\s*[./]\s*[0-9]{1,4})?\s*$/g, " ");
1136 return text.toLowerCase().replace(/["“”‘’`]+/g, "").replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
1137}
1138
1139function titleSimilarity(a, b) {
1140 const ta = normalizeTitle(a).split(" ").filter(Boolean);
1141 const tb = normalizeTitle(b).split(" ").filter(Boolean);
1142 if (!ta.length || !tb.length) {
1143 return 0;
1144 }
1145 const setB = {};
1146 tb.forEach((w) => {
1147 setB[w] = true;
1148 });
1149 let inter = 0;
1150 ta.forEach((w) => {
1151 if (setB[w]) {
1152 inter += 1;
1153 }
1154 });
1155 return inter / Math.sqrt(ta.length * tb.length);
1156}
1157
1158function titlesBelongTogether(aTitle, bTitle, aAuthor, bAuthor, explicitNext) {
1159 if (aAuthor && bAuthor && String(aAuthor).toLowerCase() !== String(bAuthor).toLowerCase()) {
1160 return explicitNext && titleSimilarity(aTitle, bTitle) >= 0.4;
1161 }
1162 const score = titleSimilarity(aTitle, bTitle);
1163 return explicitNext ? score >= 0.3 : score >= 0.5;
1164}
1165
1166function guessTitle(titles) {
1167 if (!titles || !titles.length) {
1168 return "";
1169 }
1170 const norms = titles.map(normalizeTitle).filter(Boolean);
1171 if (!norms.length) {
1172 return String(titles[0] || "").replace(/\s+/g, " ").trim();
1173 }
1174 const first = norms[0].split(" ");
1175 let end = first.length;
1176 for (let i = 1; i < norms.length; i++) {
1177 const parts = norms[i].split(" ");
1178 let j = 0;
1179 while (j < end && j < parts.length && parts[j] === first[j]) {
1180 j += 1;
1181 }
1182 end = j;
1183 }
1184 const shared = first.slice(0, end).join(" ");
1185 if (shared.length >= 4) {
1186 return shared.replace(/\b\w/g, (c) => c.toUpperCase());
1187 }
1188 return String(titles[0] || "").replace(/\s+/g, " ").trim();
1189}
1190
1191function groupPostsIntoNovels(posts, wikiEntries) {
1192 const stories = (posts || []).filter(isStoryPost);
1193 const groups = [];
1194 const claimed = {};
1195 const wiki = wikiEntries || [];
1196
1197 function matchWiki(post) {
1198 const key = normalizeTitle(post.title);
1199 const author = String(post.author || "").toLowerCase();
1200 let best = null;
1201 let bestScore = 0;
1202 wiki.forEach((entry) => {
1203 if (entry.author && author && entry.author.toLowerCase() !== author) {
1204 return;
1205 }
1206 const score = titleSimilarity(entry.title, post.title);
1207 if (score > bestScore) {
1208 bestScore = score;
1209 best = entry;
1210 }
1211 });
1212 if (best && bestScore >= 0.55) {
1213 return best;
1214 }
1215 if (best && key && normalizeTitle(best.title) === key) {
1216 return best;
1217 }
1218 return null;
1219 }
1220
1221 const byWiki = {};
1222 const byKey = {};
1223 stories.forEach((post) => {
1224 const wikiHit = matchWiki(post);
1225 if (wikiHit) {
1226 const k = "wiki:" + (wikiHit.slug || wikiHit.wikiPath);
1227 if (!byWiki[k]) {
1228 byWiki[k] = { entry: wikiHit, posts: [] };
1229 }
1230 byWiki[k].posts.push(post);
1231 claimed[postId(post)] = true;
1232 return;
1233 }
1234 const key = String(post.author || "").toLowerCase() + "|" + normalizeTitle(post.title);
1235 if (!byKey[key]) {
1236 byKey[key] = [];
1237 }
1238 byKey[key].push(post);
1239 });
1240
1241 Object.keys(byWiki).forEach((k) => {
1242 const g = byWiki[k];
1243 const members = g.posts.slice().sort(comparePosts);
1244 const first = members[0];
1245 groups.push({
1246 name: g.entry.title,
1247 path: postId(first) ? "series/" + postId(first) : "wiki/" + g.entry.slug,
1248 author: g.entry.author || first.author || "",
1249 oneshot: members.length <= 1,
1250 nsfw: members.some((p) => p.over_18 || p.over18),
1251 cover: null,
1252 });
1253 });
1254
1255 Object.keys(byKey).forEach((k) => {
1256 const members = byKey[k].filter((p) => !claimed[postId(p)]).sort(comparePosts);
1257 if (!members.length) {
1258 return;
1259 }
1260 // Alleen een nieuwe reeks starten als er een zaad is, of precies één post.
1261 const seeds = members.filter(isSeedPost);
1262 const use = seeds.length ? [seeds[0]].concat(members.filter((p) => p !== seeds[0])) : members;
1263 const ordered = use.slice().sort(comparePosts);
1264 const first = ordered[0];
1265 groups.push({
1266 name: guessTitle(ordered.map((p) => p.title)) || first.title,
1267 path: "series/" + postId(first),
1268 author: first.author || "",
1269 oneshot: ordered.length <= 1,
1270 nsfw: ordered.some((p) => p.over_18 || p.over18),
1271 cover: null,
1272 });
1273 });
1274
1275 return groups;
1276}
1277
1278function uniqueIds(ids) {
1279 const seen = {};
1280 const out = [];
1281 (ids || []).forEach((id) => {
1282 const key = String(id || "")
1283 .replace(/^t3_/, "")
1284 .toLowerCase();
1285 if (!/^[0-9a-z]{4,10}$/.test(key) || seen[key]) {
1286 return;
1287 }
1288 seen[key] = true;
1289 out.push(key);
1290 });
1291 return out;
1292}
1293
1294async function fetchRedditBody(url) {
1295 const res = await fetchApi(url, { headers: { Accept: "application/json" } });
1296 const body = res && typeof res.text === "function" ? await res.text() : "";
1297 const status = res && res.status != null ? res.status : "?";
1298 if (!res || res.ok === false || isLoginOrBlockPage(res, body)) {
1299 return {
1300 ok: false,
1301 blocked: !res || res.ok === false || isLoginOrBlockPage(res, body),
1302 reason: "HTTP " + status + (isLoginOrBlockPage(res, body) ? " (login of blokkade)" : ""),
1303 body: body,
1304 res: res,
1305 };
1306 }
1307 if (!body || looksLikeHtml(body)) {
1308 return { ok: false, reason: "geen JSON", body: body, res: res };
1309 }
1310 return { ok: true, body: body, res: res };
1311}
1312
1313async function fetchRedditJson(pathAndQuery) {
1314 const path = pathAndQuery.indexOf("/") === 0 ? pathAndQuery : "/" + pathAndQuery;
1315 const urls = [REDDIT_WWW + path, REDDIT_OLD + path];
1316 let last = { ok: false, reason: "geen antwoord" };
1317 for (let i = 0; i < urls.length; i++) {
1318 try {
1319 const got = await fetchRedditBody(urls[i]);
1320 if (!got.ok) {
1321 last = got;
1322 continue;
1323 }
1324 try {
1325 return { ok: true, data: JSON.parse(got.body), source: "reddit" };
1326 } catch (err) {
1327 last = { ok: false, reason: "ongeldige JSON" };
1328 }
1329 } catch (err) {
1330 last = { ok: false, reason: err && err.message ? err.message : String(err) };
1331 }
1332 }
1333 return last;
1334}
1335
1336async function fetchRedditWikiMarkdown(wikiPath) {
1337 const path = String(wikiPath || "").replace(/\/+$/, "");
1338 // Sommige Reddit-clients willen /wiki/series.json, andere /wiki/series/.json.
1339 const variants = [path + ".json?raw_json=1", path + "/.json?raw_json=1"];
1340 let last = { ok: false, reason: "lege wikipagina" };
1341 for (let i = 0; i < variants.length; i++) {
1342 const result = await fetchRedditJson(variants[i]);
1343 if (!result.ok) {
1344 last = result;
1345 continue;
1346 }
1347 const data = result.data && result.data.data ? result.data.data : result.data;
1348 const markdown = data && (data.content_md || data.content_html || data.content);
1349 if (!markdown || !String(markdown).trim()) {
1350 last = { ok: false, reason: "lege wikipagina" };
1351 continue;
1352 }
1353 return { ok: true, markdown: String(data.content_md || markdown), source: "reddit" };
1354 }
1355 return last;
1356}
1357
1358async function fetchRedditSearch(term, page) {
1359 const params =
1360 "q=" +
1361 encodeURIComponent(term) +
1362 "&restrict_sr=1&sort=relevance&limit=25&raw_json=1&type=link&count=" +
1363 ((Math.max(1, page) - 1) * 25);
1364 const result = await fetchRedditJson("/r/HFY/search.json?" + params);
1365 if (!result.ok) {
1366 return result;
1367 }
1368 return { ok: true, posts: listingPosts(result.data), source: "reddit" };
1369}
1370
1371async function fetchRedditListing(path, page) {
1372 const count = (Math.max(1, page) - 1) * 25;
1373 const qs = "limit=25&raw_json=1" + (count ? "&count=" + count : "");
1374 const result = await fetchRedditJson(path + (path.indexOf("?") === -1 ? "?" : "&") + qs);
1375 if (!result.ok) {
1376 return result;
1377 }
1378 return { ok: true, posts: listingPosts(result.data), source: "reddit" };
1379}
1380
1381async function fetchRedditPostsByIds(ids) {
1382 const wanted = uniqueIds(ids);
1383 const full = wanted.map((id) => "t3_" + id);
1384 const posts = [];
1385 let infoFailed = null;
1386 for (let i = 0; i < full.length; i += 100) {
1387 const chunk = full.slice(i, i + 100);
1388 const result = await fetchRedditJson("/api/info.json?id=" + encodeURIComponent(chunk.join(",")) + "&raw_json=1");
1389 if (!result.ok) {
1390 if (!posts.length) {
1391 infoFailed = result;
1392 break;
1393 }
1394 break;
1395 }
1396 listingPosts(result.data).forEach((p) => posts.push(p));
1397 }
1398 if (posts.length) {
1399 return { ok: true, posts: posts, source: "reddit" };
1400 }
1401 // /api/info.json is een ander endpoint dan de hoofdstukken
1402 // (/comments/{id}/.json) en kan 403 geven terwijl die wel werken.
1403 const fromComments = [];
1404 for (let i = 0; i < wanted.length; i++) {
1405 const chapter = await tryRedditChapter(wanted[i]);
1406 if (chapter && chapter.ok && chapter.post) {
1407 fromComments.push(chapter.post);
1408 }
1409 }
1410 if (fromComments.length) {
1411 return { ok: true, posts: fromComments, source: "reddit" };
1412 }
1413 return infoFailed || { ok: false, reason: "geen posts" };
1414}
1415
1416function listingPosts(payload) {
1417 const listing = Array.isArray(payload) ? payload[0] : payload;
1418 const children = listing && listing.data && Array.isArray(listing.data.children) ? listing.data.children : [];
1419 const out = [];
1420 children.forEach((child) => {
1421 if (child && child.data && (!child.kind || child.kind === "t3")) {
1422 out.push(child.data);
1423 }
1424 });
1425 return out;
1426}
1427
1428async function fetchArcticWikiPage(base, wikiPath) {
1429 const url =
1430 String(base || "").replace(/\/+$/, "") +
1431 "/api/subreddits/wikis?paths=" +
1432 encodeURIComponent(wikiPath);
1433 try {
1434 const payload = await readJson(url, "wiki " + wikiPath);
1435 const pages = payload.data || payload;
1436 const page = Array.isArray(pages) ? pages[0] : pages;
1437 const markdown = page && (page.content || page.content_md);
1438 if (!markdown || !String(markdown).trim()) {
1439 return { ok: false, reason: "lege Arctic Shift-wikipagina" };
1440 }
1441 return { ok: true, markdown: String(markdown), source: "arctic" };
1442 } catch (err) {
1443 return { ok: false, reason: err && err.message ? err.message : String(err) };
1444 }
1445}
1446
1447async function fetchArcticSearch(base, term) {
1448 const root = String(base || "").replace(/\/+$/, "");
1449 const tryUrls = [
1450 root + "/api/posts/search?subreddit=HFY&query=" + encodeURIComponent(term) + "&limit=25&sort=desc",
1451 root + "/api/posts/search?subreddit=HFY&title=" + encodeURIComponent(term) + "&limit=25&sort=desc",
1452 ];
1453 let last = { ok: false, reason: "Arctic Shift-zoeken mislukt" };
1454 for (let i = 0; i < tryUrls.length; i++) {
1455 try {
1456 const payload = await readJson(tryUrls[i], "zoeken");
1457 const posts = payload.data || payload;
1458 if (Array.isArray(posts)) {
1459 return { ok: true, posts: posts, source: "arctic" };
1460 }
1461 } catch (err) {
1462 last = { ok: false, reason: err && err.message ? err.message : String(err) };
1463 }
1464 }
1465 return last;
1466}
1467
1468async function fetchArcticRecent(base) {
1469 const url = String(base || "").replace(/\/+$/, "") + "/api/posts/search?subreddit=HFY&limit=50&sort=desc";
1470 try {
1471 const payload = await readJson(url, "recente posts");
1472 const posts = payload.data || payload;
1473 return { ok: true, posts: Array.isArray(posts) ? posts : [], source: "arctic" };
1474 } catch (err) {
1475 return { ok: false, reason: err && err.message ? err.message : String(err) };
1476 }
1477}
1478
1479async function fetchArcticPostsByIds(base, ids) {
1480 const url =
1481 String(base || "").replace(/\/+$/, "") +
1482 "/api/posts/ids?ids=" +
1483 encodeURIComponent(uniqueIds(ids).join(","));
1484 try {
1485 const payload = await readJson(url, "posts");
1486 const posts = payload.data || payload;
1487 return { ok: true, posts: Array.isArray(posts) ? posts : [], source: "arctic" };
1488 } catch (err) {
1489 return { ok: false, reason: err && err.message ? err.message : String(err) };
1490 }
1491}
1492
1493function chapterIdFromPath(chapterPath) {
1494 const id = String(chapterPath || "")
1495 .replace(/^chapter\//, "")
1496 .replace(/^series\//, "")
1497 .trim()
1498 .toLowerCase();
1499 return /^[0-9a-z]{4,10}$/.test(id) ? id : "";
1500}
1501
1502function redditJsonUrls(id) {
1503 const path = "/r/HFY/comments/" + id + "/.json?raw_json=1";
1504 return [REDDIT_WWW + path, REDDIT_OLD + path];
1505}
1506
1507function looksLikeHtml(text) {
1508 const body = String(text || "").trim();
1509 if (!body) {
1510 return false;
1511 }
1512 return /^\s*<(!DOCTYPE|html|body|head)\b/i.test(body);
1513}
1514
1515function isLoginOrBlockPage(res, body) {
1516 const status = res && res.status != null ? Number(res.status) : 0;
1517 if (status === 401 || status === 403 || status === 429) {
1518 return true;
1519 }
1520 const finalUrl = String((res && res.url) || "");
1521 if (/[?&]reason=lor2\b/i.test(finalUrl) || /\/login\b/i.test(finalUrl)) {
1522 return true;
1523 }
1524 const type = String(
1525 (res && res.headers && typeof res.headers.get === "function" && res.headers.get("content-type")) || "",
1526 ).toLowerCase();
1527 if (type.indexOf("text/html") !== -1 && !/json/i.test(type)) {
1528 return true;
1529 }
1530 const text = String(body || "");
1531 if (looksLikeHtml(text)) {
1532 return true;
1533 }
1534 const lower = text.toLowerCase();
1535 if (
1536 lower.indexOf("reason=lor2") !== -1 ||
1537 lower.indexOf("www.reddit.com/login") !== -1 ||
1538 lower.indexOf("old.reddit.com/login") !== -1 ||
1539 lower.indexOf("log in to reddit") !== -1 ||
1540 (lower.indexOf("shreddit") !== -1 && lower.indexOf("<!doctype html") !== -1)
1541 ) {
1542 return true;
1543 }
1544 return false;
1545}
1546
1547function postFromRedditPayload(payload) {
1548 if (!payload) {
1549 return null;
1550 }
1551 const listing = Array.isArray(payload) ? payload[0] : payload;
1552 const children =
1553 listing && listing.data && Array.isArray(listing.data.children) ? listing.data.children : [];
1554 const child = children.find((c) => !c.kind || c.kind === "t3") || children[0];
1555 if (!child || !child.data) {
1556 return null;
1557 }
1558 if (child.kind && child.kind !== "t3") {
1559 return null;
1560 }
1561 return child.data;
1562}
1563
1564function decodeRedditHtml(html) {
1565 let text = String(html || "");
1566 if (text.indexOf("&lt;") !== -1 || text.indexOf("&amp;") !== -1) {
1567 text = text
1568 .replace(/&lt;/g, "<")
1569 .replace(/&gt;/g, ">")
1570 .replace(/&quot;/g, '"')
1571 .replace(/&#39;/g, "'")
1572 .replace(/&amp;/g, "&");
1573 }
1574 return text;
1575}
1576
1577async function tryRedditChapter(id) {
1578 let lastReason = "geen antwoord";
1579 const urls = redditJsonUrls(id);
1580 for (let i = 0; i < urls.length; i++) {
1581 const url = urls[i];
1582 try {
1583 const res = await fetchApi(url, { headers: { Accept: "application/json" } });
1584 const body = typeof res.text === "function" ? await res.text() : "";
1585 if (!res || res.ok === false || isLoginOrBlockPage(res, body)) {
1586 const status = res && res.status != null ? res.status : "?";
1587 lastReason = "HTTP " + status + (isLoginOrBlockPage(res, body) ? " (login of blokkade)" : "");
1588 continue;
1589 }
1590 if (!body || looksLikeHtml(body)) {
1591 lastReason = "geen JSON";
1592 continue;
1593 }
1594 let payload;
1595 try {
1596 payload = JSON.parse(body);
1597 } catch (err) {
1598 lastReason = "ongeldige JSON";
1599 continue;
1600 }
1601 const post = postFromRedditPayload(payload);
1602 if (!post) {
1603 lastReason = "geen post in de listing";
1604 continue;
1605 }
1606 return { ok: true, post: post };
1607 } catch (err) {
1608 lastReason = err && err.message ? err.message : String(err);
1609 }
1610 }
1611 return { ok: false, reason: lastReason };
1612}
1613
1614async function tryArcticChapter(base, id) {
1615 const url = String(base || "").replace(/\/+$/, "") + "/api/posts/ids?ids=" + encodeURIComponent(id) + "&md2html=true";
1616 try {
1617 const payload = await readJson(url, "hoofdstuk " + id);
1618 const posts = payload.data || payload;
1619 const post = Array.isArray(posts) ? posts[0] : posts;
1620 if (!post) {
1621 return { ok: false, reason: "leeg antwoord" };
1622 }
1623 return { ok: true, post: post };
1624 } catch (err) {
1625 return { ok: false, reason: err && err.message ? err.message : String(err) };
1626 }
1627}
1628
1629function sourceFooter(label) {
1630 return '<p class="hfy-source"><em>Bron: ' + escapeHtml(label) + "</em></p>";
1631}
1632
1633function renderChapter(post, sourceLabel) {
1634 if (!post) {
1635 return "<p><em>Dit hoofdstuk is niet (meer) beschikbaar.</em></p>" + sourceFooter(sourceLabel);
1636 }
1637 const title = post.title ? "<h1>" + escapeHtml(post.title) + "</h1>" : "";
1638 const by = post.author ? "<p><em>by u/" + escapeHtml(post.author) + "</em></p>" : "";
1639 const rawHtml = post.selftext_html ? decodeRedditHtml(post.selftext_html) : "";
1640 const html = rawHtml ? sanitizeHtml(rawHtml) : markdownToHtml(post.selftext || "");
1641 if (!html) {
1642 return (
1643 title +
1644 by +
1645 "<p><em>Deze post heeft geen tekst (verwijderd of een link-post).</em></p>" +
1646 sourceFooter(sourceLabel)
1647 );
1648 }
1649 return title + by + html + sourceFooter(sourceLabel);
1650}
1651
1652function escapeHtml(text) {
1653 return String(text)
1654 .replace(/&/g, "&amp;")
1655 .replace(/</g, "&lt;")
1656 .replace(/>/g, "&gt;")
1657 .replace(/"/g, "&quot;");
1658}
1659
1660function sanitizeHtml(html) {
1661 // Reddit en Arctic Shift leveren HTML; we strippen scripts en on-event-attributen.
1662 return String(html)
1663 .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "")
1664 .replace(/\son[a-z]+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
1665}
1666
1667function markdownToHtml(md) {
1668 if (!md) {
1669 return "";
1670 }
1671 const escaped = escapeHtml(md);
1672 const withLinks = escaped.replace(
1673 /\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g,
1674 '<a href="$2">$1</a>',
1675 );
1676 const paragraphs = withLinks
1677 .split(/\n{2,}/)
1678 .map((block) => "<p>" + block.replace(/\n/g, "<br>") + "</p>");
1679 return paragraphs.join("");
1680}
1681
1682const instance = new HFYNovelsPlugin();
1683exports.default = instance;