| const fs = require('fs') |
| const path = require('path') |
| const assert = require('assert') |
| const { assertCode, codePattern, readReaderSource } = require('./reader_source_contract') |
|
|
| const root = path.resolve(__dirname, '..') |
| const readerEntry = fs.readFileSync(path.join(root, 'static/reader.js'), 'utf8') |
| const reader = readReaderSource(root) |
| assert.doesNotMatch(readerEntry, /^\s*(?:async\s+)?function\s+/m) |
| assertCode(readerEntry, 'from "./reader/reader-components.mjs"') |
| const searchController = fs.readFileSync(path.join(root, 'static/reader/search/reader-search-controller.mjs'), 'utf8') |
| assertCode(reader, 'import { createReaderSearchController } from "./reader/search/reader-search-controller.mjs"') |
| assertCode(reader, 'trackReaderResource(fullSearchController.dispose)') |
| assertCode(reader, 'backend: { mode: () => capability.mode, search: searchReaderText') |
| assert.doesNotMatch(reader, /dataset\.panelView\s*=\s*"full-search"/) |
| assert.doesNotMatch(searchController, /new Worker|\bfetch\(|import\(/) |
| const domSearch = fs.readFileSync(path.join(root, 'static/reader/search/reader-dom-search.mjs'), 'utf8') |
| assertCode(reader, 'import { createReaderDomSearch, fullSearchEscape, fullSearchSnippet, fullSearchPageOffset } from "./reader/search/reader-dom-search.mjs"') |
| assertCode(reader, 'trackReaderResource(domSearch.dispose)') |
| assertCode(reader, 'getTocEntries: () => navigationState.tocEntries') |
| assertCode(reader, 'domSearch.pruneMarks()') |
| assert.doesNotMatch(reader, /function (?:fullSearchDomMatches|createDomSearchSnapshot|createFullSearchDomLocator|fullSearchTextNodes|highlightTextParts)\(/) |
| assert.doesNotMatch(domSearch, /new Worker|\bfetch\(|import\(|readerRuntime|navigationState|fullSearchSession|fullSearchStatus/) |
| assertCode(domSearch, 'const stopGeneration = runtime.events.on("generation"') |
| assertCode(domSearch, 'function dispose() { stopGeneration()') |
| assertCode(domSearch, 'publishPage(page(0), page, true)') |
| const imageLoader = fs.readFileSync(path.join(root, 'static/reader/formats/reader-image-loader.mjs'), 'utf8') |
| assertCode(reader, 'import { createReaderImageLoader } from "./reader/formats/reader-image-loader.mjs"') |
| assertCode(reader, 'trackResource: trackReaderResource') |
| assertCode(reader, 'await imageLoader.load(image, target, renderController.signal)') |
| assert.doesNotMatch(reader, /function (?:waitReaderImage|loadReaderImage)\(/) |
| assert.doesNotMatch(imageLoader, /readerRuntime|readerContentUrl|pdfPageManifest|documentState|new Image|import\(/) |
| const css = fs.readFileSync(path.join(root, 'static/reader.css'), 'utf8') |
| const view = fs.readFileSync(path.join(root, 'static/foliate-reader/view.js'), 'utf8') |
| for (const marker of ["import('./epub.js')", "import('./mobi.js')", "import('./fb2.js')", "import('./pdf.js')", "isFBZ(file)", "isFB2(file)"]) assert.ok(view.includes(marker), marker) |
| for (const file of ['epub.js', 'mobi.js', 'fb2.js', 'pdf.js', 'view.js', 'progress.js', 'ui/tree.js']) assert.ok(fs.existsSync(path.join(root, 'static/foliate-reader', file)), file) |
| assert.match(fs.readFileSync(path.join(root, 'static/foliate-reader/mobi.js'), 'utf8'), /createDocument/) |
| assert.match(fs.readFileSync(path.join(root, 'static/foliate-reader/fb2.js'), 'utf8'), /resolveHref/) |
| assert.match(fs.readFileSync(path.join(root, 'static/foliate-reader/epub.js'), 'utf8'), /String\(href \?\? ''\)/) |
| assert.match(fs.readFileSync(path.join(root, 'static/foliate-reader/epub.js'), 'utf8'), /item\.mediaType === MIME\.XHTML/) |
| const foliateReader = fs.readFileSync(path.join(root, 'static/foliate-reader/reader.js'), 'utf8') |
| for (const message of ['voice-foliate-goto-cfi', 'voice-foliate-search', 'voice-foliate-seek', 'voice-foliate-prev', 'voice-foliate-next']) assert.ok(foliateReader.includes(message), message) |
|
|
| assert.strictEqual((reader.match(/async function renderFoliate\(/g) || []).length, 1) |
| assert.strictEqual(reader.includes('renderFoliateClean'), false) |
| assert.strictEqual(reader.includes('renderFoliateLegacy'), false) |
| assert.strictEqual(reader.includes('foliate-continuous'), true) |
| assert.strictEqual(reader.includes('document.querySelector("#toc-list").addEventListener'), false) |
| assert.strictEqual(reader.includes('activateFoliateTocEntryLatest'), false) |
| assert.strictEqual(reader.includes('setupFoliateToc'), false) |
| assert.strictEqual(reader.includes('foliateVisibleSections'), false) |
| assert.strictEqual(reader.includes('foliateVisibleNodes'), false) |
| assert.strictEqual(reader.includes('directFoliateMoving'), false) |
| assert.strictEqual(reader.includes('directFoliateContainer'), false) |
| assert.strictEqual(reader.includes('setInterval(() => { loadNextFoliateSection(); }, 100)'), false) |
| assert.strictEqual(reader.includes('setInterval(() => { const tab = document.querySelector("#toc-tab")'), false) |
| assert.strictEqual(reader.includes('setInterval('), false) |
| assert.match(reader, /function scheduleFoliateScrollSync\(\)/) |
| assert.match(reader, /foliateSectionObserver\?\.disconnect\(\)/) |
| assert.strictEqual((reader.match(/function disposeReader\(\)/g) || []).length, 1) |
| assert.strictEqual((reader.match(/function setReaderPhase\(/g) || []).length, 1) |
| assert.strictEqual((reader.match(/function classifyReaderError\(/g) || []).length, 1) |
| assert.match(reader, /const readerLifecycle = readerRuntime\.state\.lifecycle/) |
| assert.doesNotMatch(reader, /(?:^|\n)\s*let readerStage\b/) |
| assert.match(reader, /readerRuntime\.setStage\(stage\)/) |
| assert.match(reader, /\$\{readerLifecycle\.stage\}/) |
| assertCode(reader, 'function scheduleSave() { if (readerLifecycle.disposed || readerAbortController.signal.aborted) return;') |
| assertCode(reader, 'readerLifecycle.disposed || !documentState.restorationReady') |
| assert.strictEqual((reader.match(/if \(!setReaderPhase\("ready"\)\) return/g) || []).length, 2) |
| assert.match(reader, /addEventListener\("pagehide"/) |
| assert.match(reader, /event\.persisted/) |
| assert.match(reader, /!event\.persisted/) |
| assert.doesNotMatch(reader, /id=["']ocr["']/i) |
| assert.match(reader, /validatePdfPageManifest/) |
| assert.match(reader, /const PDF_PREFETCH_MARGIN = 2400/) |
| assert.match(reader, /const visibleObserver = new IntersectionObserver/) |
| assert.match(reader, /promotePdfRenderWaiter\(shell\)/) |
| assert.match(reader, /function pdfPagePriority\(shell\)/) |
| assert.match(reader, /priority >= 3 \? "high" : priority >= 1 \? "auto" : "low"/) |
| assert.match(reader, /const waiter = \{\s*shell,\s*priority,/) |
| assert.match(reader, /waiter\.shell \? pdfPagePriority\(waiter\.shell\) : waiter\.priority/) |
| assert.match(reader, /function cancelSpeculativePdfRenders\(protectedShell\)/) |
| assert.match(reader, /isPdfPageVisible\(shell\)/) |
| assert.match(reader, /shell\._renderCancel\?\.\(\)/) |
| assert.match(reader, /const PDF_MANIFEST_PREFETCH_LIMIT = 12/) |
| assert.match(reader, /const PDF_MANIFEST_PREFETCH_CONCURRENCY = 3/) |
| assert.match(reader, /function takePdfManifestPrefetch\(target\)/) |
| assert.match(reader, /function schedulePdfManifestPrefetch\(page\)/) |
| assert.match(reader, /image\.fetchPriority = "low"/) |
| assert.match(reader, /pdfManifestPrefetchActive\.add\(record\)/) |
| assert.match(reader, /queuePdfManifestPrefetch\(\)/) |
| const pdfPageRender = reader.match(/function renderPdfManifestShell\(shell, force = false, priority = false\) \{[\s\S]*?\n\}\s+function renderPdfShell/)[0] |
| assert.match(pdfPageRender, /(?:const|let) target = pdfPageManifest\.pageUrl\(entry\.page\)/) |
| assert.doesNotMatch(pdfPageRender, /entry\.j|entry\.w|\.jxl/) |
| assert.match(reader, /chapterManifestObserver\?\.disconnect\(\)/) |
| assert.match(reader, /content\.dataset\.errorCode = code/) |
| assert.match(reader, /reader-request-manager\.js/) |
| assert.match(reader, /VoiceOfMLReaderRequests\.createReaderRequestManager\(\)/) |
| assert.match(reader, /readerRuntime\.track\(readerRequestManager\)/) |
| assert.doesNotMatch(reader, /legacyReaderTitle/) |
| for (const generation of ['navigation', 'search', 'bookmarks', 'pdf']) assert.match(reader, new RegExp(`nextReaderGeneration\\("${generation}"\\)`)) |
| for (const timer of ['saveTimer', 'themeAnimationTimer', 'panelAnimationTimer']) assert.match(reader, new RegExp(`clearTimeout\\(${timer}\\)`)) |
| assertCode(reader, 'for (const frame of [markerFrame, foliateScrollFrame, foliateWindowFrame, epubSeekFrame]) if (frame) cancelAnimationFrame(frame)') |
| assert.match(reader, /trackReaderResource\(destroy\)/) |
| assert.match(reader, /task\.destroy\(\)/) |
| assert.match(reader, /mediaElement\.pause\(\)/) |
| assert.match(reader, /mediaElement\.removeAttribute\("src"\)/) |
| assert.strictEqual(reader.includes('activeReaderControllers'), false) |
| assert.strictEqual(reader.includes('readerRequests'), false) |
| assert.match(reader, /function syncTocTab\(\)/) |
| assert.match(reader, /function applyReaderMetadata\(data\)/) |
| assert.strictEqual((reader.match(/function applyReaderMetadata\(data\)/g) || []).length, 1) |
| const viewportDeclaration = codePattern('const viewport = document.querySelector("#viewport")').exec(reader) |
| const metadataApplication = codePattern('applyReaderMetadata(resolvedReaderData)').exec(reader) |
| assert.ok(viewportDeclaration && metadataApplication && viewportDeclaration.index < metadataApplication.index) |
| assertCode(reader, 'formatAdapters.active.open()') |
| assertCode(reader, 'await formatAdapters.active.render(prepared)') |
| assertCode(reader, 'await applyInitialRestoration(restored, generation)') |
| assertCode(reader, 'await restoreInitialPosition(entry, generation)') |
| assertCode(reader, 'await formatAdapters.active.restore(entry, generation)') |
| assert.match(reader, /const restorationPromise = loadReaderRestoration\(\)/) |
| assert.match(reader, /await formatAdapters\.active\.render\(prepared\)[\s\S]*?const restored = await awaitReader\(restorationPromise\)/) |
| assert.doesNotMatch(reader, /Promise\.all\(\[loadReaderRestoration\(\)/) |
| assert.strictEqual((reader.match(/function loadPdfDocument\(/g) || []).length, 1) |
| for (const renderer of ['renderImageDocument', 'renderMedia']) assert.strictEqual((reader.match(new RegExp(`function ${renderer}\\s*\\(`,'g')) || []).length, 1) |
| for (const renderer of ['renderTextDocument', 'renderMarkdownDocument']) assert.strictEqual((reader.match(new RegExp(`function ${renderer}\\(`,'g')) || []).length, 1) |
| for (const loader of ['loadTextDocument', 'loadMarkdownDocument', 'loadHtmlDocument']) assert.strictEqual((reader.match(new RegExp(`function ${loader}\\(`,'g')) || []).length, 1) |
| for (const loader of ['loadMediaDocument', 'loadImageDocument', 'loadChapterManifestDocument']) assert.strictEqual((reader.match(new RegExp(`function ${loader}\\(`,'g')) || []).length, 1) |
| assert.doesNotMatch(reader, /loadFoliateDocument/) |
| assert.match(reader, /reader-chapter-repository\.js/) |
| assert.match(reader, /reader-scroll-anchor\.js/) |
| assert.match(reader, /reader-section-virtualizer\.js/) |
| assert.match(reader, /VoiceOfMLReaderChapters\.createChapterRepository\(/) |
| assert.match(reader, /VoiceOfMLReaderScroll\.createScrollAnchorManager\(/) |
| assert.match(reader, /VoiceOfMLReaderVirtual\.createSectionVirtualizer\(/) |
| assert.match(reader, /foliateChapterRepository\?\.dispose\(\)/) |
| assertCode(reader, 'readerRuntime.track(VoiceOfMLReaderScroll') |
| assert.match(reader, /foliateSectionVirtualizer\?\.dispose\(\)/) |
| assert.match(reader, /function foliateSectionRoot\(article\)/) |
| assertCode(reader, 'article.attachShadow({ mode: "open" })') |
| assert.match(reader, /event\.composedPath\(\)/) |
| assert.match(reader, /foliateSectionRoot\(node\)/) |
| assert.match(reader, /foliateScrollAnchors\.observe\(article\)/) |
| assert.ok((reader.match(/foliateScrollAnchors\.invalidate\(\)/g) || []).length >= 3) |
| const renderFoliateSource = reader.match(/async\s+function\s+renderFoliate\s*\([\s\S]*?status\.textContent\s*=\s*"EPUB";/)[0] |
| assert.strictEqual(renderFoliateSource.includes('loaded = new Set'), false) |
| assert.strictEqual(renderFoliateSource.includes('pending = new Map'), false) |
| assert.match(reader, /stream\.insertBefore\(article, next \|\| null\)/) |
| assert.match(reader, /foliateSectionLoader\s*=\s*(?:\(index\)|index)\s*=>/) |
| assert.doesNotMatch(reader, /^let navigationGeneration\b/m) |
| assert.doesNotMatch(reader, /syncReaderState/) |
| assert.doesNotMatch(reader, /^(?:let|var|const)\s+title\b/m) |
| for (const mirror of ['zoom', 'currentPage', 'pageCount', 'restoredEntry', 'restorationReady', 'tocEntries', 'currentChapterIndex', 'fullSearchResults', 'fullSearchIndex', 'fullSearchGeneration', 'showingAllBookmarks', 'editingBookmark', 'pdfRenderGeneration']) assert.doesNotMatch(reader, new RegExp(`(?:let|var|const)\\s+${mirror}\\b`), mirror) |
| assert.doesNotMatch(reader, /readerRuntime\.updateFormat\(/) |
| for (const domain of ['document', 'navigation', 'search', 'panel']) assert.match(reader, new RegExp(`readerRuntime\\.state\\.${domain}`)) |
| assert.match(reader, /readerRuntime\.currentGeneration\("pdf"\)/) |
| assertCode(reader, 'nextGeneration: () => nextReaderGeneration("search")') |
| assertCode(searchController, 'const generation = nextGeneration()') |
| assert.match(reader, /isReaderGenerationCurrent\("navigation", generation\)/) |
| assert.match(reader, /registerReaderFormatAdapters\(\)/) |
| assert.match(reader, /function disposeFormatResources\(mode\)/) |
| assertCode(reader, 'link.target = "_blank"; link.rel = "noopener noreferrer"') |
| assert.doesNotMatch(reader, /function (?:navigateFormat|searchFormat)\(/) |
| assert.match(reader, /async function restoreFormat\(mode, entry, generation/) |
| assert.match(reader, /formatAdapters\.activate\(capability\.mode\)/) |
| assert.match(reader, /readerRuntime\.events\.on\("phase"/) |
| assert.strictEqual((reader.match(/function navigateTocEntry\(/g) || []).length, 1) |
| assert.match(reader, /await navigateTocEntry\(index\)/) |
| assert.strictEqual((reader.match(/function navigateFoliateSearchResult\(/g) || []).length, 1) |
| assert.strictEqual((reader.match(/function\s+fullSearchFoliateMatches\s*\(/g) || []).length, 1) |
| assertCode(reader, 'publishSearchResults(generation, await fullSearchFoliateMatches(query, generation))') |
| assert.match(reader, /function captureFoliateBookmarkPosition\(\)/) |
| assert.match(reader, /function restoreFoliateBookmarkPosition\(entry, generation/) |
| assert.match(reader, /foliatePosition = captureFoliateBookmarkPosition\(\)/) |
| assert.match(reader, /new IntersectionObserver/) |
| assert.doesNotMatch(reader, /article\.innerHTML = styles \+/) |
| assert.match(reader, /target = await epubRendition\?\.book\?\.resolveHref/) |
| assert.match(reader, /applyReaderMetadata\(resolvedReaderData\)/) |
| assert.match(css, /\.foliate-continuous\s+a\s*\{\s*color:\s*#8ab4e8\s*!important;\s*\}/) |
| assert.match(css, /min-height:\s*0\s*!important;\s*height:\s*auto\s*!important;/) |
| assert.strictEqual(view.includes('.find(x => x.index = resolved.index)'), false) |
| assert.strictEqual(view.includes('.find(x => x.index === resolved.index)'), true) |
| const vm = require('vm') |
| const priorityFunctions = reader.match(/function pdfPagePriority\(shell\) \{[\s\S]*?\n\}\s+function normalizePdfPriority\(priority\) \{[\s\S]*?\n\}/) |
| assert.ok(priorityFunctions, 'PDF page priority functions') |
| const priorityContext = { viewport: { getBoundingClientRect: () => ({ top: 0, bottom: 100 }) }, PDF_PREFETCH_MARGIN: 2400 } |
| vm.runInNewContext(priorityFunctions[0], priorityContext) |
| for (const [top, bottom, expected] of [[10, 90, 3], [70, 160, 2], [110, 190, 1], [2600, 2800, 0]]) |
| assert.strictEqual(priorityContext.pdfPagePriority({ getBoundingClientRect: () => ({ top, bottom }) }), expected) |
| assert.strictEqual(priorityContext.normalizePdfPriority(true), 3) |
| const sandbox = { self: {} }; sandbox.self = sandbox; |
| const frontMatterSource = fs.readFileSync(path.join(root, 'static/reader/formats/reader-html-format.mjs'), 'utf8') |
| const frontMatterStart = frontMatterSource.indexOf('export function stripMarkdownFrontMatter') |
| const frontMatterEnd = frontMatterSource.indexOf('\n}\n', frontMatterStart) |
| assert.ok(frontMatterStart >= 0 && frontMatterEnd > frontMatterStart, 'Markdown front matter helper') |
| const frontMatterContext = {} |
| vm.runInNewContext( |
| frontMatterSource.slice(frontMatterStart, frontMatterEnd + 3).replace(/^export /, '') + |
| ';this.stripMarkdownFrontMatter = stripMarkdownFrontMatter;', |
| frontMatterContext |
| ) |
| const stripFrontMatter = frontMatterContext.stripMarkdownFrontMatter |
| for (const [input, expected] of [ |
| ['---\ntitle: "标题"\nauthor: "作者"\nsection: "分类"\ndate: "日期"\nsource: "https://example.invalid"\nsource_path: "chinese/a.htm"\n---\n# 正文\n', '# 正文\n'], |
| ['\uFEFF---\r\ntitle: "T"\r\n---\r\n正文', '正文'], |
| ['---\ntitle: "T"\n---', ''], |
| ['---\n\n---\n# Body', '---\n\n---\n# Body'], |
| ['# Body\n---\n', '# Body\n---\n'], |
| ['---\ntitle: "T"\n', '---\ntitle: "T"\n'], |
| ]) assert.strictEqual(stripFrontMatter(input), expected) |
| assert.match(reader, /marked\.parse\(stripMarkdownFrontMatter\(text\)\)/) |
| function loadExports(file, name) { vm.runInNewContext(fs.readFileSync(path.join(root, 'static', file), 'utf8'), sandbox); return sandbox[name]; } |
| const contractFeatures = loadExports('reader/core/reader-contract.js', 'VoiceOfMLReader').features |
| const runtimeMatrix = loadExports('reader/core/reader-runtime.js', 'VoiceOfMLReaderRuntime').FEATURE_MATRIX |
| assert.strictEqual(runtimeMatrix, contractFeatures) |
| for (const mode of Object.keys(contractFeatures)) assert.strictEqual(JSON.stringify(runtimeMatrix[mode]), JSON.stringify(contractFeatures[mode]), mode) |
| assert.strictEqual(JSON.stringify(runtimeMatrix.unsupported), JSON.stringify({ toc: false, search: false, zoom: false, bookmarks: false, pagination: false, media: false })) |
| |
| |
| const registry = reader.match(/function\s+registerReaderFormatAdapters\s*\(\)\s*\{[\s\S]*?\n\}/) |
| assert.ok(registry, 'format adapter registry') |
| const expected = { |
| pdf: ['loadPdfDocument', 'renderPdf'], image: ['loadImageDocument', 'renderImageDocument'], |
| text: ['loadTextDocument', 'renderTextDocument'], markdown: ['loadMarkdownDocument', 'renderMarkdownDocument'], |
| html: ['loadHtmlDocument', 'renderHtml'], 'epub-chapters': ['loadChapterManifestDocument', 'renderChapterManifest'], |
| foliate: ['loadMediaDocument', 'renderFoliate'], |
| swf: ['loadSwfDocument', 'renderSwf'], |
| } |
| const registered = new Map(), calls = [] |
| const registryContext = { formatAdapters: { register: (mode, adapter) => registered.set(mode, adapter) } } |
| for (const name of [...new Set(Object.values(expected).flat()), 'preloadPdfFirstPage', 'fetchReaderResponse', 'renderPdfPages', 'renderImagePages', 'renderMedia', 'restoreFormat', 'disposeFormatResources']) registryContext[name] = (...args) => calls.push([name, ...args]) |
| vm.runInNewContext(registry[0] + '; registerReaderFormatAdapters();', registryContext) |
| assert.deepStrictEqual([...registered.keys()].sort(), [...Object.keys(expected), 'pdf-pages', 'image-pages', 'audio', 'video'].sort()) |
| for (const [mode, [open, render]] of Object.entries(expected)) { |
| assert.strictEqual(registered.get(mode).open, registryContext[open], mode + ' loader') |
| assert.strictEqual(registered.get(mode).render, registryContext[render], mode + ' renderer') |
| } |
| registered.get('pdf-pages').open() |
| assert.deepStrictEqual(calls.splice(0), [['fetchReaderResponse']]) |
| assert.match(reader, /const initialPage = initialReaderPage\(totalPages\);[\s\S]*?await preloadPdfFirstPage\(totalPages\)/) |
| assert.strictEqual(registered.get('pdf-pages').render, registryContext.renderPdfPages) |
| registered.get('image-pages').open() |
| assert.deepStrictEqual(calls.splice(0), [['fetchReaderResponse']]) |
| assert.strictEqual(registered.get('image-pages').render, registryContext.renderImagePages) |
| for (const mode of ['audio', 'video']) { |
| assert.strictEqual(registered.get(mode).open, registryContext.loadMediaDocument) |
| registered.get(mode).render() |
| assert.deepStrictEqual(calls.splice(0), [['renderMedia', mode]]) |
| } |
| for (const [mode, adapter] of registered) { |
| const entry = { page: 2 } |
| adapter.restore(entry, 17) |
| adapter.dispose() |
| assert.deepStrictEqual(calls.splice(0), [['restoreFormat', mode, entry, 17], ['disposeFormatResources', mode]]) |
| } |
| const html = fs.readFileSync(path.join(root, 'static/reader.html'), 'utf8') |
| const securityScript = html.indexOf('src="/static/reader/core/reader-security.js"') |
| assert.ok(securityScript >= 0 && securityScript < html.indexOf('src="/static/reader/core/reader-contract.js"')) |
| assert.match(reader, /readerRuntime\.track\(window\.__VOICE_PDF_PRELOAD__\)/) |
| console.log('reader architecture contracts passed') |
|
|
