@helloao/tools 0.0.1

package/parser/usx-parser.d.ts

@@ -0,0 +1,33 @@
+import { Chapter, ChapterContent, FootnoteReference, ParseTree, Verse, Text, HebrewSubtitle, InlineLineBreak } from "./types";
+import { RewindableIterator } from "./iterators";
+/**
+ * The version of the parser.
+ * Used to determine whether input files need to be re-parsed.
+ */
+export declare const PARSER_VERSION = "1";
+/**
+ * Defines a class that is able to parse USX content.
+ */
+export declare class USXParser {
+    private _domParser;
+    private _noteCounter;
+    constructor(domParser: DOMParser);
+    /**
+     * Parses the specified USX content.
+     *
+     * @param usx The USX content to parse.
+     * @returns The parse tree that was generated.
+     */
+    parse(usx: string): ParseTree;
+    iterateRootContent(usxElement: Element): Generator<ParseTree['content'][0]>;
+    iterateChapterContent(chapter: Chapter, nodes: RewindableIterator<Node>): IterableIterator<ChapterContent>;
+    iterateVerseContent(chapter: Chapter, verse: Verse, nodes: RewindableIterator<Node>): IterableIterator<string | FootnoteReference | Text | InlineLineBreak>;
+    parseVerse(element: Element, chapter: Chapter, nodes: RewindableIterator<Node>): Verse;
+    parseHebrewSubtitle(para: Element, chapter: Chapter, nodes: RewindableIterator<Node>): IterableIterator<HebrewSubtitle | Verse>;
+    iterateHebrewSubtitleContent(element: Element, chapter: Chapter, nodes: RewindableIterator<Node>): IterableIterator<Verse | string | Text | FootnoteReference | InlineLineBreak>;
+    iterateNodeTextContent(nodes: RewindableIterator<Node>, node: Node, chapter: Chapter, verse?: Verse): IterableIterator<string | Text | FootnoteReference | InlineLineBreak>;
+    iterateCharContent(char: Element): IterableIterator<string | Text>;
+    iterateNote(nodes: RewindableIterator<Node>, node: Element, chapter: Chapter, verse?: Verse): IterableIterator<FootnoteReference>;
+    iterateChar(nodes: RewindableIterator<Node>, node: Element): IterableIterator<string | Text>;
+}
+//# sourceMappingURL=usx-parser.d.ts.map

package/parser/usx-parser.js

@@ -0,0 +1,425 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USXParser = exports.PARSER_VERSION = void 0;
+const iterators_1 = require("./iterators");
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["Text"] = 3] = "Text";
+})(NodeType || (NodeType = {}));
+/**
+ * The version of the parser.
+ * Used to determine whether input files need to be re-parsed.
+ */
+exports.PARSER_VERSION = '1';
+/**
+ * Defines a class that is able to parse USX content.
+ */
+class USXParser {
+    _domParser;
+    _noteCounter = 0;
+    constructor(domParser) {
+        this._domParser = domParser;
+    }
+    /**
+     * Parses the specified USX content.
+     *
+     * @param usx The USX content to parse.
+     * @returns The parse tree that was generated.
+     */
+    parse(usx) {
+        const parser = this._domParser;
+        const doc = parser.parseFromString(usx, 'application/xml');
+        const usxElement = doc.documentElement;
+        let root = {
+            type: 'root',
+            content: []
+        };
+        const bookElement = usxElement.querySelector('book[code]');
+        if (!bookElement) {
+            throw new Error('The USX content does not contain a book element.');
+        }
+        const bookCode = bookElement.getAttribute('code') || '';
+        if (!bookCode) {
+            throw new Error('The book element does not contain a code attribute.');
+        }
+        root.id = bookCode;
+        const header = usxElement.querySelector('para[style="h"]');
+        if (header) {
+            root.header = header.textContent || '';
+        }
+        const titles = usxElement.querySelectorAll('para[style="mt1"], para[style="mt2"], para[style="mt3"]');
+        // const title2 = usxElement.querySelector('para[style="mt2"]');
+        // const title3 = usxElement.querySelector('para[style="mt3"]');
+        if (titles.length > 0) {
+            root.title = [...titles].map(t => t.textContent).filter(t => t).join(' ');
+        }
+        for (let content of this.iterateRootContent(usxElement)) {
+            root.content.push(content);
+        }
+        return root;
+    }
+    *iterateRootContent(usxElement) {
+        const iterator = (0, iterators_1.iterateAll)(usxElement);
+        while (true) {
+            const { done, value: child } = iterator.next();
+            if (done) {
+                break;
+            }
+            if (!(child instanceof Element)) {
+                continue;
+            }
+            if (child.nodeName === 'chapter') {
+                if (child.hasAttribute('eid')) {
+                    continue;
+                }
+                const chapter = {
+                    type: 'chapter',
+                    number: parseInt(child.getAttribute('number') || '0', 10),
+                    content: [],
+                    footnotes: [],
+                };
+                for (let content of this.iterateChapterContent(chapter, iterator)) {
+                    chapter.content.push(content);
+                }
+                yield chapter;
+            }
+            else if (child.nodeName === 'para') {
+                const style = child.getAttribute('style');
+                if (style === 's1' || style === 's2' || style === 's3' || style === 's4') {
+                    yield {
+                        type: 'heading',
+                        content: child.textContent ? [child.textContent] : []
+                    };
+                }
+            }
+        }
+    }
+    *iterateChapterContent(chapter, nodes) {
+        while (true) {
+            const { done, value: element } = nodes.next();
+            if (done) {
+                break;
+            }
+            if (!(element instanceof Element)) {
+                continue;
+            }
+            if (element.nodeName === 'chapter') {
+                break;
+            }
+            else if (element.nodeName === 'para') {
+                const style = element.getAttribute('style');
+                if (style === 's1' || style === 's2' || style === 's3' || style === 's4') {
+                    yield {
+                        type: 'heading',
+                        content: element.textContent ? [element.textContent] : []
+                    };
+                }
+                else if (style === 'b') {
+                    yield {
+                        type: 'line_break',
+                    };
+                }
+                else if (style === 'd') {
+                    yield* this.parseHebrewSubtitle(element, chapter, nodes);
+                }
+            }
+            else if (element.nodeName === 'verse') {
+                if (element.hasAttribute('eid')) {
+                    continue;
+                }
+                yield this.parseVerse(element, chapter, nodes);
+            }
+        }
+    }
+    *iterateVerseContent(chapter, verse, nodes) {
+        while (true) {
+            const { done, value: node } = nodes.next();
+            if (done) {
+                break;
+            }
+            if (node.nodeName === 'verse') {
+                break;
+            }
+            const parent = node.parentElement;
+            let poem = null;
+            let descriptive = null;
+            if (parent.nodeName === 'para') {
+                const style = parent.getAttribute('style');
+                if (style === 'q1' || style === 'q2' || style === 'q3' || style === 'q4') {
+                    poem = style === 'q1' ? 1 : style === 'q2' ? 2 : style === 'q3' ? 3 : 4;
+                }
+                else if (style === 'd') {
+                    descriptive = true;
+                }
+            }
+            for (let content of this.iterateNodeTextContent(nodes, node, chapter, verse)) {
+                if (poem !== null || descriptive !== null) {
+                    if (typeof content === 'string') {
+                        let text = {
+                            text: content
+                        };
+                        if (poem !== null) {
+                            text.poem = poem;
+                        }
+                        if (descriptive !== null) {
+                            text.descriptive = true;
+                        }
+                        yield text;
+                    }
+                    else {
+                        let text = {
+                            ...content
+                        };
+                        if ('text' in text) {
+                            if (poem !== null) {
+                                text.poem = poem;
+                            }
+                            if (descriptive !== null) {
+                                text.descriptive = true;
+                            }
+                        }
+                        yield text;
+                    }
+                }
+                else {
+                    yield content;
+                }
+            }
+        }
+    }
+    parseVerse(element, chapter, nodes) {
+        const verse = {
+            type: 'verse',
+            number: parseInt(element.getAttribute('number') || '0', 10),
+            content: []
+        };
+        for (let content of this.iterateVerseContent(chapter, verse, nodes)) {
+            addOrJoin(verse.content, content);
+        }
+        trimContent(verse.content);
+        return verse;
+    }
+    *parseHebrewSubtitle(para, chapter, nodes) {
+        const subtitle = {
+            type: 'hebrew_subtitle',
+            content: []
+        };
+        for (let content of this.iterateHebrewSubtitleContent(para, chapter, nodes)) {
+            if (typeof content === 'object' && 'number' in content) {
+                yield content;
+                continue;
+            }
+            addOrJoin(subtitle.content, content);
+        }
+        trimContent(subtitle.content);
+        if (subtitle.content.length > 0) {
+            yield subtitle;
+        }
+    }
+    *iterateHebrewSubtitleContent(element, chapter, nodes) {
+        while (true) {
+            const { done, value: node } = nodes.next();
+            if (done) {
+                break;
+            }
+            if (!(0, iterators_1.isParent)(node, element)) {
+                nodes.rewind(1);
+                break;
+            }
+            if (node instanceof Element && node.nodeName === 'verse') {
+                yield this.parseVerse(node, chapter, nodes);
+            }
+            else {
+                yield* this.iterateNodeTextContent(nodes, node, chapter);
+            }
+        }
+    }
+    *iterateNodeTextContent(nodes, node, chapter, verse) {
+        if (node instanceof Element && node.nodeName === 'note') {
+            yield* this.iterateNote(nodes, node, chapter, verse);
+        }
+        else if (node instanceof Element && node.nodeName === 'char') {
+            yield* this.iterateChar(nodes, node);
+        }
+        else if (node instanceof Element && node.nodeName === 'para' && node.getAttribute('style') === 'b') {
+            for (let _ of (0, iterators_1.children)(nodes, node)) {
+                // iterate through all the children to prevent iterating over them multiple times
+            }
+            yield {
+                lineBreak: true
+            };
+        }
+        else if (node.nodeType === NodeType.Text) {
+            yield node.textContent || '';
+        }
+    }
+    *iterateCharContent(char) {
+        const style = char.getAttribute('style');
+        const text = trimText(char.textContent || '');
+        if (style === 'wj') {
+            yield {
+                text,
+                wordsOfJesus: true
+            };
+        }
+        else {
+            yield text;
+        }
+    }
+    *iterateNote(nodes, node, chapter, verse) {
+        const style = node.getAttribute('style');
+        if (style === 'f') {
+            const verseReferenceRegex = /^[0-9]{1,3}:[0-9]{1,3}/;
+            let text = '';
+            for (let child of (0, iterators_1.children)(nodes, node)) {
+                if (child.nodeType === NodeType.Text) {
+                    text += child.textContent || '';
+                }
+            }
+            text = text.trim();
+            if (verseReferenceRegex.test(text)) {
+                text = text.replace(verseReferenceRegex, '').trim();
+            }
+            const note = {
+                noteId: this._noteCounter++,
+                caller: node.getAttribute('caller') || null,
+                text,
+                reference: {
+                    chapter: chapter.number,
+                    verse: verse?.number ?? 0
+                }
+            };
+            chapter.footnotes.push(note);
+            yield {
+                noteId: note.noteId
+            };
+        }
+        else {
+            for (let _ of (0, iterators_1.children)(nodes, node)) {
+                // iterate through all the children
+                // so that we don't end up with duplicates
+            }
+        }
+    }
+    *iterateChar(nodes, node) {
+        const style = node.getAttribute('style');
+        let text = '';
+        for (let char of (0, iterators_1.children)(nodes, node)) {
+            if (char.nodeType === NodeType.Text) {
+                text += char.textContent || '';
+            }
+        }
+        if (style === 'wj') {
+            yield {
+                text,
+                wordsOfJesus: true
+            };
+        }
+        else {
+            yield text;
+        }
+        // if (!parentChar(node) && !parentNote(node)) {
+        //     yield *iterateCharContent(node);
+        // }
+    }
+}
+exports.USXParser = USXParser;
+// Taken from https://github.com/gracious-tech/fetch/blob/1576cc4eafb32bf347a09332094cf17c2231c90c/converters/usx-to-json/src/elements.ts#L16
+const ignoredParaStyles = new Set([
+    // <para> Identification [exclude all] - Running headings & table of contents
+    'ide', // See https://github.com/schierlm/BibleMultiConverter/issues/67
+    'rem', // Remarks (valid in schema though missed in docs)
+    'h', 'h1', 'h2', 'h3', 'h4',
+    'toc1', 'toc2', 'toc3',
+    'toca1', 'toca2', 'toca3',
+    /* <para> Introductions [exclude all] - Introductionary (non-biblical) content
+        Which might be helpful in a printed book, but intro material in apps is usually bad UX,
+        and users that really care can research a translations methodology themselves
+    */
+    'imt', 'imt1', 'imt2', 'imt3', 'imt4',
+    'is', 'is1', 'is2', 'is3', 'is4',
+    'ip',
+    'ipi',
+    'im',
+    'imi',
+    'ipq',
+    'imq',
+    'ipr',
+    'iq', 'iq1', 'iq2', 'iq3', 'iq4',
+    'ib',
+    'ili', 'ili1', 'ili2', 'ili3', 'ili4',
+    'iot',
+    'io', 'io1', 'io2', 'io3', 'io4',
+    'iex',
+    'imte',
+    'ie',
+    /* <para> Headings [exclude some] - Exclude book & chapter headings but keep section headings
+        Not excluded: ms# | mr | s# | sr | d | sp | sd#
+    */
+    'mt', 'mt1', 'mt2', 'mt3', 'mt4',
+    'mte', 'mte1', 'mte2', 'mte3', 'mte4',
+    'cl',
+    'cd', // Non-biblical chapter summary, more than heading
+    'r', // Parallels to be provided by external data
+]);
+function* iterateCharContent(char) {
+    const style = char.getAttribute('style');
+    const text = trimText(char.textContent || '');
+    if (style === 'wj') {
+        yield {
+            text,
+            wordsOfJesus: true
+        };
+    }
+    else {
+        yield text;
+    }
+}
+function trimText(text) {
+    return text.replace(/\s+/g, ' ');
+}
+function trimContent(content) {
+    for (let i = 0; i < content.length; i++) {
+        const value = content[i];
+        if (typeof value === 'string') {
+            content[i] = trimText(value).trim();
+            if (content[i] === '') {
+                content.splice(i, 1);
+                i--;
+                continue;
+            }
+        }
+        else if (isVerseText(value)) {
+            value.text = trimText(value.text).trim();
+            if (value.text === '') {
+                content.splice(i, 1);
+                i--;
+                continue;
+            }
+        }
+    }
+    return content;
+}
+function addOrJoin(array, value) {
+    if (array.length === 0) {
+        array.push(value);
+    }
+    else {
+        const last = array[array.length - 1];
+        if (typeof last === 'string' && typeof value === 'string') {
+            array[array.length - 1] = last + value;
+        }
+        else if (isVerseText(last) && isVerseText(value) && hasSameFormatting(last, value)) {
+            last.text += value.text;
+        }
+        else {
+            array.push(value);
+        }
+    }
+}
+function isVerseText(value) {
+    return typeof value === 'object' && value !== null && 'text' in value;
+}
+function hasSameFormatting(a, b) {
+    return a.poem === b.poem && a.wordsOfJesus === b.wordsOfJesus;
+}

package/parser/usx-parser.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=usx-parser.spec.d.ts.map