@itsmrtr/bunkoshelf 1.2.9 → 1.3.1

package/dist/src/components/search/SearchComp.tsx

@@ -118,8 +118,8 @@ export default function SearchComp({ lang, intl }: SearchCompProps) {
           {filteredResults.map((res) => {
             const isSeries = res.type === "series";
             const href = isSeries
-              ? `/${lang}/manga/${res.slug}`
-              : `/${lang}/manga/volume/${res.slug}`;
+              ? `/${lang}/${res.section}/${res.slug}`
+              : `/${lang}/${res.section}/volume/${res.slug}`;
 
             let genres = res.genres || "";
             let tags = res.tags || "";

package/dist/src/components/search/SearchModal.tsx

@@ -140,8 +140,8 @@ export default function SearchModal({ lang, intl }: SearchModalProps) {
           {filteredResults.map((res) => {
             const isSeries = res.type === "series";
             const href = isSeries
-              ? `/${lang}/manga/${res.slug}`
-              : `/${lang}/manga/volume/${res.slug}`;
+              ? `/${lang}/${res.section}/${res.slug}`
+              : `/${lang}/${res.section}/volume/${res.slug}`;
 
             let genres = res.genres || "";
             let tags = res.tags || "";

package/dist/src/components/ui/MangaCard.tsx

@@ -3,6 +3,7 @@
 import Link from "next/link";
 import Image from "next/image";
 import clsx from "clsx";
+import { useRef } from "react";
 import type { DictionarySection } from "@/lib/types";
 
 interface MangaCardProps {
@@ -38,6 +39,8 @@ export default function MangaCard({
 }: MangaCardProps) {
   const t = intl;
   const ratio = progressRatio ?? 0;
+  const touchStart = useRef<{ x: number; y: number } | null>(null);
+  const hasTouchMoved = useRef(false);
 
   const manga = t.manga as DictionarySection;
 
@@ -48,6 +51,40 @@ export default function MangaCard({
         "group flex flex-col overflow-hidden rounded-t-lg transition-all duration-300",
         isDragging ? "cursor-grabbing" : "cursor-pointer"
       )}
+      onTouchStart={(e) => {
+        const touch = e.touches[0];
+        if (!touch) return;
+        touchStart.current = { x: touch.clientX, y: touch.clientY };
+        hasTouchMoved.current = false;
+      }}
+      onTouchMove={(e) => {
+        const touch = e.touches[0];
+        const start = touchStart.current;
+        if (!touch || !start) return;
+
+        const deltaX = Math.abs(touch.clientX - start.x);
+        const deltaY = Math.abs(touch.clientY - start.y);
+
+        if (deltaX > 12 || deltaY > 12) {
+          hasTouchMoved.current = true;
+        }
+      }}
+      onTouchEnd={() => {
+        touchStart.current = null;
+        setTimeout(() => {
+          hasTouchMoved.current = false;
+        }, 0);
+      }}
+      onTouchCancel={() => {
+        touchStart.current = null;
+        hasTouchMoved.current = false;
+      }}
+      onClickCapture={(e) => {
+        if (isDragging || hasTouchMoved.current) {
+          e.preventDefault();
+          e.stopPropagation();
+        }
+      }}
     >
       <div className="relative aspect-[7/10.5] w-full flex-shrink-0">
         <Image

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

@@ -1,5 +1,6 @@
 import { createId } from "@paralleldrive/cuid2";
 import { execute, query, queryOne } from "./query";
+import { buildNaturalSortKey } from "@/lib/naturalSort";
 import type { ComicMetadata } from "@/lib/types";
 
 export interface IndexedSeries {
@@ -82,14 +83,16 @@ export async function upsertSeriesRecord(input: {
         id,
         slug,
         title,
+        sort_title,
         path,
         is_oneshot,
         mtime
       )
-      VALUES ($1, $2, $3, $4, $5, $6)
+      VALUES ($1, $2, $3, $4, $5, $6, $7)
       ON CONFLICT (slug)
       DO UPDATE SET
         title = EXCLUDED.title,
+        sort_title = EXCLUDED.sort_title,
         path = EXCLUDED.path,
         is_oneshot = EXCLUDED.is_oneshot,
         mtime = EXCLUDED.mtime,
@@ -100,6 +103,7 @@ export async function upsertSeriesRecord(input: {
       createId(),
       input.slug,
       input.title,
+      buildNaturalSortKey(input.title),
       input.path,
       input.isOneshot,
       input.mtime,
@@ -129,6 +133,7 @@ export async function upsertVolumeRecord(input: {
         id,
         slug,
         title,
+        sort_title,
         filename,
         full_path,
         size,
@@ -136,10 +141,11 @@ export async function upsertVolumeRecord(input: {
         cover_image,
         series_id
       )
-      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
       ON CONFLICT (slug)
       DO UPDATE SET
         title = EXCLUDED.title,
+        sort_title = EXCLUDED.sort_title,
         filename = EXCLUDED.filename,
         full_path = EXCLUDED.full_path,
         size = EXCLUDED.size,
@@ -153,6 +159,7 @@ export async function upsertVolumeRecord(input: {
       createId(),
       input.slug,
       input.title,
+      buildNaturalSortKey(input.title),
       input.filename,
       input.fullPath,
       input.size,
@@ -514,7 +521,7 @@ export async function findSeriesWithVolumesById(
       SELECT id, slug, title, filename, full_path, size, cover_image, metadata_id, series_id
       FROM manga_volumes
       WHERE series_id = $1
-      ORDER BY title ASC
+      ORDER BY sort_title ASC, id ASC
     `,
     [seriesId]
   );

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

@@ -134,11 +134,39 @@ interface FindSeriesOptions {
   scope?: LibraryScope;
 }
 
+export interface SeriesVolumeAggregate {
+  communityRating: number | null;
+  format: string | null;
+  id: string;
+  writer: string | null;
+  penciller: string | null;
+  inker: string | null;
+  colorist: string | null;
+  letterer: string | null;
+  coverArtist: string | null;
+  editor: string | null;
+  publisher: string | null;
+  imprint: string | null;
+}
+
 interface FindVolumeOptions extends SharedVolumeQueryOptions {
   slug: string;
   userId?: string | null;
 }
 
+interface PagedQueryOptions {
+  page?: number;
+  pageSize?: number;
+}
+
+export interface PaginatedResult<T> {
+  items: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+}
+
 interface VolumeRow {
   volume_id: string;
   volume_slug: string;
@@ -476,6 +504,35 @@ function buildLibraryFilterScopeConditions(
   return "";
 }
 
+function buildPagination(options?: PagedQueryOptions) {
+  const pageSize = Math.max(1, options?.pageSize ?? 1);
+  const page = Math.max(1, options?.page ?? 1);
+
+  return {
+    page,
+    pageSize,
+    offset: (page - 1) * pageSize,
+  };
+}
+
+function mapPaginatedResult<T>(
+  items: T[],
+  total: number,
+  pagination: ReturnType<typeof buildPagination>
+): PaginatedResult<T> {
+  return {
+    items,
+    total,
+    page: pagination.page,
+    pageSize: pagination.pageSize,
+    totalPages: Math.ceil(total / pagination.pageSize),
+  };
+}
+
+function parseCount(value: string | number): number {
+  return typeof value === "number" ? value : Number(value);
+}
+
 async function listLibraryFiltersRaw(scope?: LibraryScope): Promise<{
   genres: GenreFilter[];
   tags: TagFilter[];
@@ -633,7 +690,7 @@ async function listVolumesRaw(
       LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
       ${progressJoin}
       ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""}
-      ORDER BY ms.title ASC, mv.title ASC
+      ORDER BY ms.sort_title ASC, mv.sort_title ASC, mv.id ASC
     `,
     params
   );
@@ -672,6 +729,174 @@ export async function listVolumes(
   });
 }
 
+async function listPagedVolumeIdsRaw(
+  options?: VolumeQueryOptions & PagedQueryOptions
+): Promise<PaginatedResult<string>> {
+  const pagination = buildPagination(options);
+  const countParams: unknown[] = [];
+  const countConditions = buildVolumeFilterSql(
+    {
+      genreNames: options?.genreNames,
+      tagNames: options?.tagNames,
+      seriesIds: options?.seriesIds,
+      volumeIds: options?.volumeIds,
+      userId: options?.userId,
+      onlyUnreadForUser: options?.onlyUnreadForUser,
+      scope: options?.scope,
+    },
+    countParams
+  );
+  const rowsParams = [...countParams];
+
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string }>(
+      `
+        SELECT COUNT(*)::text AS total
+        FROM manga_volumes mv
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+      `,
+      countParams
+    ),
+    query<{ id: string }>(
+      `
+        SELECT mv.id
+        FROM manga_volumes mv
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+        ORDER BY mv.sort_title ASC, mv.id ASC
+        LIMIT $${rowsParams.push(pagination.pageSize)}
+        OFFSET $${rowsParams.push(pagination.offset)}
+      `,
+      rowsParams
+    ),
+  ]);
+
+  return mapPaginatedResult(
+    rows.map((row) => row.id),
+    parseCount(countRow?.total ?? 0),
+    pagination
+  );
+}
+
+async function listPagedVolumeIdsCached(
+  options: SharedVolumeQueryOptions & PagedQueryOptions = {}
+) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listPagedVolumeIdsRaw(options);
+}
+
+export async function listPagedVolumes(
+  options?: VolumeQueryOptions &
+    PagedQueryOptions & {
+      includeGenres?: boolean;
+      includeTags?: boolean;
+    }
+): Promise<PaginatedResult<LibraryVolume>> {
+  const pagedIds = options?.userId || options?.onlyUnreadForUser
+    ? await listPagedVolumeIdsRaw(options)
+    : await listPagedVolumeIdsCached({
+        includeGenres: options?.includeGenres,
+        includeTags: options?.includeTags,
+        genreNames: options?.genreNames,
+        tagNames: options?.tagNames,
+        seriesIds: options?.seriesIds,
+        volumeIds: options?.volumeIds,
+        scope: options?.scope,
+        page: options?.page,
+        pageSize: options?.pageSize,
+      });
+
+  if (pagedIds.items.length === 0) {
+    return {
+      ...pagedIds,
+      items: [],
+    };
+  }
+
+  const volumes = await listVolumes({
+    volumeIds: pagedIds.items,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    scope: options?.scope,
+  });
+
+  const volumeMap = new Map(volumes.map((volume) => [volume.id, volume]));
+
+  return {
+    ...pagedIds,
+    items: pagedIds.items
+      .map((id) => volumeMap.get(id))
+      .filter((volume): volume is LibraryVolume => Boolean(volume)),
+  };
+}
+
+export async function listVolumeProgressByIds(
+  userId: string,
+  volumeIds: string[]
+): Promise<Record<string, UserVolumeProgress>> {
+  if (!userId || volumeIds.length === 0) {
+    return {};
+  }
+
+  const rows = await query<{
+    id: string;
+    user_id: string;
+    volume_id: string;
+    is_read: boolean;
+    is_favorite: boolean;
+    personal_rating: number | null;
+    last_page: number | null;
+    total_pages: number | null;
+    last_read_at: Date | null;
+    first_read: string | null;
+    created_at: Date;
+    updated_at: Date;
+  }>(
+    `
+      SELECT
+        id,
+        user_id,
+        volume_id,
+        is_read,
+        is_favorite,
+        personal_rating,
+        last_page,
+        total_pages,
+        last_read_at,
+        first_read,
+        created_at,
+        updated_at
+      FROM user_to_volumes
+      WHERE user_id = $1
+        AND volume_id = ANY($2::text[])
+    `,
+    [userId, volumeIds]
+  );
+
+  return rows.reduce<Record<string, UserVolumeProgress>>((acc, row) => {
+    acc[row.volume_id] = {
+      id: row.id,
+      userId: row.user_id,
+      volumeId: row.volume_id,
+      isRead: row.is_read,
+      isFavorite: row.is_favorite,
+      personalRating: row.personal_rating,
+      lastPage: row.last_page,
+      totalPages: row.total_pages,
+      lastReadAt: row.last_read_at,
+      firstRead: row.first_read,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+    return acc;
+  }, {});
+}
+
 async function listSeriesWithVolumesRaw(
   options?: SharedSeriesQueryOptions
 ): Promise<LibrarySeriesWithVolumes[]> {
@@ -728,6 +953,119 @@ export async function listSeriesWithVolumes(
   });
 }
 
+async function listPagedSeriesIdsRaw(
+  options?: SharedSeriesQueryOptions &
+    PagedQueryOptions & {
+      excludeOneshots?: boolean;
+    }
+): Promise<PaginatedResult<string>> {
+  const pagination = buildPagination(options);
+  const countParams: unknown[] = [];
+  const countConditions = buildVolumeFilterSql(
+    {
+      genreNames: options?.genreNames,
+      tagNames: options?.tagNames,
+      seriesIds: options?.seriesIds,
+      scope: options?.scope,
+    },
+    countParams
+  );
+
+  if (options?.excludeOneshots) {
+    countConditions.push("ms.is_oneshot = FALSE");
+  }
+
+  const rowsParams = [...countParams];
+  const [countRow, rows] = await Promise.all([
+    queryOne<{ total: string }>(
+      `
+        SELECT COUNT(DISTINCT ms.id)::text AS total
+        FROM manga_series ms
+        INNER JOIN manga_volumes mv ON mv.series_id = ms.id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+      `,
+      countParams
+    ),
+    query<{ id: string }>(
+      `
+        SELECT ms.id
+        FROM manga_series ms
+        INNER JOIN manga_volumes mv ON mv.series_id = ms.id
+        LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+        ${countConditions.length > 0 ? `WHERE ${countConditions.join(" AND ")}` : ""}
+        GROUP BY ms.id, ms.sort_title
+        ORDER BY ms.sort_title ASC, ms.id ASC
+        LIMIT $${rowsParams.push(pagination.pageSize)}
+        OFFSET $${rowsParams.push(pagination.offset)}
+      `,
+      rowsParams
+    ),
+  ]);
+
+  return mapPaginatedResult(
+    rows.map((row) => row.id),
+    parseCount(countRow?.total ?? 0),
+    pagination
+  );
+}
+
+async function listPagedSeriesIdsCached(
+  options: SharedSeriesQueryOptions &
+    PagedQueryOptions & {
+      excludeOneshots?: boolean;
+    } = {}
+) {
+  "use cache";
+
+  cacheLife("max");
+  cacheTag(MANGA_LIBRARY_TAG);
+
+  return listPagedSeriesIdsRaw(options);
+}
+
+export async function listPagedSeriesWithVolumes(
+  options?: SharedSeriesQueryOptions &
+    PagedQueryOptions & {
+      excludeOneshots?: boolean;
+    }
+): Promise<PaginatedResult<LibrarySeriesWithVolumes>> {
+  const pagedIds = await listPagedSeriesIdsCached({
+    genreNames: options?.genreNames,
+    tagNames: options?.tagNames,
+    seriesIds: options?.seriesIds,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    scope: options?.scope,
+    page: options?.page,
+    pageSize: options?.pageSize,
+    excludeOneshots: options?.excludeOneshots,
+  });
+
+  if (pagedIds.items.length === 0) {
+    return {
+      ...pagedIds,
+      items: [],
+    };
+  }
+
+  const series = await listSeriesWithVolumes({
+    seriesIds: pagedIds.items,
+    includeGenres: options?.includeGenres,
+    includeTags: options?.includeTags,
+    scope: options?.scope,
+  });
+
+  const seriesMap = new Map(series.map((entry) => [entry.id, entry]));
+
+  return {
+    ...pagedIds,
+    items: pagedIds.items
+      .map((id) => seriesMap.get(id))
+      .filter((entry): entry is LibrarySeriesWithVolumes => Boolean(entry)),
+  };
+}
+
 export async function listSeries(
   options?: { scope?: LibraryScope }
 ): Promise<LibrarySeries[]> {
@@ -742,6 +1080,7 @@ export async function listSeries(
   return query<{
     id: string;
     slug: string;
+    sort_title: string;
     title: string;
     path: string;
     is_oneshot: boolean;
@@ -754,6 +1093,7 @@ export async function listSeries(
       SELECT DISTINCT
         ms.id,
         ms.slug,
+        ms.sort_title,
         ms.title,
         ms.path,
         ms.is_oneshot,
@@ -765,7 +1105,7 @@ export async function listSeries(
       INNER JOIN manga_volumes mv ON mv.series_id = ms.id
       LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
       ${conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : ""}
-      ORDER BY title ASC
+      ORDER BY ms.sort_title ASC, ms.id ASC
     `,
     params
   ).then((rows) =>
@@ -783,6 +1123,110 @@ export async function listSeries(
   );
 }
 
+export async function findSeriesBySlugBasic(
+  slug: string
+): Promise<LibrarySeries | null> {
+  const row = await queryOne<{
+    id: string;
+    slug: string;
+    title: string;
+    path: string;
+    is_oneshot: boolean;
+    mtime: Date;
+    status: string;
+    created_at: Date;
+    updated_at: Date;
+  }>(
+    `
+      SELECT
+        id,
+        slug,
+        title,
+        path,
+        is_oneshot,
+        mtime,
+        status,
+        created_at,
+        updated_at
+      FROM manga_series
+      WHERE slug = $1
+      LIMIT 1
+    `,
+    [slug]
+  );
+
+  if (!row) {
+    return null;
+  }
+
+  return {
+    id: row.id,
+    slug: row.slug,
+    title: row.title,
+    path: row.path,
+    isOneshot: row.is_oneshot,
+    mtime: row.mtime,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export async function listSeriesVolumeAggregates(
+  seriesId: string
+): Promise<SeriesVolumeAggregate[]> {
+  return query<{
+    volume_id: string;
+    community_rating: number | null;
+    writer: string | null;
+    penciller: string | null;
+    inker: string | null;
+    colorist: string | null;
+    letterer: string | null;
+    cover_artist: string | null;
+    editor: string | null;
+    publisher: string | null;
+    imprint: string | null;
+    format: string | null;
+  }>(
+    `
+      SELECT
+        mv.id AS volume_id,
+        vm.community_rating,
+        vm.writer,
+        vm.penciller,
+        vm.inker,
+        vm.colorist,
+        vm.letterer,
+        vm.cover_artist,
+        vm.editor,
+        vm.publisher,
+        vm.imprint,
+        vm.format
+      FROM manga_volumes mv
+      LEFT JOIN volume_metadata vm ON vm.id = mv.metadata_id
+      WHERE mv.series_id = $1
+      ORDER BY mv.sort_title ASC, mv.id ASC
+    `,
+    [seriesId]
+  ).then((rows) =>
+    rows.map((row) => ({
+      id: row.volume_id,
+      communityRating: row.community_rating,
+      writer: row.writer,
+      penciller: row.penciller,
+      inker: row.inker,
+      colorist: row.colorist,
+      letterer: row.letterer,
+      coverArtist: row.cover_artist,
+      editor: row.editor,
+      publisher: row.publisher,
+      imprint: row.imprint,
+      format: row.format,
+    }))
+  );
+}
+
 async function findSeriesBySlugRaw(
   options: FindSeriesOptions
 ): Promise<LibrarySeriesWithVolumes | null> {