Balrog57
331 lines
11 KiB
TypeScript
331 lines
11 KiB
TypeScript
import { load } from 'cheerio';
|
||
import { defaultCover } from '@libs/defaultCover';
|
||
import { fetchApi } from '@libs/fetch';
|
||
import { NovelStatus } from '@libs/novelStatus';
|
||
import { Plugin } from '@/types/plugin';
|
||
|
||
type WordPressPage = {
|
||
slug: string;
|
||
link: string;
|
||
title: { rendered: string };
|
||
content: { rendered: string };
|
||
};
|
||
|
||
const chapterSlug =
|
||
/(?:chapitre|prologue|epilogue|interlude|bonus|postface|preface)/i;
|
||
|
||
class JGardenPlugin implements Plugin.PluginBase {
|
||
id = 'jgarden';
|
||
name = 'J-Garden';
|
||
icon = 'src/fr/jgarden/icon.png';
|
||
site = 'https://j-garden.fr/';
|
||
version = '1.0.5';
|
||
|
||
resolveUrl(path: string): string {
|
||
const url = new URL(path, this.site);
|
||
if (url.origin !== new URL(this.site).origin)
|
||
throw new Error('Cannot resolve a foreign origin');
|
||
return url.toString();
|
||
}
|
||
|
||
private slugFromLink(link: string): string | undefined {
|
||
try {
|
||
const url = new URL(link, this.site);
|
||
if (url.origin !== new URL(this.site).origin) return undefined;
|
||
const parts = url.pathname.split('/').filter(Boolean);
|
||
return parts[parts.length - 1];
|
||
} catch {
|
||
return undefined;
|
||
}
|
||
}
|
||
|
||
private async getJson<T>(path: string): Promise<T> {
|
||
const response = await fetchApi(this.resolveUrl(path));
|
||
if (!response.ok) throw new Error(`Failed to load ${path}`);
|
||
if (!/[/+]json\b/i.test(response.headers.get('content-type') || ''))
|
||
throw new Error(`Expected a JSON response for ${path}`);
|
||
return response.json() as Promise<T>;
|
||
}
|
||
|
||
private parseCatalogue(html: string): Plugin.NovelItem[] {
|
||
const $ = load(html);
|
||
const novels = new Map<string, Plugin.NovelItem>();
|
||
$('a[href]').each((_, element) => {
|
||
const href = $(element).attr('href');
|
||
const path = href ? this.slugFromLink(href) : undefined;
|
||
const image = $(element).find('img').first();
|
||
const name =
|
||
$(element).text().trim() ||
|
||
image.attr('alt')?.trim() ||
|
||
this.nameFromSlug(path || '');
|
||
const coverSrc = image.attr('src');
|
||
const width = Number(image.attr('width'));
|
||
const height = Number(image.attr('height'));
|
||
// The catalogue renders wide series banners (e.g. 2567×487), not the
|
||
// portrait book covers. A landscape image zoomed into a portrait card
|
||
// looks broken, so fall back to the default cover instead.
|
||
const isBanner =
|
||
Number.isFinite(width) && Number.isFinite(height) && width > height;
|
||
const cover =
|
||
coverSrc && !isBanner ? this.resolveUrl(coverSrc) : defaultCover;
|
||
if (path && name) novels.set(path, { name, path, cover });
|
||
});
|
||
return Array.from(novels.values());
|
||
}
|
||
|
||
// The catalogue only carries wide series banners; the actual portrait book
|
||
// cover lives on each novel's own page. Fetch it there so the list shows a
|
||
// real cover instead of a zoomed banner or the fallback placeholder.
|
||
private async fetchCover(slug: string): Promise<string> {
|
||
try {
|
||
const pages = await this.getJson<{ content: { rendered: string } }[]>(
|
||
`/wp-json/wp/v2/pages?slug=${encodeURIComponent(slug)}&_fields=content`,
|
||
);
|
||
const content = pages[0]?.content?.rendered;
|
||
if (!content) return defaultCover;
|
||
const $ = load(content);
|
||
let cover = '';
|
||
$('img').each((_, element) => {
|
||
if (cover) return;
|
||
const src = $(element).attr('src');
|
||
if (!src) return;
|
||
const width = Number($(element).attr('width'));
|
||
const height = Number($(element).attr('height'));
|
||
const portrait =
|
||
!Number.isFinite(width) ||
|
||
!Number.isFinite(height) ||
|
||
height >= width;
|
||
if (portrait) cover = this.resolveUrl(src);
|
||
});
|
||
return cover || defaultCover;
|
||
} catch {
|
||
return defaultCover;
|
||
}
|
||
}
|
||
|
||
private nameFromSlug(slug: string): string {
|
||
return slug
|
||
.split('-')
|
||
.filter(Boolean)
|
||
.map(word => word.charAt(0).toUpperCase() + word.slice(1))
|
||
.join(' ');
|
||
}
|
||
|
||
private chapterSequence(name: string, path: string) {
|
||
const source = `${name} ${path}`;
|
||
const volume = Number(
|
||
source.match(/(?:tome|volume|vol\.?|v|t)[\s_-]*(\d+)/i)?.[1] || 0,
|
||
);
|
||
// Within each volume: preface, prologue, numbered chapters, interlude,
|
||
// bonus, epilogue, then postface. Unrecognised links retain DOM order.
|
||
const specialKinds = [
|
||
['preface', 0],
|
||
['prologue', 1],
|
||
['interlude', 3],
|
||
['bonus', 4],
|
||
['epilogue', 5],
|
||
['postface', 6],
|
||
] as const;
|
||
const special = specialKinds.find(([label]) =>
|
||
new RegExp(`(?:^|[\\s_-])${label}(?:$|[\\s_-])`, 'i').test(source),
|
||
);
|
||
const chapter = source.match(
|
||
/(?:chapitre|chapter|ch\.?)[\s_-]*(\d+(?:[.,]\d+)?)/i,
|
||
);
|
||
return {
|
||
volume,
|
||
kind: special?.[1] ?? (chapter ? 2 : 7),
|
||
chapter: Number(chapter?.[1].replace(',', '.') || 0),
|
||
};
|
||
}
|
||
|
||
async popularNovels(pageNo: number): Promise<Plugin.NovelItem[]> {
|
||
if (pageNo > 1) return [];
|
||
const sections = await Promise.allSettled(
|
||
['jg-ln', 'jg-web-novel'].map(async section => {
|
||
const pages = await this.getJson<unknown>(
|
||
`/wp-json/wp/v2/pages?slug=${section}&_fields=content`,
|
||
);
|
||
if (
|
||
!Array.isArray(pages) ||
|
||
!pages.every(
|
||
page =>
|
||
page !== null &&
|
||
typeof page === 'object' &&
|
||
(page as Record<string, unknown>).content !== null &&
|
||
typeof (page as Record<string, unknown>).content === 'object' &&
|
||
typeof (page as { content: Record<string, unknown> }).content
|
||
.rendered === 'string',
|
||
)
|
||
)
|
||
throw new Error(`Invalid catalogue section: ${section}`);
|
||
return pages as Pick<WordPressPage, 'content'>[];
|
||
}),
|
||
);
|
||
const catalogues = sections.flatMap(section =>
|
||
section.status === 'fulfilled' ? [section.value] : [],
|
||
);
|
||
if (!catalogues.length) throw new Error('Failed to load catalogue');
|
||
const novels = new Map<string, Plugin.NovelItem>();
|
||
for (const section of catalogues.flat()) {
|
||
for (const novel of this.parseCatalogue(section.content.rendered)) {
|
||
novels.set(novel.path, novel);
|
||
}
|
||
}
|
||
const list = Array.from(novels.values());
|
||
const covers = await Promise.allSettled(
|
||
list.map(novel => this.fetchCover(novel.path)),
|
||
);
|
||
return list.map((novel, index) => ({
|
||
...novel,
|
||
cover:
|
||
covers[index]?.status === 'fulfilled'
|
||
? covers[index].value
|
||
: defaultCover,
|
||
}));
|
||
}
|
||
|
||
async parseNovel(novelPath: string): Promise<Plugin.SourceNovel> {
|
||
const novelUrl = this.resolveUrl(novelPath);
|
||
const slug = this.slugFromLink(novelUrl) || novelPath;
|
||
const pages = await this.getJson<WordPressPage[]>(
|
||
`/wp-json/wp/v2/pages?slug=${encodeURIComponent(slug)}&_fields=slug,link,title,content`,
|
||
);
|
||
const page = pages[0];
|
||
if (!page) throw new Error('Novel not found');
|
||
|
||
const $ = load(page.content.rendered);
|
||
const chapters = new Map<
|
||
string,
|
||
{ chapter: Plugin.ChapterItem; index: number }
|
||
>();
|
||
const firstChapter = $('a[href]')
|
||
.filter((_, element) => {
|
||
const href = $(element).attr('href');
|
||
const chapterPath = href ? this.slugFromLink(href) : undefined;
|
||
return Boolean(chapterPath && chapterSlug.test(chapterPath));
|
||
})
|
||
.first();
|
||
|
||
$('a[href]').each((index, element) => {
|
||
const href = $(element).attr('href');
|
||
const path = href ? this.slugFromLink(href) : undefined;
|
||
const name = $(element).text().trim();
|
||
if (path && name && chapterSlug.test(path) && !chapters.has(path)) {
|
||
chapters.set(path, { chapter: { name, path }, index });
|
||
}
|
||
});
|
||
|
||
const details = $('body *')
|
||
.map((_, element) => $(element).text().trim())
|
||
.get()
|
||
.filter(Boolean)
|
||
.join(' ');
|
||
const status =
|
||
/\b(?:termin(?:é|ée|e)|completed|complete|fini)(?![A-Za-zÀ-ÖØ-öø-ÿ0-9_])/i.test(
|
||
details,
|
||
)
|
||
? NovelStatus.Completed
|
||
: /\b(?:hiatus|en pause|pause)\b/i.test(details)
|
||
? NovelStatus.OnHiatus
|
||
: /\b(?:en cours|ongoing|publication)\b/i.test(details)
|
||
? NovelStatus.Ongoing
|
||
: NovelStatus.Unknown;
|
||
|
||
return {
|
||
path: page.slug,
|
||
name: load(page.title.rendered).text().trim(),
|
||
cover: $('img').first().attr('src')
|
||
? this.resolveUrl($('img').first().attr('src')!)
|
||
: defaultCover,
|
||
summary: firstChapter.prevAll().text().trim(),
|
||
status,
|
||
chapters: (() => {
|
||
const items = Array.from(chapters.values()).map(entry => ({
|
||
...entry,
|
||
sequence: this.chapterSequence(
|
||
entry.chapter.name,
|
||
entry.chapter.path,
|
||
),
|
||
}));
|
||
// When only some chapters carry a volume marker (e.g. v1/v2 books
|
||
// alongside untagged side stories), the site's DOM order is the
|
||
// reading order; keep it instead of interleaving by chapter number.
|
||
const mixedVolumes =
|
||
items.some(item => item.sequence.volume > 0) &&
|
||
items.some(item => item.sequence.volume === 0);
|
||
items.sort((left, right) => {
|
||
if (mixedVolumes) return left.index - right.index;
|
||
return (
|
||
left.sequence.volume - right.sequence.volume ||
|
||
left.sequence.kind - right.sequence.kind ||
|
||
left.sequence.chapter - right.sequence.chapter ||
|
||
left.index - right.index
|
||
);
|
||
});
|
||
return items.map(({ chapter }, index) => ({
|
||
...chapter,
|
||
chapterNumber: index + 1,
|
||
}));
|
||
})(),
|
||
};
|
||
}
|
||
|
||
async parseChapter(chapterPath: string): Promise<string> {
|
||
const chapterUrl = this.resolveUrl(chapterPath);
|
||
const slug = this.slugFromLink(chapterUrl) || chapterPath;
|
||
let posts = await this.getJson<
|
||
Pick<WordPressPage, 'content' | 'title' | 'link'>[]
|
||
>(
|
||
`/wp-json/wp/v2/posts?slug=${encodeURIComponent(slug)}&_fields=content,title,link`,
|
||
);
|
||
if (posts.length === 0) {
|
||
const resolved = await fetchApi(this.resolveUrl(chapterPath));
|
||
const canonicalSlug = this.slugFromLink(resolved.url);
|
||
if (canonicalSlug && canonicalSlug !== slug) {
|
||
posts = await this.getJson(
|
||
`/wp-json/wp/v2/posts?slug=${encodeURIComponent(canonicalSlug)}&_fields=content,title,link`,
|
||
);
|
||
}
|
||
}
|
||
const post = posts[0];
|
||
if (!post) throw new Error('Chapter not found');
|
||
|
||
const $ = load(post.content.rendered);
|
||
const content = $('.elementor-widget-theme-post-content').first();
|
||
const chapter = content.length ? content : $('body');
|
||
chapter
|
||
.find(
|
||
'script, style, nav, .sharedaddy, .share, [class*="share"], [id*="share"]',
|
||
)
|
||
.remove();
|
||
chapter
|
||
.find('*')
|
||
.filter((_, element) => !$(element).text().trim())
|
||
.remove();
|
||
const html = chapter.html()?.trim() || '';
|
||
if (chapter.text().trim().length < 200)
|
||
throw new Error('No readable chapter content found');
|
||
return html;
|
||
}
|
||
|
||
async searchNovels(
|
||
searchTerm: string,
|
||
pageNo: number,
|
||
): Promise<Plugin.NovelItem[]> {
|
||
if (pageNo !== 1) return [];
|
||
const normalize = (value: string) =>
|
||
value
|
||
.normalize('NFD')
|
||
.replace(/[\u0300-\u036f]/g, '')
|
||
.toLowerCase()
|
||
.trim();
|
||
const query = normalize(searchTerm);
|
||
return (await this.popularNovels(1)).filter(novel =>
|
||
normalize(novel.name).includes(query),
|
||
);
|
||
}
|
||
}
|
||
|
||
export default new JGardenPlugin();
|