BlueGit

timfa hfy-novels

Files

hfy-novels / plugin / hfy-novels.js

hfy-novels.js

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