“
+
+
+
+
+
+
+
+
+
+
+
+ 
First
++
+
\u200b
+\u00a0
+Second
+ `); + + const iterator = await ParagraphIterator.createAsync(doc, 1000); + + expect(iterator.length).toBe(2); + expect(iterator.first()?.toString()).toContain('First'); + expect(iterator.next()?.toString()).toContain('Second'); + }); + + it('keeps paragraphs with non-text content', async () => { + const doc = createDoc(` +Intro
+
Outro
+ `); + + const iterator = await ParagraphIterator.createAsync(doc, 1000); + + expect(iterator.length).toBe(3); + + iterator.first(); + expect(iterator.current()?.toString()).toContain('Intro'); + + const imageRange = iterator.next(); + const fragment = imageRange?.cloneContents(); + expect(fragment?.querySelector('img')).not.toBeNull(); + + expect(iterator.next()?.toString()).toContain('Outro'); + }); +}); diff --git a/apps/readest-app/src/utils/paragraph.ts b/apps/readest-app/src/utils/paragraph.ts index 65c8c8625b3e76a6d75457adf56e1e83cb0bceab..8ad801090946f23c6cfaa65e46a250c4f4650c0e 100644 --- a/apps/readest-app/src/utils/paragraph.ts +++ b/apps/readest-app/src/utils/paragraph.ts @@ -31,16 +31,19 @@ const blockTags = new Set([ const MAX_BLOCKS = 5000; +const INVISIBLE_TEXT_PATTERN = + /[\s\u00a0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\u200b-\u200d\u2060\ufeff]/g; +const MEDIA_SELECTOR = 'img, svg, video, audio, canvas, math, iframe, object, embed, hr'; + +const hasMeaningfulText = (text?: string | null): boolean => + (text ?? '').replace(INVISIBLE_TEXT_PATTERN, '').length > 0; + const rangeHasContent = (range: Range): boolean => { try { - const container = range.commonAncestorContainer; - if (container.nodeType === Node.TEXT_NODE) { - return (container.textContent?.trim().length ?? 0) > 0; - } - if (container.nodeType === Node.ELEMENT_NODE) { - return (container as Element).textContent?.trim().length !== 0; - } - return true; + const text = range.toString(); + if (hasMeaningfulText(text)) return true; + const fragment = range.cloneContents(); + return !!fragment.querySelector?.(MEDIA_SELECTOR); } catch { return false; } @@ -48,7 +51,7 @@ const rangeHasContent = (range: Range): boolean => { const hasDirectText = (node: Element): boolean => Array.from(node.childNodes).some( - (child) => child.nodeType === Node.TEXT_NODE && child.textContent?.trim(), + (child) => child.nodeType === Node.TEXT_NODE && hasMeaningfulText(child.textContent), ); const hasBlockChild = (node: Element): boolean => diff --git a/apps/readest-app/src/utils/style.ts b/apps/readest-app/src/utils/style.ts index 5a8c036f76f12e3d82a363376674dfc31727edbb..d9ea27589146c1eae019a1fe353535484bf92b8a 100644 --- a/apps/readest-app/src/utils/style.ts +++ b/apps/readest-app/src/utils/style.ts @@ -867,10 +867,16 @@ export const applyTableStyle = (document: Document) => { table.style.width = `calc(min(${computedWidth}, var(--available-width)))`; } } + const parentWidth = window.getComputedStyle(parent as Element).width; + const parentContainerWidth = parseFloat(parentWidth) || 0; if (totalTableWidth > 0) { const scale = `calc(min(1, var(--available-width) / ${totalTableWidth}))`; table.style.transformOrigin = 'left top'; table.style.transform = `scale(${scale})`; + } else if (parentContainerWidth > 0) { + const scale = `calc(min(1, var(--available-width) / ${parentContainerWidth}))`; + table.style.transformOrigin = 'center top'; + table.style.transform = `scale(${scale})`; } }); }; diff --git a/packages/foliate-js/.gitattributes b/packages/foliate-js/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..50f960ce7feb5cd9616f9c23014c9637015c162d --- /dev/null +++ b/packages/foliate-js/.gitattributes @@ -0,0 +1 @@ +vendor/** linguist-vendored=true diff --git a/packages/foliate-js/.github/FUNDING.yml b/packages/foliate-js/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..4e1fc87959c97007ff9e71681f7f7c5e338c0330 --- /dev/null +++ b/packages/foliate-js/.github/FUNDING.yml @@ -0,0 +1 @@ +buy_me_a_coffee: johnfactotum diff --git a/packages/foliate-js/.github/workflows/eslint.yml b/packages/foliate-js/.github/workflows/eslint.yml new file mode 100644 index 0000000000000000000000000000000000000000..2333777cbee0276b334826144dd77cf5f1121dd1 --- /dev/null +++ b/packages/foliate-js/.github/workflows/eslint.yml @@ -0,0 +1,50 @@ +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. +# ESLint is a tool for identifying and reporting on patterns +# found in ECMAScript/JavaScript code. +# More details at https://github.com/eslint/eslint +# and https://eslint.org + +name: ESLint + +on: + push: + branches: [ "main" ] + pull_request: + # The branches below must be a subset of the branches above + branches: [ "main" ] + schedule: + - cron: '27 12 * * 1' + +jobs: + eslint: + name: Run eslint scanning + runs-on: ubuntu-latest + permissions: + contents: read + security-events: write + actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Install ESLint + run: | + npm install eslint@9.28.0 + npm install @microsoft/eslint-formatter-sarif@3.1.0 + + - name: Run ESLint + env: + SARIF_ESLINT_IGNORE_SUPPRESSED: "true" + run: npx eslint . + --format @microsoft/eslint-formatter-sarif + --output-file eslint-results.sarif + continue-on-error: true + + - name: Upload analysis results to GitHub + uses: github/codeql-action/upload-sarif@v3 + with: + sarif_file: eslint-results.sarif + wait-for-processing: true diff --git a/packages/foliate-js/.gitignore b/packages/foliate-js/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..c2658d7d1b31848c3b71960543cb0368e56cd4c7 --- /dev/null +++ b/packages/foliate-js/.gitignore @@ -0,0 +1 @@ +node_modules/ diff --git a/packages/foliate-js/LICENSE b/packages/foliate-js/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..5930571b73151702a913179ef5f96313ad7d25d3 --- /dev/null +++ b/packages/foliate-js/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 John Factotum + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/foliate-js/README.md b/packages/foliate-js/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a3fe2d51104c4de6b4d116138c72ea0376f2176f --- /dev/null +++ b/packages/foliate-js/README.md @@ -0,0 +1,374 @@ +# foliate-js + +Library for rendering e-books in the browser. + +Features: +- Supports EPUB, MOBI, KF8 (AZW3), FB2, CBZ, PDF (experimental; requires PDF.js) +- Add support for other formats yourself by implementing the book interface +- Pure JavaScript +- Small and modular +- No hard dependencies +- Does not require loading whole file into memory +- Does not care about older browsers + +## Demo + +The repo includes a demo viewer that can be used to open local files. To use it, serve the files with a server, and navigate to `reader.html`. Or visit the [online demo](https://johnfactotum.github.io/foliate-js/reader.html) hosted on GitHub. Note that it is very incomplete at the moment, and lacks many basic features such as keyboard shortcuts. + +Also note that deobfuscating fonts with the IDPF algorithm requires a SHA-1 function. By default it uses Web Crypto, which is only available in secure contexts. Without HTTPS, you will need to modify `reader.js` and pass your own SHA-1 implementation. + +## Current Status + +It works reasonably well, and has been used in several stable releases of [Foliate](https://github.com/johnfactotum/foliate). This library itself is, however, *not* stable. Expect it to break and the API to change at any time. Use it at your own risk. + +If you do decide to use it, since there's no release yet, it is recommended that you include the library as a git submodule in your project so that you can easily update it. + +## Documentation + +### Overview + +This project uses native ES modules. There's no build step, and you can import them directly. + +There are mainly three kinds of modules: + +- Modules that parse and load books, implementing the "book" interface + - `comic-book.js`, for comic book archives (CBZ) + - `epub.js` and `epubcfi.js`, for EPUB + - `fb2.js`, for FictionBook 2 + - `mobi.js`, for both Mobipocket files and KF8 (commonly known as AZW3) files +- Modules that handle pagination, implementing the "renderer" interface + - `fixed-layout.js`, for fixed layout books + - `paginator.js`, for reflowable books +- Auxiliary modules used to add additional functionalities + - `overlayer.js`, for rendering annotations + - `progress.js`, for getting reading progress + - `search.js`, for searching + +The modules are designed to be modular. In general, they don't directly depend on each other. Instead they depend on certain interfaces, detailed below. The exception is `view.js`. It is the higher level renderer that strings most of the things together, and you can think of it as the main entry point of the library. See "Basic Usage" below. + +The repo also includes a still higher level reader, though strictly speaking, `reader.html` (along with `reader.js` and its associated files in `ui/`) is not considered part of the library itself. It's akin to [Epub.js Reader](https://github.com/futurepress/epubjs-reader). You are expected to modify it or replace it with your own code. + +### Basic Usage + +To get started, clone the repo and import `view.js`: + +```js +import './foliate-js/view.js' + +const view = document.createElement('foliate-view') +document.body.append(view) + +view.addEventListener('relocate', e => { + console.log('location changed') + console.log(e.detail) +}) + +// can open a File/Blob object or a URL +// or any object that implements the "book" interface +await view.open('example.epub') +await view.goTo(/* path, section index, or CFI */) +``` + +See the [online demo](https://johnfactotum.github.io/foliate-js/reader.html) for a more advanced example. + +### Security + +EPUB books can contain [scripted content](https://www.w3.org/TR/epub/#sec-scripted-content) (i.e. JavaScript in the e-book), which is potentially dangerous, and is not supported by this library because + +- It is currently impossible to do so securely due to the content being served from the same origin (using `blob:` URLs). +- Due to [WebKit Bug 218086](https://bugs.webkit.org/show_bug.cgi?id=218086), the `allow-scripts` attribute is required on iframes, which renders iframe sandbox useless. + +It is therefore imperative that you use [Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) to block all scripts except `'self'`. An EPUB file for testing can be found at https://github.com/johnfactotum/epub-test. + +> [!CAUTION] +> Do NOT use this library (or any other e-book library, for that matter) without CSP unless you completely trust the content you're rendering or can block scripts by other means. + +### The Main Interface for Books + +Processors for each book format return an object that implements the following interface: +- `.sections`: an array of sections in the book. Each item has the following properties: + - `.load()`: returns a string containing the URL that will be rendered. May be async. + - `.unload()`: returns nothing. If present, can be used to free the section. + - `.createDocument()`: returns a `Document` object of the section. Used for searching. May be async. + - `.size`: a number, the byte size of the section. Used for showing reading progress. + - `.linear`: a string. If it is `"no"`, the section is not part of the linear reading sequence (see the [`linear`](https://www.w3.org/publishing/epub32/epub-packages.html#attrdef-itemref-linear) attribute in EPUB). + - `.cfi`: base CFI string of the section. The part that goes before the `!` in CFIs. + - `.id`: an identifier for the section, used for getting TOC item (see below). Can be anything, as long as they can be used as keys in a `Map`. +- `.dir`: a string representing the page progression direction of the book (`"rtl"` or `"ltr"`). +- `.toc`: an array representing the table of contents of the book. Each item has + - `.label`: a string label for the item + - `.href`: a string representing the destination of the item. Does not have to be a valid URL. + - `.subitems`: a array that contains TOC items +- `.pageList`: same as the TOC, but for the [page list](https://www.w3.org/publishing/epub32/epub-packages.html#sec-nav-pagelist). +- `.metadata`: an object representing the metadata of the book. Currently, it follows more or less the metadata schema of [Readium's webpub manifest](https://github.com/readium/webpub-manifest). Note that titles and names can be a string or an object like `{ ja: "草枕", en: 'Kusamakura' }`, and authors, etc. can be a string, an object, or an array of strings or objects. +- `.rendition`: an object that contains properties that correspond to the [rendition properties](https://www.w3.org/publishing/epub32/epub-packages.html#sec-package-metadata-rendering) in EPUB. If `.layout` is `"pre-paginated"`, the book is rendered with the fixed layout renderer. +- `.resolveHref(href)`: given an href string, returns an object representing the destination referenced by the href, which has the following properties: + - `.index`: the index of the referenced section in the `.section` array + - `.anchor(doc)`: given a `Document` object, returns the document fragment referred to by the href (can either be an `Element` or a `Range`), or `null` +- `.resolveCFI(cfi)`: same as above, but with a CFI string instead of href +- `.isExternal(href)`: returns a boolean. If `true`, the link should be opened externally. + +The following methods are consumed by `progress.js`, for getting the correct TOC and page list item when navigating: +- `.splitTOCHref(href)`: given an href string (from the TOC), returns an array, the first element of which is the `id` of the section (see above), and the second element is the fragment identifier (can be any type; see below). May be async. +- `.getTOCFragment(doc, id)`: given a `Document` object and a fragment identifier (the one provided by `.splitTOCHref()`; see above), returns a `Node` representing the target linked by the TOC item + +In addition, the `.transformTarget`, if present, can be used to transform the contents of the book as it loads. It is an `EventTarget` with a custom event `"data"`, whose `.detail` is `{ data, type, name }`, where `.data` is either a string or `Blob`, or a `Promise` thereof, `.type` the content type string, and `.name` the identifier of the resource. Event handlers should mutate `.data` to transform the data. + +Almost all of the properties and methods are optional. At minimum it needs `.sections` and the `.load()` method for the sections, as otherwise there won't be anything to render. + +### Archived Files + +Reading Zip-based formats requires adapting an external library. Both `epub.js` and `comic-book.js` expect a `loader` object that implements the following interface: + +- `.entries`: (only used by `comic-book.js`) an array, each element of which has a `filename` property, which is a string containing the filename (the full path). +- `.loadText(filename)`: given the path, returns the contents of the file as string. May be async. +- `.loadBlob(filename)`: given the path, returns the file as a `Blob` object. May be async. +- `.getSize(filename)`: returns the file size in bytes. Used to set the `.size` property for `.sections` (see above). + +In `view.js`, this is implemented using [zip.js](https://github.com/gildas-lormeau/zip.js), which is highly recommended because it seems to be the only library that supports random access for `File` objects (as well as HTTP range requests). + +One advantage of having such an interface is that one can easily use it for reading unarchived files as well. For example, `view.js` has a loader that allows you to open unpacked EPUBs as directories. + +### Mobipocket and Kindle Files + +It can read both MOBI and KF8 (.azw3, and combo .mobi files) from a `File` (or `Blob`) object. For MOBI files, it decompresses all text at once and splits the raw markup into sections at every `Or to open it.
+…
+…
+…
+…
+xxxyyy0123456789
+…
+…
+
+ …
+…
+ +`) + + // the exact same page with some text nodes removed, CDATA & comment added, + // and characters changed to entities + const page2 = XHTML(` + +…
…
…
…
+xxxyyy4589
+…
+…
+
+ …
+…
+ +`) + + // the exact same page with nodes are to be ignored + const page3 = XHTML(` + +Also ignored
+…
…
…
…
+xxxyyyNote: we put ignored text in this span but not the other ones because although the CFI library should ignore them, they won't be ignored by DOM Ranges, which will break the tests.012345
6789
…
+…
+
+ …
+…
+…
+…
+…
+…
+xxxyyy0123456789
+…
+…
+
+ …
+…
+ +`) + + for (const cfi of [ + '/4[body0^]!/1^^]/10[para^]/0^,/5]/3:10', + '/4[body0^]!/1^^]/16[s^]^[vgimg]', + '/4[body0^]!/1^^]/10[para^]/0^,/5]/1:0', + '/4[body0^]!/1^^]/10[para^]/0^,/5]/2/1:0', + '/4[body0^]!/1^^]/10[para^]/0^,/5]/2/1:3', + ]) { + const range = CFI.toRange(page, CFI.parse(cfi)) + const a = CFI.fromRange(range) + const b = `epubcfi(${cfi})` + console.assert(a === b, `expected ${b}, got ${a}`) + } + for (let i = 0; i < 10; i++) { + const cfi = `/4[body0^]!/1^^]/10[para^]/0^,^/5],/3:${i},/3:${i+1}` + const range = CFI.toRange(page, CFI.parse(cfi)) + const n = `${i}` + console.assert(range.toString() === n, `expected ${n}, got ${range}`) + } +} + +{ + for (const [a, b, c] of [ + ['/6/4!/10', '/6/4!/10', 0], + ['/6/4!/2/3:0', '/6/4!/2', 1], + ['/6/4!/2/4/6/8/10/3:0', '/6/4!/4', -1], + [ + '/6/4[chap0^]!/1ref^^]!/4[body01^^]/10[para^]^,05^^]', + '/6/4!/4/10', + 0, + ], + [ + '/6/4[chap0^]!/1ref^^]!/4[body01^^],/10[para^]^,05^^],/15:10[foo^]]', + '/6/4!/4/12', + -1, + ], + ['/6/4', '/6/4!/2', -1], + ['/6/4!/2', '/6/4!/2!/2', -1], + ]) { + const x = CFI.compare(a, b) + console.assert(x === c, `compare ${a} and ${b}, expected ${c}, got ${x}`) + } +} diff --git a/packages/foliate-js/tests/tests.html b/packages/foliate-js/tests/tests.html new file mode 100644 index 0000000000000000000000000000000000000000..2652dab98f49d47c19460fdb563be27b416d194a --- /dev/null +++ b/packages/foliate-js/tests/tests.html @@ -0,0 +1,5 @@ + + + + + diff --git a/packages/foliate-js/tests/tests.js b/packages/foliate-js/tests/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..c0227f1d27611725b7c539aba5d2107c9c2cd8c3 --- /dev/null +++ b/packages/foliate-js/tests/tests.js @@ -0,0 +1 @@ +import './epubcfi-tests.js' diff --git a/packages/foliate-js/text-walker.js b/packages/foliate-js/text-walker.js new file mode 100644 index 0000000000000000000000000000000000000000..c1249b79c6beca30e8f4d27e96cd05fa869ef67b --- /dev/null +++ b/packages/foliate-js/text-walker.js @@ -0,0 +1,43 @@ +const walkRange = (range, walker) => { + const nodes = [] + for (let node = walker.currentNode; node; node = walker.nextNode()) { + const compare = range.comparePoint(node, 0) + if (compare === 0) nodes.push(node) + else if (compare > 0) break + } + return nodes +} + +const walkDocument = (_, walker) => { + const nodes = [] + for (let node = walker.nextNode(); node; node = walker.nextNode()) + nodes.push(node) + return nodes +} + +const filter = NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT + | NodeFilter.SHOW_CDATA_SECTION + +const acceptNode = node => { + if (node.nodeType === 1) { + const name = node.tagName.toLowerCase() + if (name === 'script' || name === 'style') return NodeFilter.FILTER_REJECT + return NodeFilter.FILTER_SKIP + } + return NodeFilter.FILTER_ACCEPT +} + +export const textWalker = function* (x, func, filterFunc) { + const root = x.commonAncestorContainer ?? x.body ?? x + const walker = document.createTreeWalker(root, filter, { acceptNode: filterFunc || acceptNode }) + const walk = x.commonAncestorContainer ? walkRange : walkDocument + const nodes = walk(x, walker) + const strs = nodes.map(node => node.nodeValue ?? '') + const makeRange = (startIndex, startOffset, endIndex, endOffset) => { + const range = document.createRange() + range.setStart(nodes[startIndex], startOffset) + range.setEnd(nodes[endIndex], endOffset) + return range + } + for (const match of func(strs, makeRange)) yield match +} diff --git a/packages/foliate-js/tts.js b/packages/foliate-js/tts.js new file mode 100644 index 0000000000000000000000000000000000000000..ca75cc0505b7d14c551130bad6e8c4b21673cc9d --- /dev/null +++ b/packages/foliate-js/tts.js @@ -0,0 +1,377 @@ +const NS = { + XML: 'http://www.w3.org/XML/1998/namespace', + SSML: 'http://www.w3.org/2001/10/synthesis', +} + +const blockTags = new Set([ + 'article', 'aside', 'audio', 'blockquote', 'caption', + 'details', 'dialog', 'div', 'dl', 'dt', 'dd', + 'figure', 'footer', 'form', 'figcaption', + 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'li', + 'main', 'math', 'nav', 'ol', 'p', 'pre', 'section', 'tr', +]) + +const getLang = el => { + const x = el.lang || el?.getAttributeNS?.(NS.XML, 'lang') + return x ? x : el.parentElement ? getLang(el.parentElement) : null +} + +const getAlphabet = el => { + const x = el?.getAttributeNS?.(NS.XML, 'lang') + return x ? x : el.parentElement ? getAlphabet(el.parentElement) : null +} + +const getSegmenter = (lang = 'en', granularity = 'word') => { + const segmenter = new Intl.Segmenter(lang, { granularity }) + const granularityIsWord = granularity === 'word' + return function* (strs, makeRange) { + const str = strs.join('').replace(/\r\n/g, ' ').replace(/\r/g, ' ').replace(/\n/g, ' ') + let name = 0 + let strIndex = -1 + let sum = 0 + const rawSegments = Array.from(segmenter.segment(str)) + const mergedSegments = [] + for (let i = 0; i < rawSegments.length; i++) { + const current = rawSegments[i] + const next = rawSegments[i + 1] + const segment = current.segment.trim() + const nextSegment = next?.segment?.trim() + const endsWithAbbr = /(?:^|\s)([A-Z][a-z]{1,5})\.$/.test(segment) + const nextStartsWithCapital = /^[A-Z]/.test(nextSegment || '') + if ((endsWithAbbr && nextStartsWithCapital) || segment.length <= 3) { + const mergedSegment = { + index: current.index, + segment: current.segment + (next?.segment || ''), + isWordLike: true, + } + mergedSegments.push(mergedSegment) + i++ + } else { + mergedSegments.push(current) + } + } + for (const { index, segment, isWordLike } of mergedSegments) { + if (granularityIsWord && !isWordLike) continue + while (sum <= index) sum += strs[++strIndex].length + const startIndex = strIndex + const startOffset = index - (sum - strs[strIndex].length) + const end = index + segment.length - 1 + if (end < str.length) while (sum <= end) sum += strs[++strIndex].length + const endIndex = strIndex + const endOffset = end - (sum - strs[strIndex].length) + 1 + yield [(name++).toString(), + makeRange(startIndex, startOffset, endIndex, endOffset)] + } + } +} + +const fragmentToSSML = (fragment, nodeFilter, inherited) => { + const ssml = document.implementation.createDocument(NS.SSML, 'speak') + const { lang } = inherited + if (lang) ssml.documentElement.setAttributeNS(NS.XML, 'lang', lang) + + const convert = (node, parent, inheritedAlphabet) => { + if (!node) return + if (node.nodeType === 3) return ssml.createTextNode(node.textContent) + if (node.nodeType === 4) return ssml.createCDATASection(node.textContent) + if (node.nodeType !== 1 && node.nodeType !== 11) return + if (nodeFilter && nodeFilter(node) === NodeFilter.FILTER_REJECT) return + + let el + const nodeName = node.nodeName.toLowerCase() + if (nodeName === 'foliate-mark') { + el = ssml.createElementNS(NS.SSML, 'mark') + el.setAttribute('name', node.dataset.name) + } + else if (nodeName === 'br') + el = ssml.createElementNS(NS.SSML, 'break') + else if (nodeName === 'em' || nodeName === 'strong') + el = ssml.createElementNS(NS.SSML, 'emphasis') + + const lang = node.lang || node.getAttributeNS?.(NS.XML, 'lang') + if (lang) { + if (!el) el = ssml.createElementNS(NS.SSML, 'lang') + el.setAttributeNS(NS.XML, 'lang', lang) + } + + const alphabet = node.getAttributeNS?.(NS.SSML, 'alphabet') || inheritedAlphabet + if (!el) { + const ph = node.getAttributeNS?.(NS.SSML, 'ph') + if (ph) { + el = ssml.createElementNS(NS.SSML, 'phoneme') + if (alphabet) el.setAttribute('alphabet', alphabet) + el.setAttribute('ph', ph) + } + } + + if (!el) el = parent + + let child = node.firstChild + while (child) { + const childEl = convert(child, el, alphabet) + if (childEl && el !== childEl) el.append(childEl) + child = child.nextSibling + } + return el + } + convert(fragment, ssml.documentElement, inherited.alphabet) + return ssml +} + +const getFragmentWithMarks = (range, textWalker, nodeFilter, granularity) => { + const lang = getLang(range.commonAncestorContainer) + const alphabet = getAlphabet(range.commonAncestorContainer) + + const segmenter = getSegmenter(lang, granularity) + const fragment = range.cloneContents() + + // we need ranges on both the original document (for highlighting) + // and the document fragment (for inserting marks) + // so unfortunately need to do it twice, as you can't copy the ranges + const entries = [...textWalker(range, segmenter, nodeFilter)] + const fragmentEntries = [...textWalker(fragment, segmenter, nodeFilter)] + + for (const [name, range] of fragmentEntries) { + const mark = document.createElement('foliate-mark') + mark.dataset.name = name + range.insertNode(mark) + } + const ssml = fragmentToSSML(fragment, nodeFilter, { lang, alphabet }) + return { entries, ssml } +} + +const rangeIsEmpty = range => !range.toString().trim() + +function* getBlocks(doc) { + let last + const walker = doc.createTreeWalker(doc.body, NodeFilter.SHOW_ELEMENT) + for (let node = walker.nextNode(); node; node = walker.nextNode()) { + const name = node.tagName.toLowerCase() + if (blockTags.has(name)) { + if (last) { + last.setEndBefore(node) + if (!rangeIsEmpty(last)) yield last + } + last = doc.createRange() + last.setStart(node, 0) + } + } + if (!last) { + last = doc.createRange() + last.setStart(doc.body.firstChild ?? doc.body, 0) + } + last.setEndAfter(doc.body.lastChild ?? doc.body) + if (!rangeIsEmpty(last)) yield last +} + +class ListIterator { + #arr = [] + #iter + #index = -1 + #f + constructor(iter, f = x => x) { + this.#iter = iter + this.#f = f + } + current() { + if (this.#arr[this.#index]) return this.#f(this.#arr[this.#index]) + } + first() { + const newIndex = 0 + if (this.#arr[newIndex]) { + this.#index = newIndex + return this.#f(this.#arr[newIndex]) + } + } + prev() { + const newIndex = this.#index - 1 + if (this.#arr[newIndex]) { + this.#index = newIndex + return this.#f(this.#arr[newIndex]) + } + } + next() { + const newIndex = this.#index + 1 + if (this.#arr[newIndex]) { + this.#index = newIndex + return this.#f(this.#arr[newIndex]) + } + while (true) { + const { done, value } = this.#iter.next() + if (done) break + this.#arr.push(value) + if (this.#arr[newIndex]) { + this.#index = newIndex + return this.#f(this.#arr[newIndex]) + } + } + } + find(f) { + const index = this.#arr.findIndex(x => f(x)) + if (index > -1) { + this.#index = index + return this.#f(this.#arr[index]) + } + while (true) { + const { done, value } = this.#iter.next() + if (done) break + this.#arr.push(value) + if (f(value)) { + this.#index = this.#arr.length - 1 + return this.#f(value) + } + } + } +} + +export class TTS { + #list + #ranges + #lastMark + #serializer = new XMLSerializer() + constructor(doc, textWalker, nodeFilter, highlight, granularity) { + this.doc = doc + this.highlight = highlight + this.#list = new ListIterator(getBlocks(doc), range => { + const { entries, ssml } = getFragmentWithMarks(range, textWalker, nodeFilter, granularity) + this.#ranges = new Map(entries) + return [ssml, range] + }) + } + #getMarkElement(doc, mark) { + if (!mark) return null + return doc.querySelector(`mark[name="${CSS.escape(mark)}"`) + } + #speak(doc, getNode) { + if (!doc) return + if (!getNode) return this.#serializer.serializeToString(doc) + const ssml = document.implementation.createDocument(NS.SSML, 'speak') + ssml.documentElement.replaceWith(ssml.importNode(doc.documentElement, true)) + let node = getNode(ssml)?.previousSibling + while (node) { + const next = node.previousSibling ?? node.parentNode?.previousSibling + node.parentNode.removeChild(node) + node = next + } + const ssmlStr = this.#serializer.serializeToString(ssml) + return ssmlStr + } + start() { + this.#lastMark = null + const [doc] = this.#list.first() ?? [] + if (!doc) return this.next() + return this.#speak(doc, ssml => this.#getMarkElement(ssml, this.#lastMark)) + } + resume() { + const [doc] = this.#list.current() ?? [] + if (!doc) return this.next() + return this.#speak(doc, ssml => this.#getMarkElement(ssml, this.#lastMark)) + } + prev(paused) { + this.#lastMark = null + const [doc, range] = this.#list.prev() ?? [] + if (paused && range) this.highlight(range.cloneRange()) + return this.#speak(doc) + } + next(paused) { + this.#lastMark = null + const [doc, range] = this.#list.next() ?? [] + if (paused && range) this.highlight(range.cloneRange()) + return this.#speak(doc) + } + prevMark(paused) { + const marks = Array.from(this.#ranges.keys()) + if (marks.length === 0) return + + const currentIndex = this.#lastMark ? marks.indexOf(this.#lastMark) : -1 + if (currentIndex > 0) { + const prevMarkName = marks[currentIndex - 1] + const range = this.#ranges.get(prevMarkName) + if (range) { + this.#lastMark = prevMarkName + if (paused) this.highlight(range.cloneRange()) + + const [doc] = this.#list.current() ?? [] + return this.#speak(doc, ssml => this.#getMarkElement(ssml, prevMarkName)) + } + } else { + const [doc, range] = this.#list.prev() ?? [] + if (doc && range) { + const prevMarks = Array.from(this.#ranges.keys()) + if (prevMarks.length > 0) { + const lastMarkName = prevMarks[prevMarks.length - 1] + const lastMarkRange = this.#ranges.get(lastMarkName) + if (lastMarkRange) { + this.#lastMark = lastMarkName + if (paused) this.highlight(lastMarkRange.cloneRange()) + return this.#speak(doc, ssml => this.#getMarkElement(ssml, lastMarkName)) + } + } else { + this.#lastMark = null + if (paused) this.highlight(range.cloneRange()) + return this.#speak(doc) + } + } + } + } + nextMark(paused) { + const marks = Array.from(this.#ranges.keys()) + if (marks.length === 0) return + + const currentIndex = this.#lastMark ? marks.indexOf(this.#lastMark) : -1 + if (currentIndex >= 0 && currentIndex < marks.length - 1) { + const nextMarkName = marks[currentIndex + 1] + const range = this.#ranges.get(nextMarkName) + if (range) { + this.#lastMark = nextMarkName + if (paused) this.highlight(range.cloneRange()) + const [doc] = this.#list.current() ?? [] + return this.#speak(doc, ssml => this.#getMarkElement(ssml, nextMarkName)) + } + } else { + const [doc, range] = this.#list.next() ?? [] + if (doc && range) { + const nextMarks = Array.from(this.#ranges.keys()) + if (nextMarks.length > 0) { + const firstMarkName = nextMarks[0] + const firstMarkRange = this.#ranges.get(firstMarkName) + if (firstMarkRange) { + this.#lastMark = firstMarkName + if (paused) this.highlight(firstMarkRange.cloneRange()) + return this.#speak(doc, ssml => this.#getMarkElement(ssml, firstMarkName)) + } + } else { + this.#lastMark = null + if (paused) this.highlight(range.cloneRange()) + return this.#speak(doc) + } + } + } + } + from(range) { + this.#lastMark = null + const [doc] = this.#list.find(range_ => + range.compareBoundaryPoints(Range.END_TO_START, range_) <= 0) + let mark + for (const [name, range_] of this.#ranges.entries()) + if (range.compareBoundaryPoints(Range.START_TO_START, range_) <= 0) { + mark = name + break + } + return this.#speak(doc, ssml => this.#getMarkElement(ssml, mark)) + } + getLastRange() { + if (this.#lastMark) { + const range = this.#ranges.get(this.#lastMark) + if (range) return range.cloneRange() + } + } + setMark(mark) { + const range = this.#ranges.get(mark) + if (range) { + this.#lastMark = mark + this.highlight(range.cloneRange()) + return range + } + } +} diff --git a/packages/foliate-js/ui/menu.js b/packages/foliate-js/ui/menu.js new file mode 100644 index 0000000000000000000000000000000000000000..d05f074653979bc09333bd2360c0729c4af46079 --- /dev/null +++ b/packages/foliate-js/ui/menu.js @@ -0,0 +1,42 @@ +const createMenuItemRadioGroup = (label, arr, onclick) => { + const group = document.createElement('ul') + group.setAttribute('role', 'group') + group.setAttribute('aria-label', label) + const map = new Map() + const select = value => { + onclick(value) + const item = map.get(value) + for (const child of group.children) + child.setAttribute('aria-checked', child === item ? 'true' : 'false') + } + for (const [label, value] of arr) { + const item = document.createElement('li') + item.setAttribute('role', 'menuitemradio') + item.innerText = label + item.onclick = () => select(value) + map.set(value, item) + group.append(item) + } + return { element: group, select } +} + +export const createMenu = arr => { + const groups = {} + const element = document.createElement('ul') + element.setAttribute('role', 'menu') + const hide = () => element.classList.remove('show') + const hideAnd = f => (...args) => (hide(), f(...args)) + for (const { name, label, type, items, onclick } of arr) { + const widget = type === 'radio' + ? createMenuItemRadioGroup(label, items, hideAnd(onclick)) + : null + if (name) groups[name] = widget + element.append(widget.element) + } + // TODO: keyboard events + window.addEventListener('blur', () => hide()) + window.addEventListener('click', e => { + if (!element.parentNode.contains(e.target)) hide() + }) + return { element, groups } +} diff --git a/packages/foliate-js/ui/tree.js b/packages/foliate-js/ui/tree.js new file mode 100644 index 0000000000000000000000000000000000000000..7ee85b400226f1698d7186d9908db51c7923ad5f --- /dev/null +++ b/packages/foliate-js/ui/tree.js @@ -0,0 +1,169 @@ +const createSVGElement = tag => + document.createElementNS('http://www.w3.org/2000/svg', tag) + +const createExpanderIcon = () => { + const svg = createSVGElement('svg') + svg.setAttribute('viewBox', '0 0 13 10') + svg.setAttribute('width', '13') + svg.setAttribute('height', '13') + const polygon = createSVGElement('polygon') + polygon.setAttribute('points', '2 1, 12 1, 7 9') + svg.append(polygon) + return svg +} + +const createTOCItemElement = (list, map, onclick) => { + let count = 0 + const makeID = () => `toc-element-${count++}` + const createItem = ({ label, href, subitems }, depth = 0) => { + const a = document.createElement(href ? 'a' : 'span') + a.innerText = label + a.setAttribute('role', 'treeitem') + a.tabIndex = -1 + a.style.paddingInlineStart = `${(depth + 1) * 24}px` + list.push(a) + if (href) { + if (!map.has(href)) map.set(href, a) + a.href = href + a.onclick = event => { + event.preventDefault() + onclick(href) + } + } else a.onclick = event => a.firstElementChild?.onclick(event) + + const li = document.createElement('li') + li.setAttribute('role', 'none') + li.append(a) + if (subitems?.length) { + a.setAttribute('aria-expanded', 'false') + const expander = createExpanderIcon() + expander.onclick = event => { + event.preventDefault() + event.stopPropagation() + const expanded = a.getAttribute('aria-expanded') + a.setAttribute('aria-expanded', expanded === 'true' ? 'false' : 'true') + } + a.prepend(expander) + const ol = document.createElement('ol') + ol.id = makeID() + ol.setAttribute('role', 'group') + a.setAttribute('aria-owns', ol.id) + ol.replaceChildren(...subitems.map(item => createItem(item, depth + 1))) + li.append(ol) + } + return li + } + return createItem +} + +// https://www.w3.org/TR/wai-aria-practices-1.2/examples/treeview/treeview-navigation.html +export const createTOCView = (toc, onclick) => { + const $toc = document.createElement('ol') + $toc.setAttribute('role', 'tree') + const list = [] + const map = new Map() + const createItem = createTOCItemElement(list, map, onclick) + $toc.replaceChildren(...toc.map(item => createItem(item))) + + const isTreeItem = item => item?.getAttribute('role') === 'treeitem' + const getParents = function* (el) { + for (let parent = el.parentNode; parent !== $toc; parent = parent.parentNode) { + const item = parent.previousElementSibling + if (isTreeItem(item)) yield item + } + } + + let currentItem, currentVisibleParent + $toc.addEventListener('focusout', () => { + if (!currentItem) return + // reset parent focus from last time + if (currentVisibleParent) currentVisibleParent.tabIndex = -1 + // if current item is visible, let it have the focus + if (currentItem.offsetParent) { + currentItem.tabIndex = 0 + return + } + // current item is hidden; give focus to the nearest visible parent + for (const item of getParents(currentItem)) { + if (item.offsetParent) { + item.tabIndex = 0 + currentVisibleParent = item + break + } + } + }) + + const setCurrentHref = href => { + if (currentItem) { + currentItem.removeAttribute('aria-current') + currentItem.tabIndex = -1 + } + const el = map.get(href) + if (!el) { + currentItem = list[0] + currentItem.tabIndex = 0 + return + } + for (const item of getParents(el)) + item.setAttribute('aria-expanded', 'true') + el.setAttribute('aria-current', 'page') + el.tabIndex = 0 + el.scrollIntoView({ behavior: 'smooth', block: 'center' }) + currentItem = el + } + + const acceptNode = node => isTreeItem(node) && node.offsetParent + ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP + const iter = document.createTreeWalker($toc, 1, { acceptNode }) + const getIter = current => (iter.currentNode = current, iter) + + for (const el of list) el.addEventListener('keydown', event => { + let stop = false + const { currentTarget, key } = event + switch (key) { + case ' ': + case 'Enter': + currentTarget.click() + stop = true + break + case 'ArrowDown': + getIter(currentTarget).nextNode()?.focus() + stop = true + break + case 'ArrowUp': + getIter(currentTarget).previousNode()?.focus() + stop = true + break + case 'ArrowLeft': + if (currentTarget.getAttribute('aria-expanded') === 'true') + currentTarget.setAttribute('aria-expanded', 'false') + else getParents(currentTarget).next()?.value?.focus() + stop = true + break + case 'ArrowRight': + if (currentTarget.getAttribute('aria-expanded') === 'true') + getIter(currentTarget).nextNode()?.focus() + else if (currentTarget.getAttribute('aria-owns')) + currentTarget.setAttribute('aria-expanded', 'true') + stop = true + break + case 'Home': + list[0].focus() + stop = true + break + case 'End': { + const last = list[list.length - 1] + if (last.offsetParent) last.focus() + else getIter(last).previousNode()?.focus() + stop = true + break + } + } + if (stop) { + event.preventDefault() + event.stopPropagation() + } + }) + + return { element: $toc, setCurrentHref } +} diff --git a/packages/foliate-js/uri-template.js b/packages/foliate-js/uri-template.js new file mode 100644 index 0000000000000000000000000000000000000000..d66bbf7f43ed0102eb45af39f899df34372b1b28 --- /dev/null +++ b/packages/foliate-js/uri-template.js @@ -0,0 +1,52 @@ +// URI Template: https://datatracker.ietf.org/doc/html/rfc6570 + +const regex = /{([+#./;?&])?([^}]+?)}/g +const varspecRegex = /(.+?)(\*|:[1-9]\d{0,3})?$/ + +const table = { + undefined: { first: '', sep: ',' }, + '+': { first: '', sep: ',', allowReserved: true }, + '.': { first: '.', sep: '.' }, + '/': { first: '/', sep: '/' }, + ';': { first: ';', sep: ';', named: true, ifemp: '' }, + '?': { first: '?', sep: '&', named: true, ifemp: '=' }, + '&': { first: '&', sep: '&', named: true, ifemp: '=' }, + '#': { first: '&', sep: '&', allowReserved: true }, +} + +// 2.4.1 Prefix Values, "Note that this numbering is in characters, not octets" +const prefix = (maxLength, str) => { + let result = '' + for (const char of str) { + const newResult = char + if (newResult.length > maxLength) return result + else result = newResult + } + return result +} + +export const replace = (str, map) => str.replace(regex, (_, operator, variableList) => { + const { first, sep, named, ifemp, allowReserved } = table[operator] + // TODO: this isn't spec compliant + const encode = allowReserved ? encodeURI : encodeURIComponent + const values = variableList.split(',').map(varspec => { + const match = varspec.match(varspecRegex) + if (!match) return + const [, name, modifier] = match + let value = map.get(name) + if (modifier?.startsWith(':')) { + const maxLength = parseInt(modifier.slice(1)) + value = prefix(maxLength, value) + } + return [name, value ? encode(value) : null] + }) + if (!values.filter(([, value]) => value).length) return '' + return first + values + .map(([name, value]) => value + ? (named ? name + (value ? '=' + value : ifemp) : value) : '') + .filter(x => x).join(sep) +}) + +export const getVariables = str => new Set(Array.from(str.matchAll(regex), + ([,, variableList]) => variableList.split(',') + .map(varspec => varspec.match(varspecRegex)?.[1])).flat()) diff --git a/packages/foliate-js/vendor/fflate.js b/packages/foliate-js/vendor/fflate.js new file mode 100644 index 0000000000000000000000000000000000000000..f275976aa27f70765eafee67c231d4d1d95c862e --- /dev/null +++ b/packages/foliate-js/vendor/fflate.js @@ -0,0 +1 @@ +var r=Uint8Array,a=Uint16Array,e=Int32Array,n=new r([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new r([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),t=new r([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),f=function(r,n){for(var i=new a(31),t=0;t<31;++t)i[t]=n+=1<