bookish-press 0.4.0

package/models/chapter/Node.js

@@ -0,0 +1,173 @@
+// A global node ID generator, for mapping views back to models.
+let nodeID = 1;
+export default class Node {
+    // A globally unique identifier, helpful for mapping things back to nodes.
+    nodeID;
+    constructor() {
+        this.nodeID = nodeID++;
+    }
+    getID() { return this.nodeID; }
+    traverse(fn, parents) {
+        const path = parents === undefined ? [this] : [...parents, this];
+        this.traverseChildren(fn, path);
+        fn.call(undefined, this, path);
+    }
+    // Traverses each of the children of this node.
+    traverseChildren(fn, parents) {
+        const children = this.getChildren();
+        children.forEach(child => child.traverse(fn, parents));
+    }
+    // Depth first sequence of all nodes in this tree.
+    getNodes() {
+        const nodes = [];
+        this.traverse(node => nodes.push(node));
+        return nodes;
+    }
+    // Swap them order if this is two text nodes that are reversed.
+    sortRange(range) {
+        const start = range.start.node;
+        const end = range.end.node;
+        if (start === end)
+            return {
+                start: { node: start, index: Math.min(range.start.index, range.end.index) },
+                end: { node: end, index: Math.max(range.start.index, range.end.index) }
+            };
+        // Find the common ancestor of the two nodes.
+        const ancestor = start.getCommonAncestor(this, end);
+        if (ancestor === undefined)
+            return range;
+        // Where do these text nodes appear in the ancestor's node sequence?
+        let startIndex = ancestor.getNodes().indexOf(start);
+        let endIndex = ancestor.getNodes().indexOf(end);
+        // Defensively verify that we could find the given nodes in the document.
+        // If we can't, something is wrong upstream.
+        if (startIndex < 0 || endIndex < 0)
+            throw Error(`Couldn't find caret range node(s) in this tree.`);
+        // If we didn't find them, or the start is before the end, return the given range.
+        return startIndex === undefined || endIndex === undefined || startIndex < endIndex ?
+            range :
+            // If they're the same node, order the index.
+            startIndex === endIndex ?
+                {
+                    start: {
+                        node: range.start.node,
+                        index: Math.min(range.start.index, range.end.index)
+                    },
+                    end: {
+                        node: range.end.node,
+                        index: Math.max(range.start.index, range.end.index)
+                    }
+                } :
+                // Otherwise, swap the caret positions
+                { start: range.end, end: range.start };
+    }
+    getNode(id) { return this.getNodes().find(n => n.getID() === id); }
+    // An index of the given node in the depth-first traversal of the nodes.
+    getIndexOf(node) {
+        const index = this.getNodes().indexOf(node);
+        return index >= 0 ? index : undefined;
+    }
+    // True if this tree contains the given node.
+    contains(node) {
+        let found = false;
+        this.traverse(n => { if (n === node)
+            found = true; });
+        return found;
+    }
+    // Returns a list of the given node's parents in this tree, from root to direct parent.
+    getParentsOf(node) {
+        let parents = undefined;
+        this.traverse((n, p) => { if (n === node)
+            parents = p; });
+        if (parents === undefined)
+            return;
+        const withoutNode = [...parents];
+        withoutNode.pop();
+        return withoutNode;
+    }
+    getParent(root) { return root.getParentOf(this); }
+    hasAncestor(root, node) {
+        let parent = root.getParentOf(this);
+        while (parent) {
+            if (parent === node)
+                return true;
+            parent = root.getParentOf(parent);
+        }
+        return false;
+    }
+    getClosestParentOfType(root, type) {
+        let parent = root.getParentOf(this);
+        while (parent) {
+            if (parent instanceof type)
+                return parent;
+            parent = root.getParentOf(parent);
+        }
+        return undefined;
+    }
+    isInside(root, type) {
+        return this.getClosestParentMatching(root, p => p instanceof type) !== undefined;
+    }
+    getClosestParentMatching(root, match) {
+        let parent = root.getParentOf(this);
+        while (parent) {
+            if (match.call(undefined, parent))
+                return parent;
+            parent = root.getParentOf(parent);
+        }
+        return undefined;
+    }
+    getFarthestParentMatching(root, match) {
+        const matchingParents = this.getAncestors(root).filter(match);
+        return matchingParents.length > 0 ? matchingParents[matchingParents.length - 1] : undefined;
+    }
+    getAncestors(root) {
+        const ancestors = [];
+        let parent = root.getParentOf(this);
+        while (parent) {
+            ancestors.push(parent);
+            parent = root.getParentOf(parent);
+        }
+        return ancestors;
+    }
+    getCommonAncestor(root, node) {
+        const thisParents = this.getAncestors(root);
+        const thatParents = node.getAncestors(root);
+        for (let i = 0; i < thisParents.length; i++) {
+            for (let j = 0; j < thatParents.length; j++) {
+                if (thisParents[i] === thatParents[j])
+                    return thisParents[i];
+            }
+        }
+        return undefined;
+    }
+    // Traverse this node's children, trying to replace the given node with the replacement node (or nothing, if allowed)
+    withNodeReplaced(node, replacement) {
+        // Is this the node we're replacing? Return the replacement.
+        if (node === this)
+            return replacement;
+        // Find all the children
+        const children = this.getChildren();
+        // Search each one for a match.
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            // If we found the child, return a new version of this node with the child replaced.
+            if (child === node)
+                return this.withChildReplaced(node, replacement);
+            // Does this child have it? If so, return a version of this node with the revised child.
+            const revisedChild = child.withNodeReplaced(node, replacement);
+            if (revisedChild !== undefined)
+                return this.withChildReplaced(child, revisedChild);
+        }
+    }
+    // By default, a node doesn't know how to insert anything into itself. Subclasses
+    // are responsible for overriding this if they want to support specific insertions.
+    withNodeInserted(caret, node) { caret; node; return undefined; }
+    copyRange(range) {
+        const sortedRange = this.sortRange(range);
+        // Find the common ancestor of the range, then ask it to copy the portion of it selected and produce a node.
+        const commonAncestor = sortedRange.start.node.getCommonAncestor(this, sortedRange.end.node);
+        if (commonAncestor === undefined)
+            return;
+        return commonAncestor.withContentInRange(sortedRange);
+    }
+}

package/models/chapter/Node.test.d.ts

@@ -0,0 +1 @@
+export {};

package/models/chapter/Node.test.js

@@ -0,0 +1,27 @@
+import { test, expect } from 'vitest'
+
+import TextNode from "./TextNode";
+import FormatNode from "./FormatNode";
+
+const textOne = new TextNode("one");
+const textTwo = new TextNode("two");
+const textThree = new TextNode("three");
+const textFour = new TextNode("four");
+const textFive = new TextNode("five");
+const bold = new FormatNode("*", [ textThree, textFour ]);
+const format = new FormatNode("", [ textOne, textTwo, bold, textFive ]);
+
+test("Replace descendants", () => {
+    expect(format.withNodeReplaced(textThree, new TextNode("hi"))?.toBookdown())
+        .toBe("onetwo*hifour*five")
+
+    expect(format.withNodeReplaced(textFive, new TextNode("yo"))?.toBookdown())
+        .toBe("onetwo*threefour*yo")
+})
+
+test("Parents", () => {
+    const parents = format.getParentsOf(textThree);
+    expect(parents?.length).toBe(2);
+    expect(parents ? parents[0] : undefined).toBe(format);
+    expect(parents ? parents[1] : undefined).toBe(bold);
+})

package/models/chapter/ParagraphNode.d.ts

@@ -0,0 +1,33 @@
+import type Node from "./Node";
+import BlockNode from "./BlockNode";
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import type Caret from "./Caret";
+import type { CaretRange } from "./Caret";
+export default class ParagraphNode extends BlockNode {
+    #private;
+    constructor(level?: number, format?: FormatNode);
+    getType(): string;
+    getLevel(): number;
+    getFormat(): FormatNode;
+    getFormats(): FormatNode[];
+    getChildren(): FormatNode[];
+    getFirstTextNode(): TextNode;
+    getLastTextNode(): TextNode;
+    getTextNodes(): TextNode[];
+    getFirstCaret(): Caret | undefined;
+    getLastCaret(): Caret | undefined;
+    getSelection(): CaretRange;
+    getParentOf(node: Node): Node | undefined;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    withLevel(level: number): ParagraphNode;
+    withContent(content: FormatNode): ParagraphNode;
+    withParagraphAppended(paragraph: ParagraphNode): ParagraphNode;
+    withParagraphPrepended(paragraph: ParagraphNode): ParagraphNode;
+    split(caret: Caret): [ParagraphNode, ParagraphNode] | undefined;
+    copy(): this;
+    withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/ParagraphNode.js

@@ -0,0 +1,93 @@
+import BlockNode from "./BlockNode";
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import AtomNode from "./AtomNode";
+import MetadataNode from "./MetadataNode";
+export default class ParagraphNode extends BlockNode {
+    #format;
+    #level;
+    constructor(level = 0, format) {
+        super();
+        // Always ensure the paragraphs have an empty space at the begining and end for insertion.
+        let adjustedFormat = format ?? new FormatNode("", [new TextNode()]);
+        if (adjustedFormat.getLength() > 0) {
+            const first = adjustedFormat.getSegments()[0];
+            const last = adjustedFormat.getSegments()[adjustedFormat.getLength() - 1];
+            if (first instanceof AtomNode || first instanceof MetadataNode)
+                adjustedFormat = adjustedFormat.withSegmentPrepended(new TextNode());
+            if (last instanceof AtomNode || last instanceof MetadataNode)
+                adjustedFormat = adjustedFormat.withSegmentAppended(new TextNode());
+        }
+        // Always ensure a paragraph has at least an empty text node.
+        adjustedFormat = adjustedFormat.withTextIfEmpty();
+        this.#format = adjustedFormat;
+        this.#level = level;
+    }
+    getType() { return "paragraph"; }
+    getLevel() { return this.#level; }
+    getFormat() { return this.#format; }
+    getFormats() { return [this.#format]; }
+    getChildren() { return [this.#format]; }
+    getFirstTextNode() { return this.getFormat().getFirstTextNode(); }
+    getLastTextNode() { return this.getFormat().getLastTextNode(); }
+    getTextNodes() { return this.getNodes().filter(n => n instanceof TextNode); }
+    getFirstCaret() { return this.#format.getFirstCaret(); }
+    getLastCaret() { return this.#format.getLastCaret(); }
+    getSelection() {
+        const first = this.getFirstTextNode();
+        const last = this.getLastTextNode();
+        return { start: { node: first, index: 0 }, end: { node: last, index: last.getLength() } };
+    }
+    getParentOf(node) { return node === this.#format ? this : this.#format.getParentOf(node); }
+    toText() {
+        return this.#format.toText();
+    }
+    toBookdown() {
+        return (this.#level === 1 ? "# " : this.#level === 2 ? "## " : this.#level === 3 ? "### " : "") + this.#format.toBookdown();
+    }
+    toHTML() {
+        const tag = this.#level === 1 ? "h1" : this.#level === 2 ? "h2" : this.#level === 3 ? "h2" : "p";
+        return `<${tag}>${this.#format.toHTML()}</${tag}>`;
+    }
+    withLevel(level) { return new ParagraphNode(level, this.#format); }
+    withContent(content) { return new ParagraphNode(this.#level, content); }
+    withParagraphAppended(paragraph) {
+        return new ParagraphNode(this.#level, new FormatNode("", [...this.#format.getSegments(), ...paragraph.#format.getSegments()]));
+    }
+    withParagraphPrepended(paragraph) {
+        return new ParagraphNode(this.#level, new FormatNode("", [...paragraph.#format.getSegments(), ...this.#format.getSegments(),]));
+    }
+    split(caret) {
+        // If we weren't given a text node, do nothing.
+        if (!(caret.node instanceof TextNode))
+            return;
+        // If this caret isn't in this paragraph, do nothing.
+        if (this.getParentOf(caret.node) === undefined)
+            return;
+        // If the caret is at the last position of the paragraph, insert a new empty paragraph.
+        const lastTextNode = this.getLastTextNode();
+        if (caret.node === lastTextNode && caret.index === lastTextNode.getLength())
+            return [this.copy(), new ParagraphNode()];
+        // If the caret is in the first position of the paragraph, insert a new empty paragraph before.
+        const firstTextNode = this.getFirstTextNode();
+        if (caret.node === firstTextNode && caret.index === 0)
+            return [new ParagraphNode(), this.copy()];
+        // Otherwise, split the paragraph in two, with the caret at the beginning of the second.
+        const before = this.#format.withoutContentAfter(caret);
+        const after = this.#format.withoutContentBefore(caret);
+        if (after === undefined || before === undefined)
+            return;
+        return [new ParagraphNode(this.#level, before), new ParagraphNode(this.#level, after)];
+    }
+    copy() { return new ParagraphNode(this.#level, this.#format.copy()); }
+    withChildReplaced(node, replacement) {
+        return node === this.#format && (replacement instanceof FormatNode || replacement === undefined) ?
+            new ParagraphNode(this.#level, replacement) : undefined;
+    }
+    withContentInRange(range) {
+        const newFormat = this.#format.withContentInRange(range);
+        if (newFormat === undefined)
+            return;
+        return new ParagraphNode(this.#level, newFormat);
+    }
+}

package/models/chapter/ParagraphNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/models/chapter/ParagraphNode.test.js

@@ -0,0 +1,21 @@
+import { test, expect } from 'vitest';
+import FootnoteNode from "./FootnoteNode";
+import FormatNode from "./FormatNode";
+import ParagraphNode from "./ParagraphNode";
+import TextNode from "./TextNode";
+const firstText = new TextNode("This is the first paragraph. What do you think of it?");
+const lastText = new TextNode("This is the second paragraph. I think it's redundant.");
+const combinedText = new TextNode(firstText.getText() + lastText.getText());
+const footnote = new FootnoteNode(new FormatNode("", [new TextNode("Side note!")]));
+const firstParagraph = new ParagraphNode(0, new FormatNode("", [firstText, footnote]));
+const lastParagraph = new ParagraphNode(0, new FormatNode("", [lastText]));
+const combinedParagraph = new ParagraphNode(0, new FormatNode("", [combinedText, footnote]));
+test("Combine/split", () => {
+    expect(firstParagraph.withParagraphAppended(lastParagraph).toBookdown()).toBe(`${firstText.getText()}${footnote.toBookdown()}${lastText.getText()}`);
+    const split = combinedParagraph.split({ node: combinedText, index: combinedText.getText().indexOf(".") + 1 });
+    expect(split).not.toBeUndefined();
+    if (split) {
+        expect(split[0].toBookdown()).toBe(firstText.getText().substring(0, firstText.getText().indexOf(".") + 1));
+        expect(split[1].toBookdown()).toBe(firstText.getText().substring(firstText.getText().indexOf(".") + 1) + lastText.getText() + footnote.toBookdown());
+    }
+});

package/models/chapter/Parser.d.ts

@@ -0,0 +1,75 @@
+import type Edition from "../book/Edition";
+import CalloutNode from "./CalloutNode";
+import ChapterNode from "./ChapterNode";
+import CitationsNode from "./CitationsNode";
+import CodeNode from "./CodeNode";
+import CommentNode from "./CommentNode";
+import DefinitionNode from "./DefinitionNode";
+import EmbedNode from "./EmbedNode";
+import ErrorNode from "./ErrorNode";
+import FootnoteNode from "./FootnoteNode";
+import FormatNode from "./FormatNode";
+import InlineCodeNode from "./InlineCodeNode";
+import LabelNode from "./LabelNode";
+import LinkNode from "./LinkNode";
+import ListNode from "./ListNode";
+import ParagraphNode from "./ParagraphNode";
+import QuoteNode from "./QuoteNode";
+import ReferenceNode from "./ReferenceNode";
+import RuleNode from "./RuleNode";
+import TableNode from "./TableNode";
+import TextNode from "./TextNode";
+import type Position from "./Position";
+import type BlockNode from "./BlockNode";
+import type Bookkeeping from "./Bookkeeping";
+export default class Parser {
+    book: Edition | undefined;
+    text: string;
+    index: number;
+    openedDoubleQuote: boolean;
+    metadata: Bookkeeping;
+    constructor(book: Edition | undefined, text: string);
+    static preprocessSymbols(book: Edition, text: string): string;
+    static parseChapter(book: Edition | undefined, text: string): ChapterNode;
+    static parseFormat(book: Edition | undefined, text: string): FormatNode;
+    static parseEmbed(book: Edition | undefined, text: string): EmbedNode | ErrorNode;
+    static parseReference(citationID: string, ref: string | Array<string>, edition: Edition, short?: boolean): FormatNode | ErrorNode | ReferenceNode;
+    peek(): string | null;
+    more(): boolean;
+    read(smarten?: boolean): string | null;
+    unread(): void;
+    rest(): string;
+    charBeforeNext(): string | null;
+    charAfterNext(): string | null;
+    restOfLine(): string;
+    nextIs(text: string): boolean;
+    nextIsContentDelimiter(): boolean;
+    nextMatches(regex: RegExp): boolean;
+    isBlankLine(): boolean;
+    readWhitespace(): void;
+    readUntilNewLine(): string;
+    readUntilNewlineOr(string: string): string;
+    parseChapter(): ChapterNode;
+    parseSymbols(): void;
+    parseBlock(): BlockNode;
+    parseParagraph(): ParagraphNode;
+    parseHeader(): ParagraphNode;
+    parseRule(): RuleNode;
+    parseList(): ListNode;
+    parseCode(): CodeNode;
+    parsePosition(): Position;
+    parseQuote(): QuoteNode;
+    parseCallout(): CalloutNode;
+    parseTable(): TableNode;
+    parseFormat(awaiting?: string): FormatNode;
+    parseEmbed(): EmbedNode | ErrorNode;
+    parseComment(): CommentNode;
+    parseLabel(): LabelNode | ErrorNode;
+    parseStyle(awaiting: string): FormatNode | ErrorNode;
+    parseInlineCode(): InlineCodeNode;
+    parseCitations(): CitationsNode;
+    parseFootnote(): FootnoteNode;
+    parseDefinition(): DefinitionNode;
+    parseEscaped(): TextNode | ErrorNode;
+    parseLink(): LinkNode | ErrorNode;
+}