cyreader 0.1.0

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

@@ -0,0 +1,132 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { generateComicCoverIfMissing, resolveComicCoverFilename } from './cover.js';
+import { isComicCoverFile, isHiddenName, isImageFile, isTxtFile, sortByNaturalName, } from './files.js';
+import { makeLocalItemId } from './id.js';
+import { convertGbkBufferToUtf8, detectTextEncoding, writeUtf8FileAtomically, } from './text-encoding.js';
+async function listDirectChildren(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries.filter((name) => !isHiddenName(name)).map((name) => path.join(dir, name));
+}
+function resolveGbkNovelHandling(handling) {
+    return handling === 'convert-to-utf-8' ? 'convert-to-utf-8' : 'ignore';
+}
+async function shouldIncludeNovel(childPath, gbkNovelHandling) {
+    const handling = resolveGbkNovelHandling(gbkNovelHandling);
+    let buffer;
+    try {
+        buffer = await readFile(childPath);
+    }
+    catch (error) {
+        console.error(`Failed to read novel file: ${childPath}`, error);
+        return false;
+    }
+    const encoding = detectTextEncoding(buffer);
+    if (encoding === 'utf-8') {
+        return true;
+    }
+    if (handling === 'ignore') {
+        return false;
+    }
+    try {
+        const text = convertGbkBufferToUtf8(buffer);
+        await writeUtf8FileAtomically(childPath, text);
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to convert GBK novel to UTF-8: ${childPath}`, error);
+        return false;
+    }
+}
+async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
+    const children = await listDirectChildren(root);
+    const stats = await Promise.all(children.map(async (childPath) => ({
+        childPath,
+        childStat: await stat(childPath).catch(() => null),
+    })));
+    const txtFiles = stats.filter(({ childStat, childPath }) => {
+        if (!childStat?.isFile()) {
+            return false;
+        }
+        return isTxtFile(path.basename(childPath));
+    });
+    const inclusion = await Promise.all(txtFiles.map(async ({ childPath }) => ({
+        childPath,
+        include: await shouldIncludeNovel(childPath, gbkNovelHandling),
+    })));
+    return inclusion
+        .filter((entry) => entry.include)
+        .map(({ childPath }) => {
+        const name = path.basename(childPath);
+        const title = path.basename(name, path.extname(name));
+        return {
+            id: makeLocalItemId(childPath),
+            type: 'novel',
+            title,
+            path: childPath,
+            directoryId,
+            filename: name,
+        };
+    });
+}
+async function listDirectImageFiles(dir) {
+    const children = await listDirectChildren(dir);
+    const stats = await Promise.all(children.map(async (childPath) => ({
+        childPath,
+        childStat: await stat(childPath).catch(() => null),
+    })));
+    const images = [];
+    for (const { childPath, childStat } of stats) {
+        if (!childStat?.isFile()) {
+            continue;
+        }
+        const name = path.basename(childPath);
+        if (!isImageFile(name) || isComicCoverFile(name)) {
+            continue;
+        }
+        images.push(childPath);
+    }
+    return sortByNaturalName(images);
+}
+async function scanComicsInDirectory(directoryId, root) {
+    const children = await listDirectChildren(root);
+    const stats = await Promise.all(children.map(async (childPath) => ({
+        childPath,
+        childStat: await stat(childPath).catch(() => null),
+    })));
+    const comicDirs = stats
+        .filter(({ childStat }) => childStat?.isDirectory())
+        .map(({ childPath }) => childPath);
+    const comics = await Promise.all(comicDirs.map(async (childPath) => {
+        const images = await listDirectImageFiles(childPath);
+        if (images.length === 0) {
+            return null;
+        }
+        await generateComicCoverIfMissing(childPath, images[0]);
+        const coverFilename = await resolveComicCoverFilename(childPath);
+        return {
+            id: makeLocalItemId(childPath),
+            type: 'comic',
+            title: path.basename(childPath),
+            path: childPath,
+            directoryId,
+            pages: images.map((imagePath) => path.basename(imagePath)),
+            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()];
+}
+export async function listComicPages(comicDir) {
+    return listDirectImageFiles(comicDir);
+}

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

@@ -0,0 +1,252 @@
+import { access, mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+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 { writeTestImage } from './test-images.js';
+describe('scanLibrary', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-scan-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('ignores GBK txt files when gbkNovelHandling is undefined', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const filePath = path.join(novelRoot, 'gbk.txt');
+        await mkdir(novelRoot);
+        await writeFile(filePath, Buffer.from([0xd6, 0xd0, 0xce, 0xc4]));
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+        });
+        expect(items).toHaveLength(0);
+        expect(Buffer.from(await readFile(filePath))).toEqual(Buffer.from([0xd6, 0xd0, 0xce, 0xc4]));
+    });
+    it('ignores GBK txt files when gbkNovelHandling is ignore', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        await mkdir(novelRoot);
+        await writeFile(path.join(novelRoot, 'gbk.txt'), Buffer.from([0xd6, 0xd0, 0xce, 0xc4]));
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(0);
+    });
+    it('converts GBK txt files to UTF-8 when gbkNovelHandling is convert-to-utf-8', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const filePath = path.join(novelRoot, 'gbk.txt');
+        await mkdir(novelRoot);
+        await writeFile(filePath, Buffer.from([0xd6, 0xd0, 0xce, 0xc4]));
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'convert-to-utf-8',
+        });
+        expect(items).toHaveLength(1);
+        expect(items[0]).toMatchObject({ type: 'novel', title: 'gbk' });
+        expect(await readFile(filePath, 'utf-8')).toBe('中文');
+    });
+    it('scans direct txt files as novels', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        await mkdir(novelRoot);
+        await writeFile(path.join(novelRoot, 'alpha.txt'), 'content');
+        await writeFile(path.join(novelRoot, 'BETA.TXT'), 'content');
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(2);
+        expect(items).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                type: 'novel',
+                title: 'alpha',
+                directoryId: 'novel-root',
+                filename: 'alpha.txt',
+            }),
+            expect.objectContaining({
+                type: 'novel',
+                title: 'BETA',
+                directoryId: 'novel-root',
+                filename: 'BETA.TXT',
+            }),
+        ]));
+    });
+    it('ignores txt files in subdirectories and hidden txt files', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const nested = path.join(novelRoot, 'nested');
+        await mkdir(nested, { recursive: true });
+        await writeFile(path.join(novelRoot, 'visible.txt'), 'content');
+        await writeFile(path.join(nested, 'hidden-nested.txt'), 'content');
+        await writeFile(path.join(novelRoot, '.hidden.txt'), 'content');
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(1);
+        expect(items[0]).toMatchObject({ type: 'novel', title: 'visible' });
+    });
+    it('scans direct child folders with direct images as comics', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        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'), '');
+        const items = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(1);
+        expect(items[0]).toMatchObject({
+            type: 'comic',
+            title: 'manga-a',
+            directoryId: 'comic-root',
+            pages: ['1.webp', '2.png', '10.jpg'],
+            coverFilename: null,
+        });
+    });
+    it('ignores root-level images and folders without direct images', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const emptyDir = path.join(comicRoot, 'empty');
+        await mkdir(emptyDir, { recursive: true });
+        await writeFile(path.join(comicRoot, 'root.jpg'), '');
+        await mkdir(path.join(emptyDir, 'nested'), { recursive: true });
+        await writeFile(path.join(emptyDir, 'nested', '1.jpg'), '');
+        const items = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(0);
+    });
+    it('generates cover.jpg from the first page during scan', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const mangaDir = path.join(comicRoot, 'manga-cover');
+        await mkdir(mangaDir, { recursive: true });
+        await writeTestImage(path.join(mangaDir, '2.jpg'), 301, 400);
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 399);
+        const items = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        const coverPath = path.join(mangaDir, COMIC_COVER_FILENAME);
+        await access(coverPath);
+        const coverMetadata = await sharp(coverPath).metadata();
+        expect(coverMetadata.width).toBe(100);
+        expect(coverMetadata.height).toBe(133);
+        expect(items).toHaveLength(1);
+        expect(items[0]).toMatchObject({
+            type: 'comic',
+            title: 'manga-cover',
+            pages: ['1.jpg', '2.jpg'],
+            coverFilename: COMIC_COVER_FILENAME,
+        });
+    });
+    it('does not regenerate cover.jpg when it already exists', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const mangaDir = path.join(comicRoot, 'manga-existing-cover');
+        await mkdir(mangaDir, { recursive: true });
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 300);
+        const coverPath = path.join(mangaDir, COMIC_COVER_FILENAME);
+        await writeFile(coverPath, 'existing-cover');
+        const beforeMtime = (await stat(coverPath)).mtimeMs;
+        await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect((await stat(coverPath)).mtimeMs).toBe(beforeMtime);
+        expect(await readFile(coverPath, 'utf-8')).toBe('existing-cover');
+    });
+    it('excludes cover.jpg from comic pages', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const mangaDir = path.join(comicRoot, 'manga-pages');
+        await mkdir(mangaDir, { recursive: true });
+        await writeTestImage(path.join(mangaDir, '2.jpg'), 300, 300);
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 300);
+        const items = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items[0]).toMatchObject({
+            type: 'comic',
+            pages: ['1.jpg', '2.jpg'],
+            coverFilename: COMIC_COVER_FILENAME,
+        });
+    });
+    it('keeps scanning comics when cover generation fails', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const mangaDir = path.join(comicRoot, 'manga-invalid');
+        await mkdir(mangaDir, { recursive: true });
+        await writeFile(path.join(mangaDir, '1.jpg'), '');
+        const items = await scanLibrary({
+            novelDirectories: [],
+            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,
+        });
+        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'), '');
+        const items = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(items).toHaveLength(1);
+        expect(items[0]).toMatchObject({
+            type: 'comic',
+            directoryId: 'comic-root',
+            pages: ['cover.jpeg'],
+        });
+    });
+});
+describe('listComicPages', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-pages-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('returns direct image files in natural order', async () => {
+        await writeFile(path.join(tempDir, '10.jpg'), '');
+        await writeFile(path.join(tempDir, '2.jpg'), '');
+        await writeFile(path.join(tempDir, '1.jpg'), '');
+        const pages = await listComicPages(tempDir);
+        expect(pages).toEqual([
+            path.join(tempDir, '1.jpg'),
+            path.join(tempDir, '2.jpg'),
+            path.join(tempDir, '10.jpg'),
+        ]);
+    });
+    it('excludes cover.jpg from comic pages', async () => {
+        await writeFile(path.join(tempDir, COMIC_COVER_FILENAME), '');
+        await writeFile(path.join(tempDir, '2.jpg'), '');
+        await writeFile(path.join(tempDir, '1.jpg'), '');
+        const pages = await listComicPages(tempDir);
+        expect(pages).toEqual([path.join(tempDir, '1.jpg'), path.join(tempDir, '2.jpg')]);
+    });
+});

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

@@ -0,0 +1,87 @@
+import { attachProgressToDetail, attachProgressToListItem } from '../reading/progress/merge.js';
+import { buildComicImageUrl } from './comic-url.js';
+import { NotFoundError, ScanInProgressError } from './errors.js';
+import { scanLibrary } from './scan.js';
+export function toListItemBase(item) {
+    if (item.type === 'novel') {
+        return {
+            id: item.id,
+            type: 'novel',
+            title: item.title,
+        };
+    }
+    const coverPage = item.coverFilename ?? item.pages[0];
+    return {
+        id: item.id,
+        type: 'comic',
+        title: item.title,
+        cover: coverPage ? buildComicImageUrl(item.directoryId, item.title, coverPage) : '',
+        pageCount: item.pages.length,
+    };
+}
+function toItemDetailBase(item) {
+    if (item.type === 'novel') {
+        return {
+            id: item.id,
+            type: 'novel',
+            title: item.title,
+            directoryId: item.directoryId,
+            filename: item.filename,
+        };
+    }
+    return {
+        id: item.id,
+        type: 'comic',
+        title: item.title,
+        directoryId: item.directoryId,
+        pages: item.pages,
+    };
+}
+export class LibraryService {
+    getConfig;
+    items = [];
+    scanning = false;
+    constructor(getConfig) {
+        this.getConfig = getConfig;
+    }
+    getState(progressMap = {}) {
+        return {
+            scanning: this.scanning,
+            items: this.items.map((item) => attachProgressToListItem(toListItemBase(item), progressMap)),
+        };
+    }
+    getListItem(id, progressMap = {}) {
+        const item = this.items.find((entry) => entry.id === id);
+        return item ? attachProgressToListItem(toListItemBase(item), progressMap) : null;
+    }
+    isScanning() {
+        return this.scanning;
+    }
+    async scan() {
+        if (this.scanning) {
+            throw new ScanInProgressError();
+        }
+        this.scanning = true;
+        try {
+            this.items = await scanLibrary(this.getConfig());
+        }
+        finally {
+            this.scanning = false;
+        }
+    }
+    tryScan() {
+        if (this.scanning) {
+            return;
+        }
+        void this.scan().catch((error) => {
+            console.error('Library scan failed:', error);
+        });
+    }
+    getItemDetail(id, progressMap = {}) {
+        const item = this.items.find((entry) => entry.id === id);
+        if (!item) {
+            throw new NotFoundError('Item not found');
+        }
+        return attachProgressToDetail(toItemDetailBase(item), progressMap);
+    }
+}

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

@@ -0,0 +1,92 @@
+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 { NotFoundError, ScanInProgressError } from './errors.js';
+import { LibraryService } from './service.js';
+import { writeTestImage } from './test-images.js';
+describe('LibraryService', () => {
+    let tempDir;
+    let novelRoot;
+    let comicRoot;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-service-'));
+        novelRoot = path.join(tempDir, 'novels');
+        comicRoot = path.join(tempDir, 'comics');
+        await mkdir(novelRoot);
+        await mkdir(comicRoot);
+        await writeFile(path.join(novelRoot, 'book.txt'), 'content');
+    });
+    afterEach(async () => {
+        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',
+        }));
+    }
+    it('populates list items after scan', async () => {
+        const service = createService();
+        await service.scan();
+        expect(service.getState()).toEqual({
+            scanning: false,
+            items: [
+                {
+                    id: expect.any(String),
+                    type: 'novel',
+                    title: 'book',
+                    progress: null,
+                },
+            ],
+        });
+    });
+    it('rejects concurrent scan', async () => {
+        const service = 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();
+        await service.scan();
+        const novel = service.getState().items[0];
+        expect(service.getItemDetail(novel.id)).toEqual({
+            id: novel.id,
+            type: 'novel',
+            title: 'book',
+            directoryId: 'novel-root',
+            filename: 'book.txt',
+            progress: null,
+        });
+    });
+    it('returns comic detail for a known id', async () => {
+        const mangaDir = path.join(comicRoot, 'manga');
+        await mkdir(mangaDir);
+        await writeTestImage(path.join(mangaDir, '2.jpg'), 300, 400);
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 400);
+        const service = createService();
+        await service.scan();
+        const comic = service.getState().items.find((item) => item.type === 'comic');
+        expect(comic).toBeDefined();
+        expect(service.getItemDetail(comic.id)).toEqual({
+            id: comic.id,
+            type: 'comic',
+            title: 'manga',
+            directoryId: 'comic-root',
+            pages: ['1.jpg', '2.jpg'],
+            progress: null,
+        });
+        expect(comic).toMatchObject({
+            pageCount: 2,
+            cover: expect.stringMatching(/\/cover\.jpg$/),
+            progress: null,
+        });
+    });
+    it('throws when detail is requested for unknown id', async () => {
+        const service = createService();
+        await service.scan();
+        expect(() => service.getItemDetail('missing')).toThrow(NotFoundError);
+    });
+});

package/bundle/server/dist/library/test-images.js

@@ -0,0 +1,23 @@
+import sharp from 'sharp';
+export async function writeTestImage(filePath, width, height, format = 'jpeg') {
+    let pipeline = sharp({
+        create: {
+            width,
+            height,
+            channels: 3,
+            background: { r: 120, g: 80, b: 200 },
+        },
+    });
+    switch (format) {
+        case 'png':
+            pipeline = pipeline.png();
+            break;
+        case 'webp':
+            pipeline = pipeline.webp();
+            break;
+        default:
+            pipeline = pipeline.jpeg();
+            break;
+    }
+    await pipeline.toFile(filePath);
+}

package/bundle/server/dist/library/text-encoding.js

@@ -0,0 +1,33 @@
+import { rename, writeFile } from 'node:fs/promises';
+const UTF8_BOM = [0xef, 0xbb, 0xbf];
+const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+const gb18030Decoder = new TextDecoder('gb18030');
+function hasUtf8Bom(buffer) {
+    return (buffer.length >= 3 &&
+        buffer[0] === UTF8_BOM[0] &&
+        buffer[1] === UTF8_BOM[1] &&
+        buffer[2] === UTF8_BOM[2]);
+}
+function isValidUtf8(buffer) {
+    try {
+        utf8Decoder.decode(buffer);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function detectTextEncoding(buffer) {
+    if (hasUtf8Bom(buffer) || isValidUtf8(buffer)) {
+        return 'utf-8';
+    }
+    return 'gbk';
+}
+export function convertGbkBufferToUtf8(buffer) {
+    return gb18030Decoder.decode(buffer);
+}
+export async function writeUtf8FileAtomically(filePath, text) {
+    const tempPath = `${filePath}.cyreader-tmp`;
+    await writeFile(tempPath, text, 'utf-8');
+    await rename(tempPath, filePath);
+}

package/bundle/server/dist/library/text-encoding.test.js

@@ -0,0 +1,42 @@
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { convertGbkBufferToUtf8, detectTextEncoding, writeUtf8FileAtomically, } from './text-encoding.js';
+describe('detectTextEncoding', () => {
+    it('detects UTF-8 BOM', () => {
+        const buffer = Buffer.from([0xef, 0xbb, 0xbf, 0x68, 0x69]);
+        expect(detectTextEncoding(buffer)).toBe('utf-8');
+    });
+    it('detects valid UTF-8 ASCII', () => {
+        expect(detectTextEncoding(Buffer.from('hello', 'utf-8'))).toBe('utf-8');
+    });
+    it('detects valid UTF-8 Chinese', () => {
+        expect(detectTextEncoding(Buffer.from('中文', 'utf-8'))).toBe('utf-8');
+    });
+    it('detects GBK bytes', () => {
+        const buffer = Buffer.from([0xd6, 0xd0, 0xce, 0xc4]);
+        expect(detectTextEncoding(buffer)).toBe('gbk');
+    });
+});
+describe('convertGbkBufferToUtf8', () => {
+    it('decodes GBK bytes to UTF-8 string', () => {
+        const buffer = Buffer.from([0xd6, 0xd0, 0xce, 0xc4]);
+        expect(convertGbkBufferToUtf8(buffer)).toBe('中文');
+    });
+});
+describe('writeUtf8FileAtomically', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-text-encoding-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('writes UTF-8 content and removes temp file', async () => {
+        const filePath = path.join(tempDir, 'novel.txt');
+        await writeUtf8FileAtomically(filePath, '中文');
+        expect(await readFile(filePath, 'utf-8')).toBe('中文');
+        await expect(readFile(`${filePath}.cyreader-tmp`, 'utf-8')).rejects.toThrow();
+    });
+});

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

@@ -0,0 +1 @@
+export {};