@helloao/tools 0.0.1

package/parser/codex-parser.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexParser = exports.codexSchema = exports.metadataSchema = exports.chapterHeadingSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../utils");
+exports.chapterHeadingSchema = zod_1.z.object({
+    type: zod_1.z.literal('chapter-heading'),
+    data: zod_1.z.object({
+        chapter: zod_1.z.coerce.number().int(),
+    }),
+});
+exports.metadataSchema = zod_1.z.discriminatedUnion('type', [
+    exports.chapterHeadingSchema
+]);
+exports.codexSchema = zod_1.z.object({
+    cells: zod_1.z.array(zod_1.z.object({
+        // kind: z.number().int(),
+        language: zod_1.z.string(),
+        value: zod_1.z.string(),
+        metadata: zod_1.z.object({
+            type: zod_1.z.string()
+        }).passthrough().nullable().optional()
+    })),
+});
+/**
+ * Defines a parser for codex files.
+ */
+class CodexParser {
+    // TODO:
+    // /**
+    //  * Whether to preserve markdown in the parsed content.
+    //  */
+    // preserveMarkdown: boolean = true;
+    _noteCounter = 0;
+    /**
+     * Parses the specified USX content.
+     *
+     * @param usx The USX content to parse.
+     * @returns The parse tree that was generated.
+     */
+    parse(codex) {
+        const json = JSON.parse(codex);
+        const data = exports.codexSchema.parse(json);
+        let root = {
+            type: 'root',
+            content: []
+        };
+        let chapters = new Map();
+        let lastChapter = null;
+        function addChapterContent(chapterNumber, content) {
+            let chapter = chapters.get(chapterNumber);
+            if (!chapter) {
+                chapter = {
+                    type: 'chapter',
+                    number: chapterNumber,
+                    content: [],
+                    footnotes: []
+                };
+                lastChapter = chapter;
+                chapters.set(chapterNumber, chapter);
+            }
+            chapter.content.push(...content);
+        }
+        function addReference(ref, content) {
+            addChapterContent(ref.chapter, [
+                {
+                    type: 'verse',
+                    number: ref.verse,
+                    content: content
+                }
+            ]);
+        }
+        for (let cell of data.cells) {
+            if (cell.language === 'scripture') {
+                const lines = cell.value.split('\n');
+                const references = lines.map(l => (0, utils_1.parseVerseReference)(l) ?? l);
+                let currentRef = null;
+                let content = [];
+                for (let i = 0; i < references.length; i++) {
+                    const ref = references[i];
+                    const nextRef = references[i + 1];
+                    if (typeof ref === 'string') {
+                        // continuation on existing verse
+                        // or line break between verses
+                        if (ref === '') {
+                            // line break
+                            if (typeof nextRef === 'object') {
+                                // between verses
+                                if (currentRef && currentRef.chapter === nextRef.chapter) {
+                                    // in same chapter
+                                    addChapterContent(currentRef.chapter, [
+                                        {
+                                            type: 'line_break',
+                                        }
+                                    ]);
+                                }
+                                else {
+                                    // do nothing since line breaks between chapters are ignored
+                                }
+                            }
+                            else {
+                                // inside verse
+                                content.push({
+                                    lineBreak: true
+                                });
+                            }
+                        }
+                        else if (ref) {
+                            content.push(ref);
+                        }
+                    }
+                    else {
+                        if (!root.id) {
+                            root.id = ref.book;
+                        }
+                        // new verse
+                        if (currentRef) {
+                            // finish previous verse
+                            currentRef = null;
+                            content = [];
+                        }
+                        currentRef = ref;
+                        if (ref.content) {
+                            content.push(ref.content);
+                        }
+                        addReference(ref, content);
+                    }
+                }
+            }
+            else if (cell.language === 'markdown') {
+                if (cell.metadata) {
+                    if (cell.metadata.type === 'chapter-heading') {
+                        const metadata = exports.metadataSchema.parse(cell.metadata);
+                        const chapter = metadata.data.chapter;
+                        addChapterContent(chapter, [
+                            {
+                                type: 'heading',
+                                content: [cell.value]
+                            }
+                        ]);
+                    }
+                }
+                else {
+                    if (lastChapter) {
+                        lastChapter.footnotes.push({
+                            noteId: this._noteCounter++,
+                            text: cell.value,
+                            caller: null,
+                        });
+                    }
+                }
+            }
+        }
+        for (let chapter of chapters.values()) {
+            root.content.push(chapter);
+        }
+        return root;
+    }
+}
+exports.CodexParser = CodexParser;

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

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