@helloao/tools 0.0.1

package/parser/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterators = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./usfm-parser"), exports);
+__exportStar(require("./usx-parser"), exports);
+__exportStar(require("./codex-parser"), exports);
+const iterators = __importStar(require("./iterators"));
+exports.iterators = iterators;

package/parser/iterators.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Defines an interface that represents an iterator that can be rewound.
+ */
+export interface RewindableIterator<T> extends IterableIterator<T> {
+    /**
+     * Rewinds the iterator by the specified number of elements.
+     * @param number The number of elements to rewind.
+     */
+    rewind(number: number): void;
+}
+/**
+ * Defines a class that implements an iterator that can be rewound.
+ */
+export declare class Rewindable<T> implements RewindableIterator<T> {
+    buffer: T[];
+    private _bufferSize;
+    private _position;
+    private _iterator;
+    constructor(iterator: IterableIterator<T>, bufferSize?: number);
+    rewind(number: number): void;
+    [Symbol.iterator](): IterableIterator<T>;
+    next(...args: [] | [undefined]): IteratorResult<T, any>;
+    return?(value?: any): IteratorResult<T, any>;
+    throw?(e?: any): IteratorResult<T, any>;
+}
+export declare function debug(label: string, iterator: IterableIterator<any>): Generator<any, void, unknown>;
+/**
+ * Creates a new rewindable iterator from the given iterator.
+ * @param iterator The iterator.
+ * @param bufferSize The size of the buffer.
+ */
+export declare function rewindable<T>(iterator: IterableIterator<T>, bufferSize?: number): Rewindable<T>;
+/**
+ * Gets the char element that is the parent of the given node.
+ * @param node The node.
+ */
+export declare function parentChar(node: Node): Element | null;
+/**
+ * Gets the note element that is the parent of the given node.
+ * @param node The node.
+ */
+export declare function parentNote(node: Node): Element | null;
+/**
+ * Gets the parent node that matches the given filter.
+ * @param node The node to start the search from.
+ * @param filter The filter that should be used.
+ */
+export declare function matchingParent(node: Node, filter: (node: Node) => boolean): Node | null;
+/**
+ * Determines if the given node is a child of the parent node.
+ * @param node The node to test.
+ * @param parent The parent.
+ * @returns
+ */
+export declare function isParent(node: Node, parent: Node): boolean;
+/**
+ * Iterates through all of the nodes in the tree in a depth-first traversal.
+ * @param node The node to start the traversal from.
+ */
+export declare function iterateAll(node: Node): RewindableIterator<Node>;
+export declare function iterateUntil<T>(iterator: IterableIterator<T>, predicate: (value: T) => boolean): IterableIterator<T>;
+/**
+ * Iterates only the elements in the iterator.
+ * @param iterator The iterator that should be used.
+ */
+export declare function elements(iterator: IterableIterator<Node>): IterableIterator<Element>;
+/**
+ * Iterates only the children of the given node in the iterator.
+ * @param iterator The iterator that should be used.
+ * @param parent The parent node.
+ */
+export declare function children(iterator: RewindableIterator<Node>, parent: Node): IterableIterator<Node>;
+/**
+ * Wraps the given iterable in a generator that will prevent consumers from calling return() on the iterator.
+ * @param iterable The iterable.
+ */
+export declare function uncompletable<T>(iterable: IterableIterator<T>): IterableIterator<T>;
+/**
+ * Converts the given iterable into an async iterable.
+ * @param input The input iterable.
+ */
+export declare function toAsyncIterable<T>(input: Iterable<T>): AsyncIterable<T>;
+/**
+ * Batches items from the given iterator.
+ * @param input The input iterator.
+ * @param batchSize The size of each batch.
+ */
+export declare function batch<T>(input: Iterable<T>, batchSize: number): Iterable<T[]>;
+//# sourceMappingURL=iterators.d.ts.map

package/parser/iterators.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rewindable = void 0;
+exports.debug = debug;
+exports.rewindable = rewindable;
+exports.parentChar = parentChar;
+exports.parentNote = parentNote;
+exports.matchingParent = matchingParent;
+exports.isParent = isParent;
+exports.iterateAll = iterateAll;
+exports.iterateUntil = iterateUntil;
+exports.elements = elements;
+exports.children = children;
+exports.uncompletable = uncompletable;
+exports.toAsyncIterable = toAsyncIterable;
+exports.batch = batch;
+/**
+ * Defines a class that implements an iterator that can be rewound.
+ */
+class Rewindable {
+    buffer = [];
+    _bufferSize = 0;
+    _position = -1;
+    _iterator;
+    constructor(iterator, bufferSize = 2) {
+        this._iterator = iterator;
+        this._bufferSize = bufferSize;
+        if (this._iterator.return) {
+            this.return = (value) => {
+                return this._iterator.return(value);
+            };
+        }
+        if (this._iterator.throw) {
+            this.throw = (value) => {
+                return this._iterator.throw(value);
+            };
+        }
+    }
+    rewind(number) {
+        this._position += number;
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+    next(...args) {
+        if (this._position >= 0) {
+            let item = this.buffer[this._position];
+            this._position--;
+            return {
+                value: item,
+                done: false
+            };
+        }
+        let result = this._iterator.next(...args);
+        this.buffer.unshift(result.value);
+        if (this.buffer.length > this._bufferSize) {
+            this.buffer.splice(this._bufferSize, this.buffer.length - this._bufferSize);
+        }
+        return result;
+    }
+}
+exports.Rewindable = Rewindable;
+function* debug(label, iterator) {
+    for (let value of uncompletable(iterator)) {
+        if (value instanceof Element) {
+            console.log(label, value.outerHTML);
+        }
+        else if (value instanceof Node) {
+            console.log(label, value.textContent);
+        }
+        else {
+            console.log(label, value);
+        }
+        yield value;
+    }
+}
+/**
+ * Creates a new rewindable iterator from the given iterator.
+ * @param iterator The iterator.
+ * @param bufferSize The size of the buffer.
+ */
+function rewindable(iterator, bufferSize = 2) {
+    return new Rewindable(iterator, bufferSize);
+}
+function* iterateNodes(node) {
+    for (let i = 0; i < node.childNodes.length; i++) {
+        yield node.childNodes[i];
+    }
+}
+/**
+ * Gets the char element that is the parent of the given node.
+ * @param node The node.
+ */
+function parentChar(node) {
+    return matchingParent(node, n => n instanceof Element && n.nodeName === 'char');
+}
+/**
+ * Gets the note element that is the parent of the given node.
+ * @param node The node.
+ */
+function parentNote(node) {
+    return matchingParent(node, n => n instanceof Element && n.nodeName === 'note');
+}
+/**
+ * Gets the parent node that matches the given filter.
+ * @param node The node to start the search from.
+ * @param filter The filter that should be used.
+ */
+function matchingParent(node, filter) {
+    let parent = node.parentNode;
+    while (parent) {
+        if (filter(parent)) {
+            return parent;
+        }
+        parent = parent.parentNode;
+    }
+    return null;
+}
+/**
+ * Determines if the given node is a child of the parent node.
+ * @param node The node to test.
+ * @param parent The parent.
+ * @returns
+ */
+function isParent(node, parent) {
+    let parentNode = node.parentNode;
+    while (parentNode) {
+        if (parentNode === parent) {
+            return true;
+        }
+        parentNode = parentNode.parentNode;
+    }
+    return false;
+}
+/**
+ * Iterates through all of the nodes in the tree in a depth-first traversal.
+ * @param node The node to start the traversal from.
+ */
+function iterateAll(node) {
+    return rewindable(_iterateAll(node));
+}
+function* iterateUntil(iterator, predicate) {
+    for (let value of iterator) {
+        if (predicate(value)) {
+            return;
+        }
+        yield value;
+    }
+}
+function* _iterateAll(node) {
+    for (let child of node.childNodes) {
+        yield child;
+        yield* iterateAll(child);
+    }
+}
+/**
+ * Iterates only the elements in the iterator.
+ * @param iterator The iterator that should be used.
+ */
+function* elements(iterator) {
+    for (let node of uncompletable(iterator)) {
+        if (node instanceof Element) {
+            yield node;
+        }
+    }
+}
+/**
+ * Iterates only the children of the given node in the iterator.
+ * @param iterator The iterator that should be used.
+ * @param parent The parent node.
+ */
+function* children(iterator, parent) {
+    for (let node of uncompletable(iterator)) {
+        if (!isParent(node, parent)) {
+            iterator.rewind(1);
+            return;
+        }
+        yield node;
+    }
+}
+/**
+ * Wraps the given iterable in a generator that will prevent consumers from calling return() on the iterator.
+ * @param iterable The iterable.
+ */
+function* uncompletable(iterable) {
+    while (true) {
+        const { done, value } = iterable.next();
+        if (done) {
+            return;
+        }
+        yield value;
+    }
+}
+/**
+ * Converts the given iterable into an async iterable.
+ * @param input The input iterable.
+ */
+async function* toAsyncIterable(input) {
+    for (let item of input) {
+        yield item;
+    }
+}
+/**
+ * Batches items from the given iterator.
+ * @param input The input iterator.
+ * @param batchSize The size of each batch.
+ */
+function* batch(input, batchSize) {
+    while (true) {
+        let batch = [];
+        for (let item of input) {
+            batch.push(item);
+            if (batch.length >= batchSize) {
+                break;
+            }
+        }
+        if (batch.length === 0) {
+            return;
+        }
+        yield batch;
+    }
+}

package/parser/iterators.spec.d.ts

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

package/parser/iterators.spec.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const linkedom_1 = require("linkedom");
+const iterators_1 = require("./iterators");
+describe('iterators', () => {
+    let dom;
+    beforeEach(() => {
+        dom = new linkedom_1.DOMParser();
+    });
+    describe('iterateAll()', () => {
+        it('should iterate through all nodes', () => {
+            const html = `
+                <div id="0">
+                    <div id="1">
+                        <div id="2">abc</div>
+                        <div id="3">def</div>
+                    </div>
+                    <div id="4">
+                        <div id="5">ghi</div>
+                        <div id="6">jfk</div>
+                    </div>
+                    <div id="7">
+                        <div id="8">lmn</div>
+                        <div id="9">opq</div>
+                    </div>
+                </div>
+            `;
+            const tree = dom.parseFromString(html, 'text/html');
+            const node = tree.getElementById('0');
+            const iterator = (0, iterators_1.iterateAll)(node);
+            expect(iterator).toBeInstanceOf(iterators_1.Rewindable);
+            const nodes = [
+                ...iterator
+            ];
+            expect(mapNodes(nodes)).toEqual([
+                "#space",
+                "1",
+                "#space",
+                "2",
+                "abc",
+                "#space",
+                "3",
+                "def",
+                "#space",
+                "#space",
+                "4",
+                "#space",
+                "5",
+                "ghi",
+                "#space",
+                "6",
+                "jfk",
+                "#space",
+                "#space",
+                "7",
+                "#space",
+                "8",
+                "lmn",
+                "#space",
+                "9",
+                "opq",
+                "#space",
+                "#space",
+            ]);
+        });
+    });
+    describe('children()', () => {
+        it('should iterate through all children', () => {
+            const html = `
+                <div id="0">
+                    <div id="1">
+                        <div id="2">abc</div>
+                        <div id="3">def</div>
+                    </div>
+                    <div id="4">
+                        <div id="5">ghi</div>
+                        <div id="6">jfk</div>
+                    </div>
+                    <div id="7">
+                        <div id="8">lmn</div>
+                        <div id="9">opq</div>
+                    </div>
+                </div>
+            `;
+            const tree = dom.parseFromString(html, 'text/html');
+            const root = tree.getElementById('0');
+            const node = tree.getElementById('1');
+            const iterator = (0, iterators_1.iterateAll)(root);
+            for (let node of (0, iterators_1.uncompletable)(iterator)) {
+                if (node instanceof linkedom_1.Element && node.id === '1') {
+                    break;
+                }
+            }
+            const nodes = [
+                ...(0, iterators_1.children)(iterator, node)
+            ];
+            expect(mapNodes(nodes)).toEqual(['#space', '2', 'abc', '#space', '3', 'def', '#space']);
+        });
+        it('should not exhaust the iterator', () => {
+            const html = `
+                <div id="0">
+                    <div id="1">
+                        <div id="2">abc</div>
+                        <div id="3">def</div>
+                    </div>
+                    <div id="4">
+                        <div id="5">ghi</div>
+                        <div id="6">jfk</div>
+                    </div>
+                    <div id="7">
+                        <div id="8">lmn</div>
+                        <div id="9">opq</div>
+                    </div>
+                </div>
+            `;
+            const tree = dom.parseFromString(html, 'text/html');
+            const root = tree.getElementById('0');
+            const node = tree.getElementById('1');
+            let iterator = (0, iterators_1.iterateAll)(root);
+            for (let node of (0, iterators_1.uncompletable)(iterator)) {
+                if (node instanceof linkedom_1.Element && node.id === '1') {
+                    break;
+                }
+            }
+            const nodes = [
+                ...(0, iterators_1.children)(iterator, node)
+            ];
+            expect(mapNodes(nodes)).toEqual(['#space', '2', 'abc', '#space', '3', 'def', '#space']);
+            const remaining = [
+                ...iterator
+            ];
+            expect(mapNodes(remaining)).toEqual(['#space', '4', '#space', '5', 'ghi', '#space', '6', 'jfk', '#space', '#space', '7', '#space', '8', 'lmn', '#space', '9', 'opq', '#space', '#space']);
+        });
+    });
+    describe('rewindable()', () => {
+        it('should be able to rewind the iterator', () => {
+            function* gen() {
+                yield 1;
+                yield 2;
+                yield 3;
+            }
+            const iterator = (0, iterators_1.rewindable)(gen());
+            const { value: value1 } = iterator.next();
+            const { value: value2 } = iterator.next();
+            const { value: value3 } = iterator.next();
+            iterator.rewind(1);
+            const { value: value4 } = iterator.next();
+            const { value: value5 } = iterator.next();
+            expect(value1).toBe(1);
+            expect(value2).toBe(2);
+            expect(value3).toBe(3);
+            expect(value4).toBe(3);
+            expect(value5).toBeUndefined();
+        });
+    });
+    function mapNodes(nodes) {
+        return nodes.map(node => {
+            if (node.nodeType === linkedom_1.Node.TEXT_NODE) {
+                if (/\s/.test(node.textContent)) {
+                    return '#space';
+                }
+                else {
+                    return node.textContent;
+                }
+            }
+            else if (node.nodeType === linkedom_1.Node.ELEMENT_NODE) {
+                return node.getAttribute('id');
+            }
+            else {
+                return 'unknown';
+            }
+        });
+    }
+});

package/parser/types.d.ts

@@ -0,0 +1,144 @@
+/**
+ * The parse tree that is gathered.
+ */
+export interface ParseTree {
+    type: 'root';
+    /**
+     * The ID of the parse tree.
+     */
+    id?: string;
+    /**
+     * The header that was associated with the tree.
+     */
+    header?: string;
+    /**
+     * The major title that was associated with the tree.
+     */
+    title?: string;
+    /**
+     * The list of chapters for the tree.
+     */
+    content: (Heading | Chapter)[];
+}
+export interface Heading {
+    type: 'heading';
+    content: string[];
+}
+export type ChapterContent = (Heading | Verse | HebrewSubtitle | LineBreak);
+export type VerseContent = string | FootnoteReference | Text;
+/**
+ * Defines an interface that represents a chapter.
+ */
+export interface Chapter {
+    type: 'chapter';
+    number: number;
+    /**
+     * The contents of the chapter.
+     */
+    content: ChapterContent[];
+    /**
+     * The list of footnotes for the chapter.
+     */
+    footnotes: Footnote[];
+}
+/**
+ * Defines an interface that represents a hebrew subtitle.
+ */
+export interface HebrewSubtitle {
+    type: 'hebrew_subtitle';
+    /**
+     * The contents of the subtitle.
+     */
+    content: (string | Text | FootnoteReference)[];
+}
+/**
+ * Defines an interface that represents a verse.
+ */
+export interface Verse {
+    type: 'verse';
+    number: number;
+    /**
+     * The contents of the verse.
+     */
+    content: (string | Text | InlineHeading | InlineLineBreak | FootnoteReference)[];
+}
+/**
+ * Defines an interface that represents text that has some markup attributes applied to it.
+ */
+export interface Text {
+    /**
+     * The text that is contained.
+     */
+    text: string;
+    /**
+     * Whether the text represents a poem.
+     * The number indicates the level of indent.
+     */
+    poem?: number;
+    /**
+     * Whether the text contains the words of Jesus.
+     */
+    wordsOfJesus?: boolean;
+    /**
+     * Whether the text is descriptive.
+     *
+     * This is only used for "hebrew subtitles" that are included inside the verse markers.
+     */
+    descriptive?: boolean;
+}
+/**
+ * Defines an interface that represents a heading that is embedded in a verse.
+ */
+export interface InlineHeading {
+    /**
+     * The text of the heading.
+     */
+    heading: string;
+}
+/**
+ * Defines an interface that represents a line break that is embedded in a verse.
+ */
+export interface InlineLineBreak {
+    lineBreak: true;
+}
+export interface FootnoteReference {
+    /**
+     * The ID of the note that is referenced.
+     */
+    noteId: number;
+}
+export interface Footnote {
+    noteId: number;
+    /**
+     * The text of the footnote.
+     */
+    text: string;
+    /**
+     * The caller that should be used for the footnote.
+     * For footnotes, a "caller" is the character that is used in the text to reference to footnote.
+     *
+     * For example, in the text:
+     * Hello (a) World
+     *
+     * ----
+     * (a) This is a footnote.
+     *
+     * The "(a)" is the caller.
+     *
+     * If "+", then the caller should be autogenerated.
+     * If null, then the caller should be empty.
+     * If a string, then the caller should be that string.
+     */
+    caller: '+' | string | null;
+    /**
+     * The verse reference for the footnote.
+     */
+    reference?: {
+        chapter: number;
+        verse: number;
+    };
+}
+export interface LineBreak {
+    type: 'line_break';
+}
+//# sourceMappingURL=types.d.ts.map

package/parser/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });