@itsmrtr/bunkoshelf 1.3.2 → 1.4.0

package/dist/src/components/stats/ReaderPanel.tsx

@@ -66,21 +66,6 @@ export default async function ReaderStatsPanel({
   const monthlyReads = data?.monthlyReads ?? [];
   const allReadDates = data?.allReadDates ?? [];
 
-  const readDaySet = new Set(dailyReading.map(({ date }) => date));
-  let currentDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  let streak = 0;
-  while (true) {
-    const y = currentDate.getFullYear();
-    const m = String(currentDate.getMonth() + 1).padStart(2, "0");
-    const d = String(currentDate.getDate()).padStart(2, "0");
-    if (readDaySet.has(`${y}-${m}-${d}`)) {
-      streak++;
-      currentDate.setDate(currentDate.getDate() - 1);
-    } else {
-      break;
-    }
-  }
-
   let lastRead = "—";
   if (dailyReading.length > 0) {
     lastRead = formatLoggedDate(dailyReading[0].date, lang, thisYear);
@@ -130,7 +115,7 @@ export default async function ReaderStatsPanel({
     <section className={`grid grid-cols-2 ${mdCols} w-full gap-4`}>
       <TileStreak
         title={stats.streak as string}
-        streak={streak}
+        dailyReadingDates={dailyReading.map(({ date }) => date)}
         daysLabel={stats.days as string}
         bgColor={bgColor}
         textColor={textColor}

package/dist/src/components/stats/TileStreak.tsx

@@ -1,12 +1,45 @@
+"use client";
+
 type TileStreakProps = {
   title: string;
-  streak: number;
+  dailyReadingDates: string[];
   daysLabel: string;
   bgColor: string;
   textColor: string;
 };
 
-export default function TileStreak({ title, streak, daysLabel, bgColor, textColor }: TileStreakProps) {
+function formatLocalDate(date: Date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+
+  return `${year}-${month}-${day}`;
+}
+
+function getCurrentReadingStreak(dailyReadingDates: string[]) {
+  const readDaySet = new Set(dailyReadingDates);
+  const currentDate = new Date();
+  currentDate.setHours(0, 0, 0, 0);
+
+  let streak = 0;
+
+  while (readDaySet.has(formatLocalDate(currentDate))) {
+    streak++;
+    currentDate.setDate(currentDate.getDate() - 1);
+  }
+
+  return streak;
+}
+
+export default function TileStreak({
+  title,
+  dailyReadingDates,
+  daysLabel,
+  bgColor,
+  textColor,
+}: TileStreakProps) {
+  const streak = getCurrentReadingStreak(dailyReadingDates);
+
   return (
     <div className={`h-[110px] rounded-lg ${bgColor} p-4 2xl:px-4 2xl:pt-4 2xl:pb-5 flex flex-col justify-between`}>
       <span className={`${textColor} text-sm uppercase`}>{title}</span>

package/dist/src/components/stats/TopGenres.tsx

@@ -24,9 +24,12 @@ export default function TopGenres({
   bgColor,
   textColor,
 }: TopGenresProps) {
+  const [isMounted, setIsMounted] = useState(false);
   const [data, setData] = useState<GenreStatEntry[]>([]);
 
   useEffect(() => {
+    setIsMounted(true);
+
     async function fetchGenres() {
       try {
         const result = await getGenresStats();
@@ -49,40 +52,42 @@ export default function TopGenres({
     >
       <h3 className="text-base mb-4">{stats.ttGenres as string}</h3>
       <div className="w-full h-72">
-        <ResponsiveContainer width="100%" height="100%">
-          <RadarChart data={data}>
-            <PolarGrid stroke="#333" />
-            <PolarAngleAxis
-              dataKey="genre"
-              tick={{ fill: "currentColor", fontSize: 12 }}
-            />
-            <PolarRadiusAxis
-              tick={{ fill: "currentColor", fontSize: 10 }}
-              stroke="#444"
-              axisLine={false}
-              tickLine={false}
-            />
-            <Tooltip
-              contentStyle={{
-                backgroundColor: "#151515",
-                border: "none",
-                borderRadius: "8px",
-                fontSize: "0.875rem",
-              }}
-              labelStyle={{ color: "#e5e0dc" }}
-              formatter={(value) => [
-                String(value ?? 0),
-                stats.tooltip as string,
-              ]}
-            />
-            <Radar
-              name="Lecturas"
-              dataKey="user"
-              fill="#8a6fdc"
-              fillOpacity={0.6}
-            />
-          </RadarChart>
-        </ResponsiveContainer>
+        {isMounted ? (
+          <ResponsiveContainer width="100%" height="100%">
+            <RadarChart data={data}>
+              <PolarGrid stroke="#333" />
+              <PolarAngleAxis
+                dataKey="genre"
+                tick={{ fill: "currentColor", fontSize: 12 }}
+              />
+              <PolarRadiusAxis
+                tick={{ fill: "currentColor", fontSize: 10 }}
+                stroke="#444"
+                axisLine={false}
+                tickLine={false}
+              />
+              <Tooltip
+                contentStyle={{
+                  backgroundColor: "#151515",
+                  border: "none",
+                  borderRadius: "8px",
+                  fontSize: "0.875rem",
+                }}
+                labelStyle={{ color: "#e5e0dc" }}
+                formatter={(value) => [
+                  String(value ?? 0),
+                  stats.tooltip as string,
+                ]}
+              />
+              <Radar
+                name="Lecturas"
+                dataKey="user"
+                fill="#8a6fdc"
+                fillOpacity={0.6}
+              />
+            </RadarChart>
+          </ResponsiveContainer>
+        ) : null}
       </div>
     </div>
   );

package/dist/src/lib/db/library.ts

@@ -1,5 +1,9 @@
 import { cacheLife, cacheTag } from "next/cache";
-import type { LibraryScope } from "@/lib/librarySection";
+import {
+  getLibrarySection,
+  type LibraryScope,
+  type LibrarySection,
+} from "@/lib/librarySection";
 import { MANGA_LIBRARY_TAG } from "@/lib/mangaLibraryCache";
 import { query, queryOne } from "./query";
 
@@ -167,6 +171,41 @@ export interface PaginatedResult<T> {
   totalPages: number;
 }
 
+export interface CatalogLibraryVolume {
+  id: string;
+  slug: string;
+  section: LibrarySection;
+  title: string | null;
+  series: string | null;
+  number: number | null;
+  year: number | null;
+  writer: string | null;
+  publisher: string | null;
+  languageISO: string | null;
+  ageRating: string | null;
+  gtin: string | null;
+  isRead: boolean;
+  isFavorite: boolean;
+}
+
+export interface CatalogAuthorStats {
+  author: string | null;
+  works: number;
+  avgRating: number | null;
+  readCount: number;
+  hasManga: boolean;
+  hasOthers: boolean;
+  hasBooks: boolean;
+}
+
+export interface CatalogRelationStats {
+  name: string;
+  hasManga: boolean;
+  hasOthers: boolean;
+  hasBooks: boolean;
+  total: number;
+}
+
 interface VolumeRow {
   volume_id: string;
   volume_slug: string;
@@ -533,6 +572,268 @@ function parseCount(value: string | number): number {
   return typeof value === "number" ? value : Number(value);
 }
 
+export async function listPagedCatalogLibraryVolumes(
+  options?: PagedQueryOptions & { userId?: string | null }
+): Promise<PaginatedResult<CatalogLibraryVolume>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM manga_volumes mv
+      `
+    ),
+    query<{
+      id: string;
+      slug: string;
+      title: string | null;
+      series: string | null;
+      number: number | null;
+      year: number | null;
+      writer: string | null;
+      publisher: string | null;
+      language_iso: string | null;
+      age_rating: string | null;
+      gtin: string | null;
+      manga_style: string | null;
+      is_read: boolean | null;
+      is_favorite: boolean | null;
+    }>(
+      `
+        SELECT
+          mv.id,
+          mv.slug,
+          vm.title,
+          ms.title AS series,
+          vm.number,
+          vm.year,
+          vm.writer,
+          vm.publisher,
+          vm.language_iso,
+          vm.age_rating,
+          vm.gtin,
+          vm.manga_style,
+          utv.is_read,
+          utv.is_favorite
+        FROM manga_volumes mv
+        INNER JOIN manga_series ms ON ms.id = mv.series_id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        LEFT JOIN user_to_volumes utv
+          ON utv.volume_id = mv.id
+         AND utv.user_id = $1
+        ORDER BY ms.sort_title ASC, mv.sort_title ASC, mv.id ASC
+        LIMIT $2
+        OFFSET $3
+      `,
+      [options?.userId ?? null, pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      id: row.id,
+      slug: row.slug,
+      section: getLibrarySection(row.manga_style),
+      title: row.title,
+      series: row.series,
+      number: row.number,
+      year: row.year,
+      writer: row.writer,
+      publisher: row.publisher,
+      languageISO: row.language_iso,
+      ageRating: row.age_rating,
+      gtin: row.gtin,
+      isRead: row.is_read === true,
+      isFavorite: row.is_favorite === true,
+    })),
+    total,
+    pagination
+  );
+}
+
+export async function listPagedCatalogAuthors(
+  options?: PagedQueryOptions & { userId?: string | null }
+): Promise<PaginatedResult<CatalogAuthorStats>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT vm.writer
+          FROM manga_volumes mv
+          LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+          GROUP BY vm.writer
+        ) AS authors
+      `
+    ),
+    query<{
+      author: string | null;
+      works: string | number;
+      avg_rating: number | null;
+      read_count: string | number;
+      has_manga: boolean | null;
+      has_others: boolean | null;
+    }>(
+      `
+        SELECT
+          vm.writer AS author,
+          COUNT(mv.id) AS works,
+          ROUND(AVG(utv.personal_rating)::numeric, 1)::float8 AS avg_rating,
+          COUNT(*) FILTER (WHERE utv.is_read = TRUE) AS read_count,
+          BOOL_OR(vm.manga_style IS DISTINCT FROM 'No') AS has_manga,
+          BOOL_OR(vm.manga_style = 'No') AS has_others
+        FROM manga_volumes mv
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        LEFT JOIN user_to_volumes utv
+          ON utv.volume_id = mv.id
+         AND utv.user_id = $1
+        GROUP BY vm.writer
+        ORDER BY COALESCE(vm.writer, '') ASC
+        LIMIT $2
+        OFFSET $3
+      `,
+      [options?.userId ?? null, pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      author: row.author,
+      works: parseCount(row.works),
+      avgRating: row.avg_rating,
+      readCount: parseCount(row.read_count),
+      hasManga: row.has_manga === true,
+      hasOthers: row.has_others === true,
+      hasBooks: false,
+    })),
+    total,
+    pagination
+  );
+}
+
+export async function listPagedCatalogGenres(
+  options?: PagedQueryOptions
+): Promise<PaginatedResult<CatalogRelationStats>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT g.id
+          FROM genres g
+          INNER JOIN volume_to_genres vtg ON vtg.genre_id = g.id
+          INNER JOIN manga_volumes mv ON mv.id = vtg.volume_id
+          GROUP BY g.id
+        ) AS genres
+      `
+    ),
+    query<{
+      name: string;
+      has_manga: boolean | null;
+      has_others: boolean | null;
+      total: string | number;
+    }>(
+      `
+        SELECT
+          g.name,
+          BOOL_OR(vm.manga_style IS DISTINCT FROM 'No') AS has_manga,
+          BOOL_OR(vm.manga_style = 'No') AS has_others,
+          COUNT(mv.id) AS total
+        FROM genres g
+        INNER JOIN volume_to_genres vtg ON vtg.genre_id = g.id
+        INNER JOIN manga_volumes mv ON mv.id = vtg.volume_id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        GROUP BY g.id, g.name
+        ORDER BY g.name ASC
+        LIMIT $1
+        OFFSET $2
+      `,
+      [pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      name: row.name,
+      hasManga: row.has_manga === true,
+      hasOthers: row.has_others === true,
+      hasBooks: false,
+      total: parseCount(row.total),
+    })),
+    total,
+    pagination
+  );
+}
+
+export async function listPagedCatalogTags(
+  options?: PagedQueryOptions
+): Promise<PaginatedResult<CatalogRelationStats>> {
+  const pagination = buildPagination(options);
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string | number }>(
+      `
+        SELECT COUNT(*) AS total
+        FROM (
+          SELECT t.id
+          FROM tags t
+          INNER JOIN volume_to_tags vtt ON vtt.tag_id = t.id
+          INNER JOIN manga_volumes mv ON mv.id = vtt.volume_id
+          GROUP BY t.id
+        ) AS tags
+      `
+    ),
+    query<{
+      name: string;
+      has_manga: boolean | null;
+      has_others: boolean | null;
+      total: string | number;
+    }>(
+      `
+        SELECT
+          t.name,
+          BOOL_OR(vm.manga_style IS DISTINCT FROM 'No') AS has_manga,
+          BOOL_OR(vm.manga_style = 'No') AS has_others,
+          COUNT(mv.id) AS total
+        FROM tags t
+        INNER JOIN volume_to_tags vtt ON vtt.tag_id = t.id
+        INNER JOIN manga_volumes mv ON mv.id = vtt.volume_id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        GROUP BY t.id, t.name
+        ORDER BY t.name ASC
+        LIMIT $1
+        OFFSET $2
+      `,
+      [pagination.pageSize, pagination.offset]
+    ),
+  ]);
+
+  const total = parseCount(countRow?.total ?? 0);
+
+  return mapPaginatedResult(
+    rows.map((row) => ({
+      name: row.name,
+      hasManga: row.has_manga === true,
+      hasOthers: row.has_others === true,
+      hasBooks: false,
+      total: parseCount(row.total),
+    })),
+    total,
+    pagination
+  );
+}
+
 async function listLibraryFiltersRaw(scope?: LibraryScope): Promise<{
   genres: GenreFilter[];
   tags: TagFilter[];

package/dist/src/lib/i18n/Dictionary.ts

@@ -20,6 +20,7 @@ const dictionaries: Record<Locale, () => Promise<Record<string, DictionarySectio
       import("./dictionaries/en/toast.json").then((m) => m.default),
       import("./dictionaries/en/search.json").then((m) => m.default),
       import("./dictionaries/en/filters.json").then((m) => m.default),
+      import("./dictionaries/en/catalog.json").then((m) => m.default),
       import("./dictionaries/en/push.json").then((m) => m.default),
       import("./dictionaries/en/months.json").then((m) => m.default),
       import("./dictionaries/en/stats.json").then((m) => m.default),
@@ -42,6 +43,7 @@ const dictionaries: Record<Locale, () => Promise<Record<string, DictionarySectio
       import("./dictionaries/es/toast.json").then((m) => m.default),
       import("./dictionaries/es/search.json").then((m) => m.default),
       import("./dictionaries/es/filters.json").then((m) => m.default),
+      import("./dictionaries/es/catalog.json").then((m) => m.default),
       import("./dictionaries/es/push.json").then((m) => m.default),
       import("./dictionaries/es/months.json").then((m) => m.default),
       import("./dictionaries/es/stats.json").then((m) => m.default),

package/dist/src/lib/i18n/dictionaries/en/catalog.json

@@ -0,0 +1,32 @@
+{
+  "catalog": {
+    "title": "Catalog",
+    "library": "Library",
+    "authors": "Authors",
+    "genres": "Genres",
+    "tags": "Tags",
+    "genreColumn": "Genre",
+    "tagColumn": "Tag",
+    "mangaColumn": "Manga",
+    "othersColumn": "Comic/Others",
+    "booksColumn": "Books",
+    "totalColumn": "Total",
+    "authorColumn": "Author",
+    "worksColumn": "Works",
+    "avgRatingColumn": "Avg",
+    "progressColumn": "Progress",
+    "libraryColumn": "Library",
+    "titleColumn": "Title",
+    "seriesColumn": "Series",
+    "numberColumn": "Number",
+    "yearColumn": "Year",
+    "writerColumn": "Writer",
+    "publisherColumn": "Publisher",
+    "statusColumn": "Stat",
+    "languageColumn": "Language",
+    "ageRatingColumn": "Age",
+    "gtinColumn": "ISBN",
+    "favoriteColumn": "Fav",
+    "actionsColumn": "Act"
+  }
+}

package/dist/src/lib/i18n/dictionaries/en/sidebar.json

@@ -6,6 +6,7 @@
     "others": "Comic/Others",
     "books": "Books",
     "favorites": "Favorites",
+    "catalog": "Catalog",
     "profile": "Profile"
   }
 }

package/dist/src/lib/i18n/dictionaries/es/catalog.json

@@ -0,0 +1,32 @@
+{
+  "catalog": {
+    "title": "Catálogo",
+    "library": "Biblioteca",
+    "authors": "Autores",
+    "genres": "Géneros",
+    "tags": "Etiquetas",
+    "genreColumn": "Género",
+    "tagColumn": "Etiqueta",
+    "mangaColumn": "Manga",
+    "othersColumn": "Cómic/Otros",
+    "booksColumn": "Libros",
+    "totalColumn": "Total",
+    "authorColumn": "Autor",
+    "worksColumn": "Obras",
+    "avgRatingColumn": "Prom",
+    "progressColumn": "Progreso",
+    "libraryColumn": "Biblioteca",
+    "titleColumn": "Título",
+    "seriesColumn": "Serie",
+    "numberColumn": "Número",
+    "yearColumn": "Año",
+    "writerColumn": "Autor",
+    "publisherColumn": "Editorial",
+    "statusColumn": "Estd",
+    "languageColumn": "Idioma",
+    "ageRatingColumn": "Clasf",
+    "gtinColumn": "ISBN",
+    "favoriteColumn": "Fav",
+    "actionsColumn": "Acc"
+  }
+}

package/dist/src/lib/i18n/dictionaries/es/sidebar.json

@@ -6,6 +6,7 @@
     "others": "Cómic/Otros",
     "books": "Libros",
     "favorites": "Favoritos",
+    "catalog": "Catálogo",
     "profile": "Perfil"
   }
 }

package/dist/src/lib/nav/catalogNav.ts

@@ -0,0 +1,54 @@
+import type { LucideIcon } from "lucide-react";
+import {
+  DramaIcon,
+  LibraryBigIcon,
+  TagsIcon,
+  UserRoundPenIcon,
+} from "lucide-react";
+import type { Dictionary } from "@/lib/types";
+
+export interface CatalogNavLink {
+  label: string;
+  href: string;
+  icon: LucideIcon;
+  isActive: boolean;
+}
+
+interface GetCatalogNavLinksParams {
+  intl: Dictionary;
+  lang: string;
+  pathname: string;
+}
+
+export function getCatalogNavLinks({
+  intl,
+  lang,
+  pathname,
+}: GetCatalogNavLinksParams): CatalogNavLink[] {
+  return [
+    {
+      label: intl.catalog.library as string,
+      href: `/${lang}/catalog/library`,
+      icon: LibraryBigIcon,
+      isActive: pathname === `/${lang}/catalog/library`,
+    },
+    {
+      label: intl.catalog.authors as string,
+      href: `/${lang}/catalog/authors`,
+      icon: UserRoundPenIcon,
+      isActive: pathname === `/${lang}/catalog/authors`,
+    },
+    {
+      label: intl.catalog.genres as string,
+      href: `/${lang}/catalog/genres`,
+      icon: DramaIcon,
+      isActive: pathname === `/${lang}/catalog/genres`,
+    },
+    {
+      label: intl.catalog.tags as string,
+      href: `/${lang}/catalog/tags`,
+      icon: TagsIcon,
+      isActive: pathname === `/${lang}/catalog/tags`,
+    },
+  ];
+}