From 16337a78a0040e4631cf80b0b01a0652acae7c5e Mon Sep 17 00:00:00 2001
From: Patrick <pdmacinnes@gmail.com>
Date: Wed, 12 Aug 2026 16:54:18 -0600
Subject: [PATCH 1/2] feat: add Anime Anyway plugin (english)

Reads the site's embedded Next.js page data (__NEXT_DATA__) instead of
scraping rendered HTML: volume/chapter lists and chapter bodies (Sanity
Portable Text) come straight from the JSON the site itself was built
from. Volumes titled "Year N Vol. M" are grouped into one novel per
year since no single page represents an entire year; everything else
is its own standalone novel.
---
 plugins/english/animeAnyway.ts            | 379 ++++++++++++++++++++++
 public/static/src/en/animeanyway/icon.png | Bin 0 -> 3449 bytes
 2 files changed, 379 insertions(+)
 create mode 100644 plugins/english/animeAnyway.ts
 create mode 100644 public/static/src/en/animeanyway/icon.png

diff --git a/plugins/english/animeAnyway.ts b/plugins/english/animeAnyway.ts
new file mode 100644
index 000000000..b3e00b7a2
--- /dev/null
+++ b/plugins/english/animeAnyway.ts
@@ -0,0 +1,379 @@
+import { fetchApi } from '@libs/fetch';
+import { Plugin } from '@/types/plugin';
+import { defaultCover } from '@libs/defaultCover';
+import { NovelStatus } from '@libs/novelStatus';
+
+type PortableSpan = {
+  _type: 'span';
+  text: string;
+  marks?: string[];
+};
+
+type PortableBlock =
+  | {
+      _type: 'block';
+      style?: string;
+      children?: PortableSpan[];
+    }
+  | { _type: 'horizontalLine' }
+  | { _type: 'image'; asset?: { _ref?: string } }
+  | { _type: string };
+
+type SanityVolume = {
+  title: string;
+  volkeyword: string;
+  mainImage?: { asset?: { url?: string } };
+  banner?: { asset?: { url?: string } };
+  progress?: number;
+  releaseDate?: string;
+  synopsis?: PortableBlock[];
+  chapters?: {
+    chkeyword: string;
+    title: string;
+  }[];
+};
+
+type SanityAllVolumesEntry = {
+  title: string;
+  volkeyword: string;
+  mainImage?: { asset?: { url?: string } };
+};
+
+type NextData<T> = { props: { pageProps: T } };
+
+type HomePageProps = { allVolumes?: SanityAllVolumesEntry[] };
+type VolumePageProps = { vol?: SanityVolume; statusCode?: number };
+type ChapterPageProps = {
+  chapter?: { content?: PortableBlock[] };
+  statusCode?: number;
+};
+
+/** Groups the "Year N Vol. M" family of volumes into one novel per year. */
+type CatalogueEntry = {
+  novelPath: string;
+  name: string;
+  cover: string;
+  /** volkeywords, ascending by volume number for grouped entries */
+  members: string[];
+  releaseDate: string;
+};
+
+class AnimeAnyway implements Plugin.PluginBase {
+  id = 'animeanyway';
+  name = 'Anime Anyway';
+  icon = 'src/en/animeanyway/icon.png';
+  site = 'https://animeanyway.com/';
+  version = '1.0.0';
+
+  private readonly yearVolumePattern = /^Year\s+(\d+)\s+Vol\.?\s*(\d+)/i;
+
+  /**
+   * Sanity's image CDN URL for a Portable Text image block, which only carries
+   * an asset reference ("image-<id>-<w>x<h>-<format>"), not a resolved URL —
+   * unlike mainImage/banner elsewhere on the site, which come pre-resolved.
+   * Project id and dataset are this site's own fixed identifiers.
+   */
+  private readonly sanityImageBase =
+    'https://cdn.sanity.io/images/m1xj6lbt/production/';
+
+  private cataloguePromise: Promise<CatalogueEntry[]> | null = null;
+  /** novelPath -> real site URL of its newest member volume, for resolveUrl. */
+  private novelUrlCache = new Map<string, string>();
+
+  /** Extracts the Next.js page data every server-rendered page embeds. */
+  private async fetchPageData<T>(path: string): Promise<T | undefined> {
+    const response = await fetchApi(`${this.site}${path}`);
+    const html = await response.text();
+    const match = html.match(
+      /<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/,
+    );
+    if (!match) return undefined;
+
+    const parsed = JSON.parse(match[1]) as NextData<T>;
+    return parsed.props?.pageProps;
+  }
+
+  /**
+   * The catalogue is built from the homepage's own volume list, then grouped:
+   * "Year N Vol. M" titled volumes become one novel per year (chapters spread
+   * across volumes on a real site with no single page for "all of Year N");
+   * everything else is its own standalone novel. Cached for the session.
+   */
+  private async getCatalogue(): Promise<CatalogueEntry[]> {
+    if (this.cataloguePromise) return this.cataloguePromise;
+
+    this.cataloguePromise = (async () => {
+      const home = await this.fetchPageData<HomePageProps>('');
+      const volumes = home?.allVolumes ?? [];
+
+      const years = new Map<
+        string,
+        { volkeyword: string; num: number; title: string }[]
+      >();
+      const entries: CatalogueEntry[] = [];
+
+      for (const volume of volumes) {
+        const match = volume.title.match(this.yearVolumePattern);
+        if (match) {
+          const year = match[1];
+          const list = years.get(year) ?? [];
+          list.push({
+            volkeyword: volume.volkeyword,
+            num: Number(match[2]),
+            title: volume.title,
+          });
+          years.set(year, list);
+        } else {
+          entries.push({
+            novelPath: volume.volkeyword,
+            name: volume.title,
+            cover: volume.mainImage?.asset?.url ?? defaultCover,
+            members: [volume.volkeyword],
+            releaseDate: '',
+          });
+        }
+      }
+
+      for (const [year, list] of Array.from(years)) {
+        list.sort((a, b) => a.num - b.num);
+        const latest = list[list.length - 1];
+        const latestVolume = volumes.find(
+          v => v.volkeyword === latest.volkeyword,
+        );
+        entries.push({
+          novelPath: `series/year-${year}`,
+          name: `Classroom of the Elite: Year ${year}`,
+          cover: latestVolume?.mainImage?.asset?.url ?? defaultCover,
+          members: list.map(v => v.volkeyword),
+          releaseDate: '',
+        });
+      }
+
+      // Release dates aren't on the homepage listing, only on each volume
+      // page — fetch just the newest member of each entry to sort "latest".
+      await Promise.all(
+        entries.map(async entry => {
+          const newest = entry.members[entry.members.length - 1];
+          const vol = await this.fetchPageData<VolumePageProps>(newest);
+          entry.releaseDate = vol?.vol?.releaseDate ?? '';
+        }),
+      );
+
+      for (const entry of entries) {
+        const newest = entry.members[entry.members.length - 1];
+        this.novelUrlCache.set(entry.novelPath, `${this.site}${newest}`);
+      }
+
+      return entries;
+    })();
+
+    try {
+      return await this.cataloguePromise;
+    } catch (error) {
+      this.cataloguePromise = null;
+      throw error;
+    }
+  }
+
+  async popularNovels(
+    pageNo: number,
+    { showLatestNovels }: Plugin.PopularNovelsOptions,
+  ): Promise<Plugin.NovelItem[]> {
+    if (pageNo > 1) return [];
+
+    const catalogue = await this.getCatalogue();
+    const ordered = showLatestNovels
+      ? [...catalogue].sort((a, b) =>
+          b.releaseDate.localeCompare(a.releaseDate),
+        )
+      : catalogue;
+
+    return ordered.map(entry => ({
+      name: entry.name,
+      path: entry.novelPath,
+      cover: entry.cover,
+    }));
+  }
+
+  private normalize(value: string) {
+    return value
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, ' ')
+      .trim();
+  }
+
+  private score(name: string, term: string): number {
+    const a = this.normalize(name);
+    const b = this.normalize(term);
+    if (!a || !b) return 0;
+
+    if (a === b) return 1000;
+    if (a.startsWith(b)) return 900;
+    if (a.includes(b)) return 800;
+
+    const queryTokens = b.split(' ').filter(Boolean);
+    const matched = queryTokens.filter(token => a.includes(token)).length;
+    if (matched === queryTokens.length) return 700;
+    if (matched > 0) return Math.round((matched / queryTokens.length) * 500);
+    return 0;
+  }
+
+  async searchNovels(
+    searchTerm: string,
+    pageNo: number,
+  ): Promise<Plugin.NovelItem[]> {
+    if (pageNo > 1 || !searchTerm.trim()) return [];
+
+    const catalogue = await this.getCatalogue();
+    return catalogue
+      .map(entry => ({ entry, score: this.score(entry.name, searchTerm) }))
+      .filter(({ score }) => score > 0)
+      .sort((a, b) => b.score - a.score)
+      .map(({ entry }) => ({
+        name: entry.name,
+        path: entry.novelPath,
+        cover: entry.cover,
+      }));
+  }
+
+  /** Reconstructs a Sanity CDN URL from a Portable Text image asset ref. */
+  private resolveImageRef(ref?: string): string | undefined {
+    const match = ref?.match(/^image-([a-f0-9]+)-(\d+x\d+)-(\w+)$/);
+    if (!match) return undefined;
+    return `${this.sanityImageBase}${match[1]}-${match[2]}.${match[3]}`;
+  }
+
+  private renderPortableText(blocks: PortableBlock[] | undefined): string {
+    if (!blocks) return '';
+
+    const parts: string[] = [];
+    for (const block of blocks) {
+      if (block._type === 'horizontalLine') {
+        parts.push('<hr>');
+      } else if (block._type === 'image') {
+        const src = this.resolveImageRef(
+          (block as { asset?: { _ref?: string } }).asset?._ref,
+        );
+        if (src) parts.push(`<img src="${src}">`);
+      } else if (block._type === 'block') {
+        const b = block as {
+          style?: string;
+          children?: PortableSpan[];
+        };
+        const tag = b.style === 'h2' ? 'h2' : 'p';
+        const inner = (b.children ?? [])
+          .map(span => {
+            let text = span.text ?? '';
+            if (span.marks?.includes('strong'))
+              text = `<strong>${text}</strong>`;
+            if (span.marks?.includes('em')) text = `<em>${text}</em>`;
+            return text;
+          })
+          .join('');
+        if (inner.trim()) parts.push(`<${tag}>${inner}</${tag}>`);
+      }
+      // Unrecognized block types are skipped rather than thrown on.
+    }
+    return parts.join('\n');
+  }
+
+  private plainTextFromPortableText(blocks: PortableBlock[] | undefined) {
+    if (!blocks) return undefined;
+    const text = blocks
+      .filter(
+        (block): block is { _type: 'block'; children?: PortableSpan[] } =>
+          block._type === 'block',
+      )
+      .map(block => (block.children ?? []).map(span => span.text).join(''))
+      .filter(line => line.trim())
+      .join('\n\n');
+    return text || undefined;
+  }
+
+  async parseNovel(novelPath: string): Promise<Plugin.SourceNovel> {
+    const novel: Plugin.SourceNovel = {
+      path: novelPath,
+      name: novelPath,
+      cover: defaultCover,
+      status: NovelStatus.Ongoing,
+      chapters: [],
+    };
+
+    if (novelPath.startsWith('series/year-')) {
+      const year = novelPath.replace('series/year-', '');
+      const catalogue = await this.getCatalogue();
+      const entry = catalogue.find(e => e.novelPath === novelPath);
+      if (!entry) {
+        novel.summary = 'This series is not available on Anime Anyway.';
+        return novel;
+      }
+
+      novel.name = entry.name;
+      novel.cover = entry.cover;
+
+      const chapters: Plugin.ChapterItem[] = [];
+      for (const volkeyword of entry.members) {
+        const data = await this.fetchPageData<VolumePageProps>(volkeyword);
+        const vol = data?.vol;
+        if (!vol) continue;
+
+        if (volkeyword === entry.members[entry.members.length - 1]) {
+          novel.summary = this.plainTextFromPortableText(vol.synopsis);
+        }
+
+        const volumeChapters = (vol.chapters ?? []).map((chapter, index) => ({
+          name: chapter.title,
+          path: `${volkeyword}/${chapter.chkeyword}`,
+          chapterNumber: chapters.length + index + 1,
+          page: vol.title,
+        }));
+        chapters.push(...volumeChapters);
+      }
+
+      novel.chapters = chapters;
+      if (!novel.summary) {
+        novel.summary = `Fan-translated continuation covering Year ${year} of Classroom of the Elite.`;
+      }
+      return novel;
+    }
+
+    const data = await this.fetchPageData<VolumePageProps>(novelPath);
+    const vol = data?.vol;
+    if (!vol) {
+      novel.summary = 'This novel is not available on Anime Anyway.';
+      return novel;
+    }
+
+    novel.name = vol.title;
+    novel.cover = vol.mainImage?.asset?.url ?? defaultCover;
+    novel.summary = this.plainTextFromPortableText(vol.synopsis);
+    novel.chapters = (vol.chapters ?? []).map((chapter, index) => ({
+      name: chapter.title,
+      path: `${novelPath}/${chapter.chkeyword}`,
+      chapterNumber: index + 1,
+    }));
+
+    return novel;
+  }
+
+  async parseChapter(chapterPath: string): Promise<string> {
+    const data = await this.fetchPageData<ChapterPageProps>(chapterPath);
+    const content = data?.chapter?.content;
+    if (!content)
+      return '<p>This chapter is not available on Anime Anyway.</p>';
+
+    const html = this.renderPortableText(content);
+    return html || '<p>This chapter appears to be empty.</p>';
+  }
+
+  resolveUrl = (path: string) => {
+    if (path.startsWith('series/year-')) {
+      // No single page represents an entire grouped year — point at the
+      // newest member volume's real URL, cached when the catalogue was built.
+      return this.novelUrlCache.get(path) ?? this.site;
+    }
+    return `${this.site}${path}`;
+  };
+}
+
+export default new AnimeAnyway();
diff --git a/public/static/src/en/animeanyway/icon.png b/public/static/src/en/animeanyway/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..b1c8b9b7e6df991d4e82c85b45199b5578e78f94
GIT binary patch
literal 3449
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
bVS@hwcoiIcY3ju%00000NkvXXu0mjfaQJj2

literal 0
HcmV?d00001


From 618c992a3f13959ebc20c156aaeb82161f7481e8 Mon Sep 17 00:00:00 2001
From: Patrick <pdmacinnes@gmail.com>
Date: Wed, 12 Aug 2026 17:23:53 -0600
Subject: [PATCH 2/2] fix: expose each Anime Anyway volume as its own novel

Each Classroom of the Elite volume is published as its own distinct
book, so list them separately instead of merging same-year volumes
into one novel. Drops the grouping/synthetic-path machinery entirely
-- every novel path is now just the site's own real volkeyword.
---
 plugins/english/animeAnyway.ts | 168 +++++++++------------------------
 1 file changed, 44 insertions(+), 124 deletions(-)

diff --git a/plugins/english/animeAnyway.ts b/plugins/english/animeAnyway.ts
index b3e00b7a2..70d2c449c 100644
--- a/plugins/english/animeAnyway.ts
+++ b/plugins/english/animeAnyway.ts
@@ -48,13 +48,11 @@ type ChapterPageProps = {
   statusCode?: number;
 };
 
-/** Groups the "Year N Vol. M" family of volumes into one novel per year. */
+/** One novel per volume — each is published as its own distinct book. */
 type CatalogueEntry = {
-  novelPath: string;
+  volkeyword: string;
   name: string;
   cover: string;
-  /** volkeywords, ascending by volume number for grouped entries */
-  members: string[];
   releaseDate: string;
 };
 
@@ -65,7 +63,12 @@ class AnimeAnyway implements Plugin.PluginBase {
   site = 'https://animeanyway.com/';
   version = '1.0.0';
 
-  private readonly yearVolumePattern = /^Year\s+(\d+)\s+Vol\.?\s*(\d+)/i;
+  /**
+   * The site's own volume titles ("Year 3 Vol. 4") don't name the franchise,
+   * unlike "High School Syndrome" which is already self-explanatory — prefix
+   * just the former so both are recognisable in a novel list.
+   */
+  private readonly yearVolumePattern = /^Year\s+\d+\s+Vol\.?\s*\d+/i;
 
   /**
    * Sanity's image CDN URL for a Portable Text image block, which only carries
@@ -77,8 +80,6 @@ class AnimeAnyway implements Plugin.PluginBase {
     'https://cdn.sanity.io/images/m1xj6lbt/production/';
 
   private cataloguePromise: Promise<CatalogueEntry[]> | null = null;
-  /** novelPath -> real site URL of its newest member volume, for resolveUrl. */
-  private novelUrlCache = new Map<string, string>();
 
   /** Extracts the Next.js page data every server-rendered page embeds. */
   private async fetchPageData<T>(path: string): Promise<T | undefined> {
@@ -93,11 +94,16 @@ class AnimeAnyway implements Plugin.PluginBase {
     return parsed.props?.pageProps;
   }
 
+  private displayName(title: string) {
+    return this.yearVolumePattern.test(title)
+      ? `Classroom of the Elite: ${title}`
+      : title;
+  }
+
   /**
-   * The catalogue is built from the homepage's own volume list, then grouped:
-   * "Year N Vol. M" titled volumes become one novel per year (chapters spread
-   * across volumes on a real site with no single page for "all of Year N");
-   * everything else is its own standalone novel. Cached for the session.
+   * The catalogue is the homepage's own volume list, one novel per volume —
+   * each is published as its own book on the site, so that's what's exposed
+   * here too. Cached for the session (shared promise, retried on failure).
    */
   private async getCatalogue(): Promise<CatalogueEntry[]> {
     if (this.cataloguePromise) return this.cataloguePromise;
@@ -106,65 +112,12 @@ class AnimeAnyway implements Plugin.PluginBase {
       const home = await this.fetchPageData<HomePageProps>('');
       const volumes = home?.allVolumes ?? [];
 
-      const years = new Map<
-        string,
-        { volkeyword: string; num: number; title: string }[]
-      >();
-      const entries: CatalogueEntry[] = [];
-
-      for (const volume of volumes) {
-        const match = volume.title.match(this.yearVolumePattern);
-        if (match) {
-          const year = match[1];
-          const list = years.get(year) ?? [];
-          list.push({
-            volkeyword: volume.volkeyword,
-            num: Number(match[2]),
-            title: volume.title,
-          });
-          years.set(year, list);
-        } else {
-          entries.push({
-            novelPath: volume.volkeyword,
-            name: volume.title,
-            cover: volume.mainImage?.asset?.url ?? defaultCover,
-            members: [volume.volkeyword],
-            releaseDate: '',
-          });
-        }
-      }
-
-      for (const [year, list] of Array.from(years)) {
-        list.sort((a, b) => a.num - b.num);
-        const latest = list[list.length - 1];
-        const latestVolume = volumes.find(
-          v => v.volkeyword === latest.volkeyword,
-        );
-        entries.push({
-          novelPath: `series/year-${year}`,
-          name: `Classroom of the Elite: Year ${year}`,
-          cover: latestVolume?.mainImage?.asset?.url ?? defaultCover,
-          members: list.map(v => v.volkeyword),
-          releaseDate: '',
-        });
-      }
-
-      // Release dates aren't on the homepage listing, only on each volume
-      // page — fetch just the newest member of each entry to sort "latest".
-      await Promise.all(
-        entries.map(async entry => {
-          const newest = entry.members[entry.members.length - 1];
-          const vol = await this.fetchPageData<VolumePageProps>(newest);
-          entry.releaseDate = vol?.vol?.releaseDate ?? '';
-        }),
-      );
-
-      for (const entry of entries) {
-        const newest = entry.members[entry.members.length - 1];
-        this.novelUrlCache.set(entry.novelPath, `${this.site}${newest}`);
-      }
-
-      return entries;
+      return volumes.map(volume => ({
+        volkeyword: volume.volkeyword,
+        name: this.displayName(volume.title),
+        cover: volume.mainImage?.asset?.url ?? defaultCover,
+        releaseDate: '',
+      }));
     })();
 
     try {
@@ -182,15 +135,27 @@ class AnimeAnyway implements Plugin.PluginBase {
     if (pageNo > 1) return [];
 
     const catalogue = await this.getCatalogue();
-    const ordered = showLatestNovels
-      ? [...catalogue].sort((a, b) =>
-          b.releaseDate.localeCompare(a.releaseDate),
-        )
-      : catalogue;
+    let ordered = catalogue;
+
+    if (showLatestNovels) {
+      // Release dates aren't on the homepage listing, only on each volume
+      // page — the catalogue is small, so fetch them all to sort "latest".
+      await Promise.all(
+        catalogue.map(async entry => {
+          const vol = await this.fetchPageData<VolumePageProps>(
+            entry.volkeyword,
+          );
+          entry.releaseDate = vol?.vol?.releaseDate ?? '';
+        }),
+      );
+      ordered = [...catalogue].sort((a, b) =>
+        b.releaseDate.localeCompare(a.releaseDate),
+      );
+    }
 
     return ordered.map(entry => ({
       name: entry.name,
-      path: entry.novelPath,
+      path: entry.volkeyword,
       cover: entry.cover,
     }));
   }
@@ -231,7 +196,7 @@ class AnimeAnyway implements Plugin.PluginBase {
       .sort((a, b) => b.score - a.score)
       .map(({ entry }) => ({
         name: entry.name,
-        path: entry.novelPath,
+        path: entry.volkeyword,
         cover: entry.cover,
       }));
   }
@@ -299,44 +264,6 @@ class AnimeAnyway implements Plugin.PluginBase {
       chapters: [],
     };
 
-    if (novelPath.startsWith('series/year-')) {
-      const year = novelPath.replace('series/year-', '');
-      const catalogue = await this.getCatalogue();
-      const entry = catalogue.find(e => e.novelPath === novelPath);
-      if (!entry) {
-        novel.summary = 'This series is not available on Anime Anyway.';
-        return novel;
-      }
-
-      novel.name = entry.name;
-      novel.cover = entry.cover;
-
-      const chapters: Plugin.ChapterItem[] = [];
-      for (const volkeyword of entry.members) {
-        const data = await this.fetchPageData<VolumePageProps>(volkeyword);
-        const vol = data?.vol;
-        if (!vol) continue;
-
-        if (volkeyword === entry.members[entry.members.length - 1]) {
-          novel.summary = this.plainTextFromPortableText(vol.synopsis);
-        }
-
-        const volumeChapters = (vol.chapters ?? []).map((chapter, index) => ({
-          name: chapter.title,
-          path: `${volkeyword}/${chapter.chkeyword}`,
-          chapterNumber: chapters.length + index + 1,
-          page: vol.title,
-        }));
-        chapters.push(...volumeChapters);
-      }
-
-      novel.chapters = chapters;
-      if (!novel.summary) {
-        novel.summary = `Fan-translated continuation covering Year ${year} of Classroom of the Elite.`;
-      }
-      return novel;
-    }
-
     const data = await this.fetchPageData<VolumePageProps>(novelPath);
     const vol = data?.vol;
     if (!vol) {
@@ -344,7 +271,7 @@ class AnimeAnyway implements Plugin.PluginBase {
       return novel;
     }
 
-    novel.name = vol.title;
+    novel.name = this.displayName(vol.title);
     novel.cover = vol.mainImage?.asset?.url ?? defaultCover;
     novel.summary = this.plainTextFromPortableText(vol.synopsis);
     novel.chapters = (vol.chapters ?? []).map((chapter, index) => ({
@@ -366,14 +293,7 @@ class AnimeAnyway implements Plugin.PluginBase {
     return html || '<p>This chapter appears to be empty.</p>';
   }
 
-  resolveUrl = (path: string) => {
-    if (path.startsWith('series/year-')) {
-      // No single page represents an entire grouped year — point at the
-      // newest member volume's real URL, cached when the catalogue was built.
-      return this.novelUrlCache.get(path) ?? this.site;
-    }
-    return `${this.site}${path}`;
-  };
+  resolveUrl = (path: string) => `${this.site}${path}`;
 }
 
 export default new AnimeAnyway();