@itsmrtr/bunkoshelf 1.6.0 → 1.7.0

package/dist/src/lib/client/offlineLibrary.ts

@@ -0,0 +1,427 @@
+"use client";
+
+import type { LibrarySection } from "@/lib/librarySection";
+
+const DB_NAME = "bunko-pwa";
+const DB_VERSION = 1;
+const VOLUMES = "volumes";
+const PAGES = "pages";
+const DOWNLOADS = "downloads";
+const OPERATIONS = "operations";
+
+export type OfflineDownloadStatus = "queued" | "downloading" | "ready" | "error";
+export type OfflineOperationKind = "favorite" | "read" | "progress" | "series-favorite";
+
+export interface OfflineVolume {
+  id: string;
+  userId: string;
+  slug: string;
+  section: LibrarySection;
+  title: string;
+  seriesId: string;
+  seriesSlug: string;
+  seriesTitle: string;
+  isOneshot: boolean;
+  mangaStyle: string | null;
+  metadata: Record<string, unknown>;
+  coverUrl: string | null;
+  downloadedAt?: string;
+  isRead: boolean;
+  isFavorite: boolean;
+  lastPage: number;
+  totalPages: number;
+}
+
+export interface OfflineDownload {
+  key: string;
+  userId: string;
+  volumeId: string;
+  status: OfflineDownloadStatus;
+  completedPages: number;
+  totalPages: number;
+  size: number;
+  error?: string;
+  updatedAt: string;
+}
+
+interface OfflinePage {
+  key: string;
+  userId: string;
+  volumeId: string;
+  index: number;
+  blob: Blob;
+}
+
+export interface OfflineOperation {
+  id: string;
+  userId: string;
+  kind: OfflineOperationKind;
+  payload: Record<string, unknown>;
+  createdAt: string;
+}
+
+interface OfflineVolumeManifest {
+  id: string;
+  slug: string;
+  section: LibrarySection;
+  title: string;
+  series: {
+    id: string;
+    slug: string;
+    title: string;
+    isOneshot: boolean;
+  };
+  mangaStyle: string | null;
+  metadata: Record<string, unknown>;
+  coverUrl: string | null;
+  isRead: boolean;
+  isFavorite: boolean;
+  lastPage: number;
+  totalPages: number;
+}
+
+function request<T>(req: IDBRequest<T>) {
+  return new Promise<T>((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+function transactionDone(tx: IDBTransaction) {
+  return new Promise<void>((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error);
+  });
+}
+
+function volumeKey(userId: string, volumeId: string) {
+  return `${userId}:${volumeId}`;
+}
+
+function pageKey(userId: string, volumeId: string, index: number) {
+  return `${userId}:${volumeId}:${index}`;
+}
+
+function downloadKey(userId: string, volumeId: string) {
+  return `${userId}:${volumeId}`;
+}
+
+function emitChange() {
+  window.dispatchEvent(new Event("bunko:offline-change"));
+}
+
+export function offlinePageUrl(userId: string, volumeId: string, index: number) {
+  return `/offline/volumes/${encodeURIComponent(userId)}/${encodeURIComponent(volumeId)}/pages/${index}`;
+}
+
+export function openOfflineLibrary() {
+  return new Promise<IDBDatabase>((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(VOLUMES)) {
+        const store = db.createObjectStore(VOLUMES, { keyPath: "key" });
+        store.createIndex("userId", "userId", { unique: false });
+        store.createIndex("userSection", ["userId", "section"], { unique: false });
+      }
+      if (!db.objectStoreNames.contains(PAGES)) {
+        const store = db.createObjectStore(PAGES, { keyPath: "key" });
+        store.createIndex("volume", ["userId", "volumeId"], { unique: false });
+      }
+      if (!db.objectStoreNames.contains(DOWNLOADS)) {
+        const store = db.createObjectStore(DOWNLOADS, { keyPath: "key" });
+        store.createIndex("userId", "userId", { unique: false });
+      }
+      if (!db.objectStoreNames.contains(OPERATIONS)) {
+        const store = db.createObjectStore(OPERATIONS, { keyPath: "id" });
+        store.createIndex("userId", "userId", { unique: false });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function getOfflineVolume(userId: string, volumeId: string) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readonly");
+  const value = await request<(OfflineVolume & { key: string }) | undefined>(
+    tx.objectStore(VOLUMES).get(volumeKey(userId, volumeId)),
+  );
+  db.close();
+  return value ? withoutKey(value) : null;
+}
+
+export async function getReadyVolumes(userId: string, section?: LibrarySection) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction([VOLUMES, DOWNLOADS], "readonly");
+  const [volumes, downloads] = await Promise.all([
+    request<Array<OfflineVolume & { key: string }>>(
+    section
+      ? tx.objectStore(VOLUMES).index("userSection").getAll([userId, section])
+      : tx.objectStore(VOLUMES).index("userId").getAll(userId),
+    ),
+    request<OfflineDownload[]>(tx.objectStore(DOWNLOADS).index("userId").getAll(userId)),
+  ]);
+  db.close();
+  const readyIds = new Set(downloads.filter((download) => download.status === "ready").map((download) => download.volumeId));
+  const ready = volumes.filter((volume) => readyIds.has(volume.id)).map(withoutKey);
+  return ready.sort((a, b) => a.title.localeCompare(b.title));
+}
+
+export async function getDownload(userId: string, volumeId: string) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(DOWNLOADS, "readonly");
+  const value = await request<OfflineDownload | undefined>(tx.objectStore(DOWNLOADS).get(downloadKey(userId, volumeId)));
+  db.close();
+  return value ?? null;
+}
+
+export async function getOfflineImages(userId: string, volumeId: string) {
+  const download = await getDownload(userId, volumeId);
+  if (download?.status !== "ready") return [];
+  return Array.from({ length: download.totalPages }, (_, index) => offlinePageUrl(userId, volumeId, index));
+}
+
+async function putDownload(download: OfflineDownload) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(DOWNLOADS, "readwrite");
+  tx.objectStore(DOWNLOADS).put(download);
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+async function saveManifest(userId: string, manifest: OfflineVolumeManifest) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readwrite");
+  tx.objectStore(VOLUMES).put({
+    key: volumeKey(userId, manifest.id),
+    userId,
+    id: manifest.id,
+    slug: manifest.slug,
+    section: manifest.section,
+    title: manifest.title,
+    seriesId: manifest.series.id,
+    seriesSlug: manifest.series.slug,
+    seriesTitle: manifest.series.title,
+    isOneshot: manifest.series.isOneshot,
+    mangaStyle: manifest.mangaStyle,
+    metadata: manifest.metadata,
+    coverUrl: manifest.coverUrl,
+    isRead: manifest.isRead,
+    isFavorite: manifest.isFavorite,
+    lastPage: manifest.lastPage,
+    totalPages: manifest.totalPages,
+  });
+  await transactionDone(tx);
+  db.close();
+}
+
+async function hasPage(userId: string, volumeId: string, index: number) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(PAGES, "readonly");
+  const value = await request<OfflinePage | undefined>(tx.objectStore(PAGES).get(pageKey(userId, volumeId, index)));
+  db.close();
+  return !!value;
+}
+
+async function savePage(userId: string, volumeId: string, index: number, blob: Blob) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(PAGES, "readwrite");
+  tx.objectStore(PAGES).put({ key: pageKey(userId, volumeId, index), userId, volumeId, index, blob } satisfies OfflinePage);
+  await transactionDone(tx);
+  db.close();
+}
+
+async function fetchManifest(section: LibrarySection, kind: "volume" | "series", slug: string) {
+  const response = await fetch(`/api/offline/library/${section}/${kind}/${encodeURIComponent(slug)}`);
+  if (!response.ok) throw new Error("No se pudo preparar la descarga offline");
+  return response.json() as Promise<{ volume?: OfflineVolumeManifest; volumes?: OfflineVolumeManifest[] }>;
+}
+
+async function fetchBlob(url: string) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error("No se pudo descargar una página");
+  return response.blob();
+}
+
+export async function downloadOfflineVolume(
+  userId: string,
+  manifest: OfflineVolumeManifest,
+  onProgress?: (download: OfflineDownload) => void,
+) {
+  if (!navigator.onLine) throw new Error("Se requiere conexión para descargar");
+  await navigator.storage?.persist?.();
+  await saveManifest(userId, manifest);
+
+  const pagesResponse = await fetch("/api/reader/manga", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ slug: manifest.slug }),
+  });
+  const pagesData = await pagesResponse.json() as { images?: string[] };
+  if (!pagesResponse.ok || !pagesData.images?.length) throw new Error("No se encontraron páginas para descargar");
+
+  let size = 0;
+  let completedPages = 0;
+  const totalPages = pagesData.images.length;
+  const publish = async (status: OfflineDownloadStatus, error?: string) => {
+    const download: OfflineDownload = {
+      key: downloadKey(userId, manifest.id), userId, volumeId: manifest.id, status,
+      completedPages, totalPages, size, error, updatedAt: new Date().toISOString(),
+    };
+    await putDownload(download);
+    onProgress?.(download);
+    return download;
+  };
+
+  try {
+    await publish("queued");
+    if (manifest.coverUrl && !(await hasPage(userId, manifest.id, -1))) {
+      const cover = await fetchBlob(manifest.coverUrl);
+      await savePage(userId, manifest.id, -1, cover);
+      size += cover.size;
+    }
+
+    for (let index = 0; index < pagesData.images.length; index++) {
+      if (await hasPage(userId, manifest.id, index)) {
+        completedPages++;
+        continue;
+      }
+      await publish("downloading");
+      const blob = await fetchBlob(pagesData.images[index]);
+      await savePage(userId, manifest.id, index, blob);
+      size += blob.size;
+      completedPages++;
+      await publish("downloading");
+    }
+
+    const ready = await publish("ready");
+    const db = await openOfflineLibrary();
+    const tx = db.transaction(VOLUMES, "readwrite");
+    const stored = await request<(OfflineVolume & { key: string }) | undefined>(tx.objectStore(VOLUMES).get(volumeKey(userId, manifest.id)));
+    if (stored) tx.objectStore(VOLUMES).put({ ...stored, downloadedAt: new Date().toISOString(), totalPages: totalPages });
+    await transactionDone(tx);
+    db.close();
+    emitChange();
+    return ready;
+  } catch (error) {
+    await publish("error", error instanceof Error ? error.message : "Error al descargar");
+    throw error;
+  }
+}
+
+export async function downloadVolumeBySlug(userId: string, section: LibrarySection, slug: string, onProgress?: (download: OfflineDownload) => void) {
+  const data = await fetchManifest(section, "volume", slug);
+  if (!data.volume) throw new Error("Tomo no encontrado");
+  return downloadOfflineVolume(userId, data.volume, onProgress);
+}
+
+export async function downloadSeriesBySlug(userId: string, section: LibrarySection, slug: string, onProgress?: (completed: number, total: number) => void) {
+  const data = await fetchManifest(section, "series", slug);
+  const volumes = data.volumes ?? [];
+  if (!volumes.length) throw new Error("La serie no tiene tomos descargables");
+  let completed = 0;
+  for (const volume of volumes) {
+    await downloadOfflineVolume(userId, volume);
+    completed++;
+    onProgress?.(completed, volumes.length);
+  }
+}
+
+export async function removeOfflineVolume(userId: string, volumeId: string) {
+  const db = await openOfflineLibrary();
+  const pageTx = db.transaction(PAGES, "readwrite");
+  const keys = await request<IDBValidKey[]>(pageTx.objectStore(PAGES).index("volume").getAllKeys([userId, volumeId]));
+  keys.forEach((key) => pageTx.objectStore(PAGES).delete(key));
+  await transactionDone(pageTx);
+  const tx = db.transaction([VOLUMES, DOWNLOADS], "readwrite");
+  tx.objectStore(VOLUMES).delete(volumeKey(userId, volumeId));
+  tx.objectStore(DOWNLOADS).delete(downloadKey(userId, volumeId));
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+export async function removeOfflineSeries(userId: string, seriesId: string) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readonly");
+  const volumes = await request<Array<OfflineVolume & { key: string }>>(tx.objectStore(VOLUMES).index("userId").getAll(userId));
+  db.close();
+  await Promise.all(volumes.filter((volume) => volume.seriesId === seriesId).map((volume) => removeOfflineVolume(userId, volume.id)));
+}
+
+export async function updateOfflineVolume(userId: string, volumeId: string, update: Partial<Pick<OfflineVolume, "isRead" | "isFavorite" | "lastPage" | "totalPages">>) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(VOLUMES, "readwrite");
+  const stored = await request<(OfflineVolume & { key: string }) | undefined>(tx.objectStore(VOLUMES).get(volumeKey(userId, volumeId)));
+  if (stored) tx.objectStore(VOLUMES).put({ ...stored, ...update });
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+export async function enqueueOfflineOperation(userId: string, kind: OfflineOperationKind, payload: Record<string, unknown>) {
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(OPERATIONS, "readwrite");
+  const id = crypto.randomUUID();
+  tx.objectStore(OPERATIONS).put({ id, userId, kind, payload, createdAt: new Date().toISOString() } satisfies OfflineOperation);
+  await transactionDone(tx);
+  db.close();
+  emitChange();
+}
+
+export async function flushOfflineOperations(userId: string) {
+  if (!navigator.onLine) return;
+  const db = await openOfflineLibrary();
+  const tx = db.transaction(OPERATIONS, "readonly");
+  const operations = await request<OfflineOperation[]>(tx.objectStore(OPERATIONS).index("userId").getAll(userId));
+  db.close();
+  if (!operations.length) return;
+  const response = await fetch("/api/offline/sync", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ operations }),
+  });
+  if (!response.ok) return;
+  const data = await response.json() as { completed?: string[] };
+  if (!data.completed?.length) return;
+  const writable = await openOfflineLibrary();
+  const writableTx = writable.transaction(OPERATIONS, "readwrite");
+  data.completed.forEach((id) => writableTx.objectStore(OPERATIONS).delete(id));
+  await transactionDone(writableTx);
+  writable.close();
+  emitChange();
+}
+
+export async function resumeOfflineDownloads(userId: string) {
+  if (!navigator.onLine) return;
+  const db = await openOfflineLibrary();
+  const tx = db.transaction([DOWNLOADS, VOLUMES], "readonly");
+  const downloads = await request<OfflineDownload[]>(tx.objectStore(DOWNLOADS).index("userId").getAll(userId));
+  const storedVolumes = await request<Array<OfflineVolume & { key: string }>>(tx.objectStore(VOLUMES).index("userId").getAll(userId));
+  const pending = downloads.filter((download) => download.status === "downloading" || download.status === "queued" || download.status === "error");
+  const manifests: OfflineVolumeManifest[] = [];
+  for (const download of pending) {
+    const volume = storedVolumes.find((item) => item.id === download.volumeId);
+    if (!volume) continue;
+    manifests.push({
+      id: volume.id, slug: volume.slug, section: volume.section, title: volume.title,
+      series: { id: volume.seriesId, slug: volume.seriesSlug, title: volume.seriesTitle, isOneshot: volume.isOneshot },
+      mangaStyle: volume.mangaStyle, metadata: volume.metadata, coverUrl: volume.coverUrl,
+      isRead: volume.isRead, isFavorite: volume.isFavorite, lastPage: volume.lastPage, totalPages: volume.totalPages,
+    });
+  }
+  db.close();
+  for (const manifest of manifests) {
+    try { await downloadOfflineVolume(userId, manifest); } catch { /* retry on next connection */ }
+  }
+}
+
+function withoutKey(value: OfflineVolume & { key: string }): OfflineVolume {
+  const { key: _key, ...volume } = value;
+  return volume;
+}

package/dist/src/lib/db/migrations/004_offline_sync_operations.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS offline_sync_operations (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  client_operation_id TEXT NOT NULL,
+  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
+  UNIQUE (user_id, client_operation_id)
+);
+
+CREATE INDEX IF NOT EXISTS offline_sync_operations_user_id_idx
+  ON offline_sync_operations (user_id);

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

@@ -8,11 +8,13 @@ pg.types.setTypeParser(1700, (value: string) =>
   value !== null ? parseFloat(value) : null
 );
 
-let pool: pg.Pool | undefined;
+const globalForPool = globalThis as typeof globalThis & {
+  bunkoPool?: pg.Pool;
+};
 
 export function getPool(): pg.Pool {
-  if (pool) {
-    return pool;
+  if (globalForPool.bunkoPool) {
+    return globalForPool.bunkoPool;
   }
 
   const connectionString = process.env.DATABASE_URL;
@@ -21,17 +23,17 @@ export function getPool(): pg.Pool {
     throw new Error("DATABASE_URL is not defined in environment variables");
   }
 
-  pool = new pg.Pool({
+  const pool = new pg.Pool({
     connectionString,
     max: 10,
     idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 2000,
+    connectionTimeoutMillis: 10000,
   });
 
   pool.on("error", (error: Error) => {
     console.error("[bunko/db] Unexpected pool error:", error.message);
-    process.exit(1);
   });
 
+  globalForPool.bunkoPool = pool;
   return pool;
 }

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

@@ -1,12 +1,43 @@
-import type { QueryResultRow } from "pg";
+import type { QueryResult, QueryResultRow } from "pg";
 import { getPool } from "./pool";
 
+function isRetryableConnectionError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("connection terminated due to connection timeout") ||
+    message.includes("timeout exceeded when trying to connect") ||
+    message.includes("connect econnrefused") ||
+    message.includes("the database system is starting up")
+  );
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function runQuery<T extends QueryResultRow>(
+  text: string,
+  params: unknown[]
+): Promise<QueryResult<T>> {
+  const pool = getPool();
+
+  try {
+    return await pool.query<T>(text, params);
+  } catch (error) {
+    if (!isRetryableConnectionError(error)) throw error;
+
+    await wait(150);
+    return pool.query<T>(text, params);
+  }
+}
+
 export async function query<T extends QueryResultRow>(
   text: string,
   params: unknown[] = []
 ): Promise<T[]> {
-  const pool = getPool();
-  const result = await pool.query<T>(text, params);
+  const result = await runQuery<T>(text, params);
   return result.rows;
 }
 
@@ -22,7 +53,6 @@ export async function execute(
   text: string,
   params: unknown[] = []
 ): Promise<number> {
-  const pool = getPool();
-  const result = await pool.query(text, params);
+  const result = await runQuery(text, params);
   return result.rowCount ?? 0;
 }

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

@@ -1,6 +1,16 @@
 {
   "misc": {
     "coming": "Feature coming soon",
+    "offline": {
+      "unavailable": "Unavailable offline",
+      "download": "Download for offline reading",
+      "remove": "Remove offline download",
+      "downloadSeries": "Do you want to download every volume in this series?",
+      "removeSeries": "Do you want to remove this series downloads?",
+      "removeVolume": "Do you want to remove this volume download?",
+      "downloading": "Downloading for offline reading",
+      "downloadError": "The download could not be completed"
+    },
     "noSeriesFav": "There are no favorite series...",
     "noVolumesFav": "There is no favorite manga...",
     "dropzoneTt": "Drag and drop files here or click to select",

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

@@ -1,6 +1,16 @@
 {
   "misc": {
     "coming": "Característica disponible próximamente",
+    "offline": {
+      "unavailable": "No disponible sin conexión",
+      "download": "Descargar para leer sin conexión",
+      "remove": "Eliminar descarga offline",
+      "downloadSeries": "¿Quieres descargar todos los tomos de esta serie?",
+      "removeSeries": "¿Quieres eliminar las descargas de esta serie?",
+      "removeVolume": "¿Quieres eliminar la descarga de este tomo?",
+      "downloading": "Descargando para leer sin conexión",
+      "downloadError": "No se pudo completar la descarga"
+    },
     "noSeriesFav": "No hay series favoritas...",
     "noVolumesFav": "No hay ningún manga favorito...",
     "dropzoneTt": "Arrastra y suelta aquí o haz clic para seleccionar",

package/dist/src/lib/utils.ts

@@ -70,6 +70,7 @@ function isTransientDatabaseConnectionError(error: unknown): boolean {
   const message = error.message.toLowerCase();
 
   return (
+    message.includes("connection terminated due to connection timeout") ||
     message.includes("timeout exceeded when trying to connect") ||
     message.includes("connect econnrefused") ||
     message.includes("the database system is starting up")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsmrtr/bunkoshelf",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Self-hosted personal manga library.",
   "keywords": [
     "bunko",

package/dist/.next/server/app/en/catalog.rsc

@@ -1,34 +0,0 @@
-1:"$Sreact.fragment"
-2:I[19191,["/_next/static/chunks/172z3klmfotr0.js","/_next/static/chunks/0u754jhlfjokm.js"],"default"]
-3:I[1708,["/_next/static/chunks/172z3klmfotr0.js","/_next/static/chunks/0u754jhlfjokm.js"],"default"]
-7:I[46468,["/_next/static/chunks/172z3klmfotr0.js","/_next/static/chunks/0u754jhlfjokm.js"],"OutletBoundary"]
-8:"$Sreact.suspense"
-e:I[46468,["/_next/static/chunks/172z3klmfotr0.js","/_next/static/chunks/0u754jhlfjokm.js"],"ViewportBoundary"]
-10:I[46468,["/_next/static/chunks/172z3klmfotr0.js","/_next/static/chunks/0u754jhlfjokm.js"],"MetadataBoundary"]
-12:I[99879,[],"default",1]
-16:I[65932,["/_next/static/chunks/145kuzv8s_m2t.js","/_next/static/chunks/07d0zq071jiyd.js"],"ToastProvider"]
-17:I[54085,["/_next/static/chunks/145kuzv8s_m2t.js","/_next/static/chunks/07d0zq071jiyd.js","/_next/static/chunks/12n1j6lzbr7gf.js"],"default"]
-18:I[52803,["/_next/static/chunks/145kuzv8s_m2t.js","/_next/static/chunks/07d0zq071jiyd.js","/_next/static/chunks/12n1j6lzbr7gf.js"],"default"]
-1a:I[71209,["/_next/static/chunks/172z3klmfotr0.js","/_next/static/chunks/0u754jhlfjokm.js"],"IconMark"]
-:HL["/_next/static/chunks/15zf6cw_gubrr.css","style"]
-:HL["/_next/static/media/Boldonse-s.p.0cfuyh95w9h4z.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-:HL["/_next/static/media/RobotoCondensed_Bold-s.p.00gqv~1e-fgpk.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-:HL["/_next/static/media/RobotoCondensed_Regular-s.p.0s.ps242b.v.0.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
-0:{"P":null,"c":["","en","catalog"],"q":"","i":false,"f":[[["",{"children":[["lang","en","d",null],{"children":["catalog",{"children":["__PAGE__",{}]}]},"$undefined","$undefined",16]}],[["$","$1","c",{"children":[null,["$","$L2",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L3",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]]}],{"children":[["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/chunks/15zf6cw_gubrr.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","script","script-0",{"src":"/_next/static/chunks/145kuzv8s_m2t.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/_next/static/chunks/07d0zq071jiyd.js","async":true,"nonce":"$undefined"}]],"$L4"]}],{"children":[["$","$1","c",{"children":[[["$","script","script-0",{"src":"/_next/static/chunks/12n1j6lzbr7gf.js","async":true,"nonce":"$undefined"}]],"$L5"]}],{"children":[["$","$1","c",{"children":["$L6",null,["$","$L7",null,{"children":["$","$8",null,{"name":"Next.MetadataOutlet","children":"$@9"}]}]]}],{},null,true,"$@a"]},null,true,"$@b"]},null,true,"$@c"]},null,true,"$@d"],["$","$1","h",{"children":[null,["$","$Le",null,{"children":"$Lf"}],["$","div",null,{"hidden":true,"children":["$","$L10",null,{"children":["$","$8",null,{"name":"Next.Metadata","children":"$L11"}]}]}],["$","meta",null,{"name":"next-size-adjust","content":""}]]}],true]],"m":"$undefined","G":["$12",[]],"S":true,"h":"$@13","s":"$undefined","l":"$undefined","p":"$undefined","d":"$undefined","b":"0ft9nB7GUgx-SjXU9qpLG"}
-14:[]
-d:"$W14"
-4:["$","html",null,{"lang":"en","className":"robotocondensed_46225445-module__OlTauq__variable boldonse_9cf6da9d-module__rkwiJG__variable antialiased","children":[["$","head",null,{"children":[["$","meta",null,{"name":"robots","content":"noindex,nofollow"}],["$","meta",null,{"name":"googlebot","content":"noindex,nofollow"}]]}],["$","body",null,{"className":"flex h-screen overflow-hidden text-lg relative","children":[["$","div",null,{"className":"fixed inset-0 -z-10 pointer-events-none bg-seigaiha-pattern-k opacity-50"}],["$","$8",null,{"fallback":["$","aside",null,{"className":"hidden md:flex md:w-[35%] lg:w-[25%] xl:w-[21%] 2xl:w-[17%] bg-blackamber flex-col"}],"children":"$L15"}],["$","main",null,{"className":"w-full md:w-[65%] lg:w-[75%] xl:w-[79%] 2xl:w-[83%] flex flex-col overflow-y-auto","children":["$","$L16",null,{"children":["$","$L2",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L3",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]}]}]]}]]}]
-5:["$","div",null,{"className":"flex flex-col md:flex-row md:h-screen overflow-hidden","children":[["$","aside",null,{"className":"flex md:w-[40%] lg:w-[32%] xl:w-[27%] 2xl:w-[20%] bg-pearl flex-col p-4 md:h-screen","children":[["$","h2",null,{"className":"flex items-center text-onix","children":[["$","$L17",null,{"ref":"$undefined","iconNode":[["path",{"d":"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20","key":"k3hazp"}],["path",{"d":"m8 13 4-7 4 7","key":"4rari8"}],["path",{"d":"M9.1 11h5.7","key":"1gkovt"}]],"className":"lucide-book-a mr-2","size":28}],"Catalog"]}],["$","$L18",null,{"intl":{"home":{"noActivity":"No recent activity","goToProfile":"Go To Profile"},"misc":{"coming":"Feature coming soon","noSeriesFav":"There are no favorite series...","noVolumesFav":"There is no favorite manga...","dropzoneTt":"Drag and drop files here or click to select","dropzoneMulti":"You can upload multiple files","dropzoneSingle":"You can upload a single file","dropzoneActive":"Drop the files here..."},"login":{"username":"Username","password":"Password","login":"Login"},"noauth":{"guide":"User Guide"},"sidebar":{"home":"Home","library":"Library","manga":"Manga","others":"Comic/Others","books":"Books","favorites":"Favorites","catalog":"Catalog","profile":"Profile"},"libraries":{"manga":"Manga","books":"Books","volumes":"Volumes","series":"Series","readList":"Read List","keepReading":"Keep Reading","inProgress":"Continue the Series","recentlyAdded":"Recently Added","recentlyUpdated":"Recently Updated","recentlyRead":"Recently Read","overview":"Overview","toRead":"Want to Read","deleteItem":{"series":"Delete Series","volume":"Delete Volume"},"deleteSure":{"series":"Are you sure you want to delete this series from your library?","volume":"Are you sure you want to delete this volume from your library?"}},"manga":{"read":"Read","series":"Series:","readingJp":"Right to Left","readingEn":"Left to Right","volumes":"Volumes","synopsis":"Synopsis","author":"Author","penciller":"Penciller","inker":"Inker","colorist":"Colorist","letterer":"Letterer","coverArtist":"Cover Artist","editor":"Editor","publisher":"Publisher","imprint":"Imprint","pages":"pages","genre":"Genre","tags":"Tags","format":"Format","seriesVolumes":"Series Volumes","allSeries":"Series (All)","allVolumes":"Volumes (All)","wantToRead":"Want to Read","showMore":"Show More","showLess":"Show Less","gtin":"ISBN","onGoing":"On Going","finished":"Finished","hiatus":"Hiatus","cancelled":"Cancelled","scanSeries":"Rescan Series","scanVolume":"Rescan Volume","scanning":"Scanning...","details":"Details","readingHistory":"Reading history","firstRead":"First read","reread":"Reread","addEntry":"Add reading","editEntry":"Edit reading","deleteEntry":"Delete","date":"Date","save":"Save","noEntries":"No readings recorded","migrateEntry":"Recover reading"},"reader":{"page":"Page","ttNext":"Next Page","ttPrev":"Previous Page","ttExit":"Exit Reader","finishFavorite":"Add Favorite","finishUnfavorite":"Remove Favorite"},"favorites":{"title":"Favorites","ttManga":"Manga","ttSeries":"Favorite Series","ttVolumes":"Favorite Volumes","ttSeriesManga":"Series - Manga","ttVolumesManga":"Volumes - Manga","ttSeriesOthers":"Series - Comic/Others","ttVolumesOthers":"Volumes - Comic/Others","sectionManga":"Manga","badgeSeries":"Series","badgeVolumes":"Volumes","sectionMangaSeries":"Manga - Series","sectionMangaVolumes":"Manga - Volumes","sectionOthers":"Comic/Others","sectionOthersSeries":"Comic/Others - Series","sectionOthersVolumes":"Comic/Others - Volumes","sectionBooks":"Books"},"profile":{"title":"Profile","overview":"Overview","name":"Name","lastname":"Lastname","password":"New Password","picture":"Profile picture","pictureHelp":"PNG, JPG or WEBP. Max 5MB.","removePicture":"Remove profile picture","save":"Save Changes","greeting":"Hi,","updateProfile":"Update Profile","notifications":"Notifications","noSubscriptions":"No subscriptions","endpoint":"Endpoint","subscribedAt":"Subscribed on","unsubscribe":"Remove","device":"Device","unknownDevice":"Unknown","thisDevice":"Current","unsubscribeAll":"Delete all","ttChallenge":"Challenge Goal","completed":"Completed","usrAdmin":"Owner","usrNormal":"Member","age":"Years","challenges":{"title":"Reading Challenges","challenge":"Challenge","of":"of"}},"settings":{"title":"Settings","overview":"Overview","totalVolumes":"Total volumes","totalSeries":"Total series","totalAddedMonth":"Added this month","totalUsers":"Total users","infoServerTt":"Server Information","infoServerDesc":"Basic details of Bunko Shelf","semVer":"Semantic Version","buildDate":"Build Date","users":"Users","library":"Library Settings","username":"Username","password":"Password","type":"Type","name":"Name","lastname":"Lastname","age":"Age","edit":"Edit","nameOpt":"Name (optional)","lastnameOpt":"Lastname (optional)","birthYearOpt":"Birth Year (optional)","isAdmin":"Super Admin","role":"Role","roleAdmin":"Admin","roleMember":"Member","roleGuest":"Guest","createUser":"Create User","updateUser":"Update User","deleteUser":"Delete User","passwordNew":"New Password","scanLibrary":"Scan Library","scanning":"Scanning...","backupdb":"Download Database","restoredb":"Restore Database","restoringDb":"Restoring...","successRestoreDbTt":"Database restored","successRestoreDbDesc":"The database was restored successfully","errorRestoreDbDesc":"Could not restore the database","ttActivity":"Recent Activity","noActivity":"No recent activity...","uploadLibrary":"Upload mangas/books","uploadLibraryTt":"Upload Manga or Book","uploadLibraryManga":"Manga","uploadLibraryBook":"Book","uploadLibrarySelect":"Select a directory","uploadLibraryNewManga":"New manga","uploadLibraryNewBook":"New book","uploadLibraryNewFolder":"Name of the new directory","uploadLibraryUploading":"Uploading...","uploadLibraryBtn":"Upload Files","storageLocal":"Local Library","storageCloud":"Remote Library","reindexing":"Reindexing...","reindex":"Reindex Library","regeneratingCovers":"Regenerating...","regenerateCovers":"Regenerate Covers","reprocessingMeta":"Processing...","reprocessMetadata":"Process Metadata"},"alerts":{"confirmDelete":"Are you sure you want to delete the user?","loginFail":"Invalid credentials","serverError":"Invalid server response"},"tooltip":{"logout":"Log Out","userGuide":"User Guide","switchLang":"Switch to Spanish","closeModal":"Close Window","settings":"Settings"},"toastUsers":{"successTt":"Success","successUpdate":"Updated User","successCreate":"User Created","successDel":"Deleted User","errorTt":"Error","errorUpdate":"Error updating user","errorCreate":"Error creating user","errorDel":"Error deleting user"},"toastScan":{"progressTt":"Scan Progress","noTask":"No active task","reindexTt":"Reindexing Library","reindexDesc":"The library is being reindexed","regeneratingCoversTt":"Regenerating Covers","regeneratingCoversDesc":"Extracting covers from all volumes...","reprocessingMetaTt":"Processing Metadata","reprocessingMetaDesc":"Extracting metadata from all volumes...","successTt":"Scanning Completed","successDesc":"Scanning completed successfully","successReindexTt":"Reindexing Completed","successReindexDesc":{"prefix":"series and","suffix":"volumes processed"},"successRegeneratingCoversTt":"Covers Regenerated","successRegeneratingCoversDesc":"covers extracted","successReprocessingMetaTt":"Metadata Processed","errorTt":"Error","errorDesc":"Could not complete scanning","errorReindexDesc":"Could not reindex the library","errorRegeneratingCoversDesc":"Could not extract covers","errorReprocessingMetaDesc":"Could not process metadata"},"toastVersion":{"title":"New Version","description":"View version changes"},"toastDev":{"appDevelopTt":"App in development","appDevelop":"Advanced Beta, may not work as you expect"},"search":{"placeholder":"Search","titleAuthor":"Search title or author","searching":"Searching...","noResults":"No results found","author":"Author","series":"Series","volume":"Volume"},"filters":{"filter":"Filter","filtering":"Filtering","filters":"Filters","authors":"Authors","genres":"Genres","tags":"Tags","apply":"Apply Filters","clean":"Clean Filters"},"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","unknownAuthor":"Unknown","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"},"push":{"ttSubscription":"Notification","bodySubscription":"Notifications activated","ttLibraryUpdate":"Updated library","bodyLibraryUpdate":"There are new things in the library","ttReadStreak":"Reading streak","bodyReadStreak":"Don't lose your streak, you still have time","ttFirstRead":"Volume completed!","bodyFirstRead":"You have finished reading volume: {title}","ttChallengeDone":"Reading challenge completed!","bodyChallengeDone":"Congratulations, you completed your {year} reading challenge"},"months":{"1":"Jan","2":"Feb","3":"Mar","4":"Apr","5":"May","6":"Jun","7":"Jul","8":"Aug","9":"Sep","10":"Oct","11":"Nov","12":"Dec"},"stats":{"monthRead":"Read this month","daysRead":"Days read this month","daysReadYear":"Days read in the last year","mangaRead":"Read in total","prevMonth":"Compared to previous month","streak":"Reading streak","days":"days","lastRead":"Last day read","ttMonthlyRead":"Monthly Read","tooltip":"Read","ttGenres":"Narrative Affinities"}}}]]}],"$L19"]}]
-19:["$","div",null,{"className":"w-full md:w-[60%] lg:w-[68%] xl:w-[73%] 2xl:w-[80%] p-4 overflow-y-auto","children":["$","div",null,{"className":"mb-24 md:mb-4","children":["$","$L2",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L3",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]}]}]
-f:[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]]
-9:null
-11:[["$","title","0",{"children":"Bunko Shelf"}],["$","meta","1",{"name":"description","content":"Self-hosted server for managing-reading manga & ebooks."}],["$","link","2",{"rel":"manifest","href":"/manifest.json","crossOrigin":"$undefined"}],["$","link","3",{"rel":"icon","href":"/favicon.png"}],["$","link","4",{"rel":"apple-touch-icon","href":"/pwa/bunkoshelf-icon-192.png"}],["$","$L1a","5",{}]]
-1b:[]
-13:"$W1b"
-1c:["lang"]
-a:"$W1c"
-1d:["lang"]
-b:"$W1d"
-1e:["lang"]
-c:"$W1e"
-6:E{"digest":"NEXT_REDIRECT;replace;/en/catalog/library;307;"}