bookish-press 0.4.1 → 0.4.21

package/models/chapter/MetadataNode.js

@@ -1,4 +1,4 @@
-import Node from "./Node";
+import Node from './Node';
 export default class MetadataNode extends Node {
     #text;
     #meta;
@@ -7,10 +7,18 @@ export default class MetadataNode extends Node {
         this.#text = text;
         this.#meta = meta;
     }
-    getMeta() { return this.#meta; }
-    getText() { return this.#text; }
-    getChildren() { return [this.#text]; }
-    getParentOf(node) { return this.#text === node ? this : undefined; }
+    getMeta() {
+        return this.#meta;
+    }
+    getText() {
+        return this.#text;
+    }
+    getChildren() {
+        return [this.#text];
+    }
+    getParentOf(node) {
+        return this.#text === node ? this : undefined;
+    }
     withChildReplaced(node, replacement) {
         if (this.#text === node && replacement !== undefined)
             return this.withText(replacement);

package/models/chapter/Node.d.ts

@@ -1,6 +1,6 @@
-import type Caret from "./Caret";
-import type { CaretRange } from "./Caret";
-import type Edit from "./Edit";
+import type Caret from './Caret';
+import type { CaretRange } from './Caret';
+import type Edit from './Edit';
 export default abstract class Node {
     readonly nodeID: number;
     constructor();
@@ -16,6 +16,8 @@ export default abstract class Node {
     traverse(fn: (node: Node, parents: Node[]) => void, parents?: Node[]): void;
     traverseChildren(fn: (node: Node, parents: Node[]) => void, parents: Node[]): void;
     getNodes(): Node[];
+    getNodeBefore<Kind extends Node>(node: Node, matcher: (node: Kind) => boolean): Kind | undefined;
+    getNodeAfter<Kind extends Node>(node: Node, matcher: (node: Kind) => boolean): Kind | undefined;
     sortRange(range: CaretRange): CaretRange;
     getNode(id: number): Node | undefined;
     getIndexOf(node: Node): number | undefined;

package/models/chapter/Node.js

@@ -6,7 +6,9 @@ export default class Node {
     constructor() {
         this.nodeID = nodeID++;
     }
-    getID() { return this.nodeID; }
+    getID() {
+        return this.nodeID;
+    }
     traverse(fn, parents) {
         const path = parents === undefined ? [this] : [...parents, this];
         this.traverseChildren(fn, path);
@@ -15,22 +17,50 @@ export default class Node {
     // Traverses each of the children of this node.
     traverseChildren(fn, parents) {
         const children = this.getChildren();
-        children.forEach(child => child.traverse(fn, parents));
+        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));
+        this.traverse((node) => nodes.push(node));
         return nodes;
     }
+    getNodeBefore(node, matcher) {
+        const nodes = this.getNodes();
+        let previous = undefined;
+        for (const currentNode of nodes) {
+            if (currentNode === node)
+                return previous;
+            if (matcher(currentNode))
+                previous = currentNode;
+        }
+        return undefined;
+    }
+    getNodeAfter(node, matcher) {
+        const nodes = this.getNodes();
+        let found = false;
+        for (const currentNode of nodes) {
+            if (found && matcher(currentNode))
+                return currentNode;
+            if (currentNode === node)
+                found = true;
+        }
+        return undefined;
+    }
     // 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) }
+                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);
@@ -44,24 +74,28 @@ export default class Node {
         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)
+        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 };
+                    : // Otherwise, swap the caret positions
+                        { start: range.end, end: range.start };
+    }
+    getNode(id) {
+        return this.getNodes().find((n) => n.getID() === id);
     }
-    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);
@@ -70,22 +104,28 @@ export default class Node {
     // True if this tree contains the given node.
     contains(node) {
         let found = false;
-        this.traverse(n => { if (n === node)
-            found = true; });
+        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; });
+        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); }
+    getParent(root) {
+        return root.getParentOf(this);
+    }
     hasAncestor(root, node) {
         let parent = root.getParentOf(this);
         while (parent) {
@@ -105,7 +145,8 @@ export default class Node {
         return undefined;
     }
     isInside(root, type) {
-        return this.getClosestParentMatching(root, p => p instanceof type) !== undefined;
+        return (this.getClosestParentMatching(root, (p) => p instanceof type) !==
+            undefined);
     }
     getClosestParentMatching(root, match) {
         let parent = root.getParentOf(this);
@@ -118,7 +159,9 @@ export default class Node {
     }
     getFarthestParentMatching(root, match) {
         const matchingParents = this.getAncestors(root).filter(match);
-        return matchingParents.length > 0 ? matchingParents[matchingParents.length - 1] : undefined;
+        return matchingParents.length > 0
+            ? matchingParents[matchingParents.length - 1]
+            : undefined;
     }
     getAncestors(root) {
         const ancestors = [];
@@ -161,7 +204,11 @@ export default class Node {
     }
     // 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; }
+    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.

package/models/chapter/Node.test.js

@@ -1,27 +1,29 @@
-import { test, expect } from 'vitest'
+import { test, expect } from 'vitest';
 
-import TextNode from "./TextNode";
-import FormatNode from "./FormatNode";
+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 ]);
+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")
+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")
-})
+    expect(
+        format.withNodeReplaced(textFive, new TextNode('yo'))?.toBookdown()
+    ).toBe('onetwo*threefour*yo');
+});
 
-test("Parents", () => {
+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

@@ -1,9 +1,9 @@
-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";
+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);

package/models/chapter/ParagraphNode.js

@@ -1,15 +1,15 @@
-import BlockNode from "./BlockNode";
-import FormatNode from "./FormatNode";
-import TextNode from "./TextNode";
-import AtomNode from "./AtomNode";
-import MetadataNode from "./MetadataNode";
+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()]);
+        let adjustedFormat = format ?? new FormatNode('', [new TextNode()]);
         if (adjustedFormat.getLength() > 0) {
             const first = adjustedFormat.getSegments()[0];
             const last = adjustedFormat.getSegments()[adjustedFormat.getLength() - 1];
@@ -23,39 +23,86 @@ export default class ParagraphNode extends BlockNode {
         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(); }
+    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() } };
+        return {
+            start: { node: first, index: 0 },
+            end: { node: last, index: last.getLength() },
+        };
+    }
+    getParentOf(node) {
+        return node === this.#format ? this : this.#format.getParentOf(node);
     }
-    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();
+        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";
+        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); }
+    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()]));
+        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(),]));
+        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.
@@ -66,7 +113,8 @@ export default class ParagraphNode extends BlockNode {
             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())
+        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();
@@ -77,12 +125,19 @@ export default class ParagraphNode extends BlockNode {
         const after = this.#format.withoutContentBefore(caret);
         if (after === undefined || before === undefined)
             return;
-        return [new ParagraphNode(this.#level, before), new ParagraphNode(this.#level, after)];
+        return [
+            new ParagraphNode(this.#level, before),
+            new ParagraphNode(this.#level, after),
+        ];
+    }
+    copy() {
+        return new ParagraphNode(this.#level, this.#format.copy());
     }
-    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;
+        return node === this.#format &&
+            (replacement instanceof FormatNode || replacement === undefined)
+            ? new ParagraphNode(this.#level, replacement)
+            : undefined;
     }
     withContentInRange(range) {
         const newFormat = this.#format.withContentInRange(range);

package/models/chapter/ParagraphNode.test.js

@@ -1,21 +1,30 @@
 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?");
+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", () => {
+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 });
+    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());
+        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

@@ -1,27 +1,26 @@
-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";
+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 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;
@@ -33,9 +32,10 @@ export default class Parser {
     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;
+    nextIsEmptyParagraph(): boolean;
+    nextIsWhitespace(): boolean;
     read(smarten?: boolean): string | null;
     unread(): void;
     rest(): string;