cyreader 0.1.1 → 0.2.0

package/bundle/server/dist/config/paths.js

@@ -16,3 +16,9 @@ export function getRecentFilePath() {
 export function getProgressFilePath() {
     return path.join(getConfigDir(), 'progress.json');
 }
+export function getLibraryFilePath() {
+    return path.join(getConfigDir(), 'library.json');
+}
+export function getLegacyLibraryCacheFilePath() {
+    return path.join(getConfigDir(), 'library-cache.json');
+}

package/bundle/server/dist/index.js

@@ -7,7 +7,7 @@ import { ProgressService } from './reading/progress/service.js';
 import { RecentService } from './reading/recent/service.js';
 async function main() {
     const configService = await ConfigService.create();
-    const libraryService = new LibraryService(() => configService.get());
+    const libraryService = await LibraryService.create(() => configService.get());
     const recentService = await RecentService.create(libraryService);
     const progressService = await ProgressService.create(libraryService);
     const app = createApp(configService, libraryService, recentService, progressService);

package/bundle/server/dist/library/cache.js

@@ -0,0 +1,70 @@
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { getConfigDir, getLibraryCacheFilePath } from '../config/paths.js';
+const comicPageSchema = z.object({
+    filename: z.string().min(1),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+});
+const novelCacheItemSchema = z.object({
+    id: z.string().min(1),
+    type: z.literal('novel'),
+    title: z.string(),
+    path: z.string().min(1),
+    addedAt: z.string().datetime(),
+    directoryId: z.string().min(1),
+    filename: z.string().min(1),
+});
+const comicCacheItemSchema = z.object({
+    id: z.string().min(1),
+    type: z.literal('comic'),
+    title: z.string(),
+    path: z.string().min(1),
+    addedAt: z.string().datetime(),
+    directoryId: z.string().min(1),
+    pages: z.array(comicPageSchema),
+    coverFilename: z.string().nullable(),
+});
+const libraryCacheSchema = z.object({
+    items: z.array(z.discriminatedUnion('type', [novelCacheItemSchema, comicCacheItemSchema])),
+});
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createEmptyLibraryScanCache() {
+    return { items: [] };
+}
+export function parseLibraryScanCache(data) {
+    const parsed = libraryCacheSchema.safeParse(data);
+    if (!parsed.success) {
+        return createEmptyLibraryScanCache();
+    }
+    return { items: parsed.data.items };
+}
+export async function readLibraryScanCache() {
+    const cacheFile = getLibraryCacheFilePath();
+    if (!(await fileExists(cacheFile))) {
+        return createEmptyLibraryScanCache();
+    }
+    let data;
+    try {
+        data = JSON.parse(await readFile(cacheFile, 'utf-8'));
+    }
+    catch {
+        return createEmptyLibraryScanCache();
+    }
+    return parseLibraryScanCache(data);
+}
+export async function writeLibraryScanCache(cache) {
+    const configDir = getConfigDir();
+    const cacheFile = getLibraryCacheFilePath();
+    const normalized = parseLibraryScanCache(cache);
+    await mkdir(configDir, { recursive: true });
+    await writeFile(cacheFile, `${JSON.stringify(normalized, null, 2)}\n`, 'utf-8');
+}

package/bundle/server/dist/library/scan.js

@@ -1,5 +1,7 @@
 import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
+import sharp from 'sharp';
+import { readLibrary } from './storage.js';
 import { generateComicCoverIfMissing, resolveComicCoverFilename } from './cover.js';
 import { isComicCoverFile, isHiddenName, isImageFile, isTxtFile, sortByNaturalName, } from './files.js';
 import { makeLocalItemId } from './id.js';
@@ -44,7 +46,7 @@ async function shouldIncludeNovel(childPath, gbkNovelHandling) {
         return false;
     }
 }
-async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
+async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling, cacheByPath) {
     const children = await listDirectChildren(root);
     const stats = await Promise.all(children.map(async (childPath) => ({
         childPath,
@@ -56,11 +58,21 @@ async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
         }
         return isTxtFile(path.basename(childPath));
     });
-    const inclusion = await Promise.all(txtFiles.map(async ({ childPath }) => ({
+    const cachedNovels = [];
+    const uncachedTxtFiles = [];
+    for (const entry of txtFiles) {
+        const cached = cacheByPath.get(entry.childPath);
+        if (cached?.type === 'novel') {
+            cachedNovels.push({ ...cached, directoryId });
+            continue;
+        }
+        uncachedTxtFiles.push(entry);
+    }
+    const inclusion = await Promise.all(uncachedTxtFiles.map(async ({ childPath }) => ({
         childPath,
         include: await shouldIncludeNovel(childPath, gbkNovelHandling),
     })));
-    return inclusion
+    const scannedNovels = inclusion
         .filter((entry) => entry.include)
         .map(({ childPath }) => {
         const name = path.basename(childPath);
@@ -70,10 +82,12 @@ async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
             type: 'novel',
             title,
             path: childPath,
+            addedAt: new Date().toISOString(),
             directoryId,
             filename: name,
         };
     });
+    return [...cachedNovels, ...scannedNovels];
 }
 async function listDirectImageFiles(dir) {
     const children = await listDirectChildren(dir);
@@ -94,7 +108,26 @@ async function listDirectImageFiles(dir) {
     }
     return sortByNaturalName(images);
 }
-async function scanComicsInDirectory(directoryId, root) {
+async function resolveComicPage(imagePath) {
+    try {
+        const metadata = await sharp(imagePath).metadata();
+        const width = metadata.width;
+        const height = metadata.height;
+        if (!width || !height) {
+            return null;
+        }
+        return {
+            filename: path.basename(imagePath),
+            width,
+            height,
+        };
+    }
+    catch (error) {
+        console.error(`Failed to read comic page metadata: ${imagePath}`, error);
+        return null;
+    }
+}
+async function scanComicsInDirectory(directoryId, root, cacheByPath) {
     const children = await listDirectChildren(root);
     const stats = await Promise.all(children.map(async (childPath) => ({
         childPath,
@@ -104,10 +137,18 @@ async function scanComicsInDirectory(directoryId, root) {
         .filter(({ childStat }) => childStat?.isDirectory())
         .map(({ childPath }) => childPath);
     const comics = await Promise.all(comicDirs.map(async (childPath) => {
+        const cached = cacheByPath.get(childPath);
+        if (cached?.type === 'comic') {
+            return Object.assign({}, cached, { directoryId });
+        }
         const images = await listDirectImageFiles(childPath);
         if (images.length === 0) {
             return null;
         }
+        const pages = (await Promise.all(images.map((imagePath) => resolveComicPage(imagePath)))).filter((page) => page !== null);
+        if (pages.length === 0) {
+            return null;
+        }
         await generateComicCoverIfMissing(childPath, images[0]);
         const coverFilename = await resolveComicCoverFilename(childPath);
         return {
@@ -115,17 +156,21 @@ async function scanComicsInDirectory(directoryId, root) {
             type: 'comic',
             title: path.basename(childPath),
             path: childPath,
+            addedAt: new Date().toISOString(),
             directoryId,
-            pages: images.map((imagePath) => path.basename(imagePath)),
+            pages,
             coverFilename,
         };
     }));
     return comics.filter((comic) => comic !== null);
 }
 export async function scanLibrary(config) {
-    const novelResults = await Promise.all(config.novelDirectories.map((directory) => scanNovelsInDirectory(directory.id, directory.path, config.gbkNovelHandling)));
-    const comicResults = await Promise.all(config.comicDirectories.map((directory) => scanComicsInDirectory(directory.id, directory.path)));
-    return [...novelResults.flat(), ...comicResults.flat()];
+    const cache = await readLibrary();
+    const cacheByPath = new Map(cache.items.map((item) => [item.path, item]));
+    const novelResults = await Promise.all(config.novelDirectories.map((directory) => scanNovelsInDirectory(directory.id, directory.path, config.gbkNovelHandling, cacheByPath)));
+    const comicResults = await Promise.all(config.comicDirectories.map((directory) => scanComicsInDirectory(directory.id, directory.path, cacheByPath)));
+    const items = [...novelResults.flat(), ...comicResults.flat()];
+    return items;
 }
 export async function listComicPages(comicDir) {
     return listDirectImageFiles(comicDir);

package/bundle/server/dist/library/scan.test.js

@@ -5,13 +5,23 @@ import sharp from 'sharp';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { COMIC_COVER_FILENAME } from './files.js';
 import { listComicPages, scanLibrary } from './scan.js';
+import { readLibrary, writeLibrary } from './storage.js';
 import { writeTestImage } from './test-images.js';
 describe('scanLibrary', () => {
     let tempDir;
+    let previousConfigDir;
     beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
         tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-scan-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
     });
     afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
         await rm(tempDir, { recursive: true, force: true });
     });
     it('ignores GBK txt files when gbkNovelHandling is undefined', async () => {
@@ -97,10 +107,10 @@ describe('scanLibrary', () => {
         const mangaDir = path.join(comicRoot, 'manga-a');
         const nested = path.join(mangaDir, 'chapter');
         await mkdir(nested, { recursive: true });
-        await writeFile(path.join(mangaDir, '10.jpg'), '');
-        await writeFile(path.join(mangaDir, '2.png'), '');
-        await writeFile(path.join(mangaDir, '1.webp'), '');
-        await writeFile(path.join(nested, 'ignored.jpeg'), '');
+        await writeTestImage(path.join(mangaDir, '10.jpg'), 1000, 1200);
+        await writeTestImage(path.join(mangaDir, '2.png'), 200, 300);
+        await writeTestImage(path.join(mangaDir, '1.webp'), 100, 150);
+        await writeTestImage(path.join(nested, 'ignored.jpeg'), 50, 50);
         const items = await scanLibrary({
             novelDirectories: [],
             comicDirectories: [{ id: 'comic-root', path: comicRoot }],
@@ -111,8 +121,13 @@ describe('scanLibrary', () => {
             type: 'comic',
             title: 'manga-a',
             directoryId: 'comic-root',
-            pages: ['1.webp', '2.png', '10.jpg'],
-            coverFilename: null,
+            pages: [
+                { filename: '1.webp', width: 100, height: 150 },
+                { filename: '2.png', width: 200, height: 300 },
+                { filename: '10.jpg', width: 1000, height: 1200 },
+            ],
+            coverFilename: COMIC_COVER_FILENAME,
+            addedAt: expect.any(String),
         });
     });
     it('ignores root-level images and folders without direct images', async () => {
@@ -149,7 +164,10 @@ describe('scanLibrary', () => {
         expect(items[0]).toMatchObject({
             type: 'comic',
             title: 'manga-cover',
-            pages: ['1.jpg', '2.jpg'],
+            pages: [
+                { filename: '1.jpg', width: 300, height: 399 },
+                { filename: '2.jpg', width: 301, height: 400 },
+            ],
             coverFilename: COMIC_COVER_FILENAME,
         });
     });
@@ -182,11 +200,14 @@ describe('scanLibrary', () => {
         });
         expect(items[0]).toMatchObject({
             type: 'comic',
-            pages: ['1.jpg', '2.jpg'],
+            pages: [
+                { filename: '1.jpg', width: 300, height: 300 },
+                { filename: '2.jpg', width: 300, height: 300 },
+            ],
             coverFilename: COMIC_COVER_FILENAME,
         });
     });
-    it('keeps scanning comics when cover generation fails', async () => {
+    it('skips comic images when metadata cannot be read', async () => {
         const comicRoot = path.join(tempDir, 'comics');
         const mangaDir = path.join(comicRoot, 'manga-invalid');
         await mkdir(mangaDir, { recursive: true });
@@ -196,20 +217,14 @@ describe('scanLibrary', () => {
             comicDirectories: [{ id: 'comic-root', path: comicRoot }],
             gbkNovelHandling: 'ignore',
         });
-        expect(items).toHaveLength(1);
-        expect(items[0]).toMatchObject({
-            type: 'comic',
-            title: 'manga-invalid',
-            pages: ['1.jpg'],
-            coverFilename: null,
-        });
+        expect(items).toHaveLength(0);
         await expect(access(path.join(mangaDir, COMIC_COVER_FILENAME))).rejects.toThrow();
     });
     it('supports jpeg extension for comic cover', async () => {
         const comicRoot = path.join(tempDir, 'comics');
         const mangaDir = path.join(comicRoot, 'manga-b');
         await mkdir(mangaDir, { recursive: true });
-        await writeFile(path.join(mangaDir, 'cover.jpeg'), '');
+        await writeTestImage(path.join(mangaDir, 'cover.jpeg'), 320, 480);
         const items = await scanLibrary({
             novelDirectories: [],
             comicDirectories: [{ id: 'comic-root', path: comicRoot }],
@@ -219,8 +234,74 @@ describe('scanLibrary', () => {
         expect(items[0]).toMatchObject({
             type: 'comic',
             directoryId: 'comic-root',
-            pages: ['cover.jpeg'],
+            pages: [{ filename: 'cover.jpeg', width: 320, height: 480 }],
+        });
+    });
+    it('reuses cached comic directories from persisted library', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const mangaDir = path.join(comicRoot, 'manga-cached');
+        await mkdir(mangaDir, { recursive: true });
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 450);
+        const first = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(first[0]).toMatchObject({
+            type: 'comic',
+            pages: [{ filename: '1.jpg', width: 300, height: 450 }],
+            coverFilename: COMIC_COVER_FILENAME,
+            addedAt: expect.any(String),
+        });
+        await writeLibrary({ items: first });
+        await rm(path.join(mangaDir, '1.jpg'));
+        await rm(path.join(mangaDir, COMIC_COVER_FILENAME));
+        const second = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(second).toEqual(first);
+        await expect(access(path.join(mangaDir, COMIC_COVER_FILENAME))).rejects.toThrow();
+    });
+    it('reuses cached novels without rechecking encoding', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const filePath = path.join(novelRoot, 'book.txt');
+        await mkdir(novelRoot);
+        await writeFile(filePath, 'content');
+        const first = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        await writeLibrary({ items: first });
+        await writeFile(filePath, Buffer.from([0xd6, 0xd0, 0xce, 0xc4]));
+        const second = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
         });
+        expect(second).toEqual(first);
+    });
+    it('removes deleted entries after scanning persisted library', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const filePath = path.join(novelRoot, 'book.txt');
+        await mkdir(novelRoot);
+        await writeFile(filePath, 'content');
+        const first = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        await writeLibrary({ items: first });
+        await rm(filePath);
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(0);
+        expect((await readLibrary()).items).toHaveLength(1);
     });
 });
 describe('listComicPages', () => {

package/bundle/server/dist/library/service.js

@@ -2,19 +2,22 @@ import { attachProgressToDetail, attachProgressToListItem } from '../reading/pro
 import { buildComicImageUrl } from './comic-url.js';
 import { NotFoundError, ScanInProgressError } from './errors.js';
 import { scanLibrary } from './scan.js';
+import { readLibrary, writeLibrary } from './storage.js';
 export function toListItemBase(item) {
     if (item.type === 'novel') {
         return {
             id: item.id,
             type: 'novel',
             title: item.title,
+            addedAt: item.addedAt,
         };
     }
-    const coverPage = item.coverFilename ?? item.pages[0];
+    const coverPage = item.coverFilename ?? item.pages[0]?.filename;
     return {
         id: item.id,
         type: 'comic',
         title: item.title,
+        addedAt: item.addedAt,
         cover: coverPage ? buildComicImageUrl(item.directoryId, item.title, coverPage) : '',
         pageCount: item.pages.length,
     };
@@ -25,6 +28,7 @@ function toItemDetailBase(item) {
             id: item.id,
             type: 'novel',
             title: item.title,
+            addedAt: item.addedAt,
             directoryId: item.directoryId,
             filename: item.filename,
         };
@@ -33,16 +37,22 @@ function toItemDetailBase(item) {
         id: item.id,
         type: 'comic',
         title: item.title,
+        addedAt: item.addedAt,
         directoryId: item.directoryId,
         pages: item.pages,
     };
 }
 export class LibraryService {
     getConfig;
-    items = [];
+    items;
     scanning = false;
-    constructor(getConfig) {
+    constructor(getConfig, items) {
         this.getConfig = getConfig;
+        this.items = items;
+    }
+    static async create(getConfig) {
+        const library = await readLibrary();
+        return new LibraryService(getConfig, library.items);
     }
     getState(progressMap = {}) {
         return {
@@ -63,7 +73,9 @@ export class LibraryService {
         }
         this.scanning = true;
         try {
-            this.items = await scanLibrary(this.getConfig());
+            const items = await scanLibrary(this.getConfig());
+            await writeLibrary({ items });
+            this.items = items;
         }
         finally {
             this.scanning = false;

package/bundle/server/dist/library/service.test.js

@@ -2,15 +2,25 @@ import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getLibraryFilePath } from '../config/paths.js';
 import { NotFoundError, ScanInProgressError } from './errors.js';
 import { LibraryService } from './service.js';
+import { readLibrary } from './storage.js';
 import { writeTestImage } from './test-images.js';
 describe('LibraryService', () => {
     let tempDir;
+    let previousConfigDir;
     let novelRoot;
     let comicRoot;
+    const config = () => ({
+        novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+        comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+        gbkNovelHandling: 'ignore',
+    });
     beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
         tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-service-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
         novelRoot = path.join(tempDir, 'novels');
         comicRoot = path.join(tempDir, 'comics');
         await mkdir(novelRoot);
@@ -18,17 +28,42 @@ describe('LibraryService', () => {
         await writeFile(path.join(novelRoot, 'book.txt'), 'content');
     });
     afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
         await rm(tempDir, { recursive: true, force: true });
     });
     function createService() {
-        return new LibraryService(() => ({
-            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
-            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
-            gbkNovelHandling: 'ignore',
-        }));
+        return LibraryService.create(config);
     }
+    it('returns persisted items before scan', async () => {
+        const scanned = await createService();
+        await scanned.scan();
+        const preloaded = await createService();
+        expect(preloaded.getState()).toEqual({
+            scanning: false,
+            items: scanned.getState().items,
+        });
+    });
+    it('keeps persisted items visible while scan is in progress', async () => {
+        const service = await createService();
+        await service.scan();
+        const before = service.getState().items;
+        await writeFile(path.join(novelRoot, 'newbook.txt'), 'more content');
+        const scanPromise = service.scan();
+        expect(service.getState()).toEqual({
+            scanning: true,
+            items: before,
+        });
+        await scanPromise;
+        expect(service.getState().scanning).toBe(false);
+        expect(service.getState().items).toHaveLength(2);
+    });
     it('populates list items after scan', async () => {
-        const service = createService();
+        const service = await createService();
         await service.scan();
         expect(service.getState()).toEqual({
             scanning: false,
@@ -37,25 +72,35 @@ describe('LibraryService', () => {
                     id: expect.any(String),
                     type: 'novel',
                     title: 'book',
+                    addedAt: expect.any(String),
                     progress: null,
                 },
             ],
         });
     });
+    it('writes library.json after scan', async () => {
+        const service = await createService();
+        await service.scan();
+        const library = await readLibrary();
+        expect(library.items).toHaveLength(1);
+        expect(library.items[0]).toMatchObject({ type: 'novel', title: 'book' });
+        expect(getLibraryFilePath()).toContain('library.json');
+    });
     it('rejects concurrent scan', async () => {
-        const service = createService();
+        const service = await createService();
         const firstScan = service.scan();
         await expect(service.scan()).rejects.toBeInstanceOf(ScanInProgressError);
         await firstScan;
     });
     it('returns novel detail for a known id', async () => {
-        const service = createService();
+        const service = await createService();
         await service.scan();
         const novel = service.getState().items[0];
         expect(service.getItemDetail(novel.id)).toEqual({
             id: novel.id,
             type: 'novel',
             title: 'book',
+            addedAt: expect.any(String),
             directoryId: 'novel-root',
             filename: 'book.txt',
             progress: null,
@@ -66,7 +111,7 @@ describe('LibraryService', () => {
         await mkdir(mangaDir);
         await writeTestImage(path.join(mangaDir, '2.jpg'), 300, 400);
         await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 400);
-        const service = createService();
+        const service = await createService();
         await service.scan();
         const comic = service.getState().items.find((item) => item.type === 'comic');
         expect(comic).toBeDefined();
@@ -74,8 +119,12 @@ describe('LibraryService', () => {
             id: comic.id,
             type: 'comic',
             title: 'manga',
+            addedAt: expect.any(String),
             directoryId: 'comic-root',
-            pages: ['1.jpg', '2.jpg'],
+            pages: [
+                { filename: '1.jpg', width: 300, height: 400 },
+                { filename: '2.jpg', width: 300, height: 400 },
+            ],
             progress: null,
         });
         expect(comic).toMatchObject({
@@ -85,7 +134,7 @@ describe('LibraryService', () => {
         });
     });
     it('throws when detail is requested for unknown id', async () => {
-        const service = createService();
+        const service = await createService();
         await service.scan();
         expect(() => service.getItemDetail('missing')).toThrow(NotFoundError);
     });