bookish-press 0.4.47 → 0.4.48

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

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

package/{src/lib/models/chapter/ListNode.test.ts → models/chapter/ListNode.test.js}

@@ -1,9 +1,7 @@
 import { test, expect } from 'vitest';
-
 import FormatNode from './FormatNode';
 import ListNode from './ListNode';
 import TextNode from './TextNode';
-
 const oneText = new TextNode('one');
 const oneFormat = new FormatNode('', [oneText]);
 const twoText = new TextNode('two');
@@ -15,77 +13,42 @@ const fourFormat = new FormatNode('', [fourText]);
 const fiveText = new TextNode('five');
 const fiveFormat = new FormatNode('', [fiveText]);
 const shortList = new ListNode([oneFormat, twoFormat, threeFormat], false);
-const list = new ListNode(
-    [
-        oneFormat,
-        new ListNode([twoFormat, threeFormat, fourFormat], false),
-        fiveFormat,
-    ],
-    false
-);
-
+const list = new ListNode([
+    oneFormat,
+    new ListNode([twoFormat, threeFormat, fourFormat], false),
+    fiveFormat,
+], false);
 test('Insert items', () => {
-    expect(shortList.withItemAppended(fourFormat)?.toBookdown()).toBe(
-        `* one\n* two\n* three\n* four`
-    );
-    expect(shortList.withItemPrepended(fourFormat)?.toBookdown()).toBe(
-        `* four\n* one\n* two\n* three`
-    );
+    expect(shortList.withItemAppended(fourFormat)?.toBookdown()).toBe(`* one\n* two\n* three\n* four`);
+    expect(shortList.withItemPrepended(fourFormat)?.toBookdown()).toBe(`* four\n* one\n* two\n* three`);
     expect(shortList.withItemAt(fourFormat, 9)).toBeUndefined();
-    expect(shortList.withItemAt(fourFormat, 1)?.toBookdown()).toBe(
-        `* one\n* four\n* two\n* three`
-    );
-    expect(shortList.withItemAfter(fourFormat, oneFormat)?.toBookdown()).toBe(
-        `* one\n* four\n* two\n* three`
-    );
-    expect(shortList.withItemBefore(fourFormat, twoFormat)?.toBookdown()).toBe(
-        `* one\n* four\n* two\n* three`
-    );
-    expect(
-        shortList
-            .withListAppended(new ListNode([fourFormat, fiveFormat], true))
-            ?.toBookdown()
-    ).toBe(`* one\n* two\n* three\n* four\n* five`);
+    expect(shortList.withItemAt(fourFormat, 1)?.toBookdown()).toBe(`* one\n* four\n* two\n* three`);
+    expect(shortList.withItemAfter(fourFormat, oneFormat)?.toBookdown()).toBe(`* one\n* four\n* two\n* three`);
+    expect(shortList.withItemBefore(fourFormat, twoFormat)?.toBookdown()).toBe(`* one\n* four\n* two\n* three`);
+    expect(shortList
+        .withListAppended(new ListNode([fourFormat, fiveFormat], true))
+        ?.toBookdown()).toBe(`* one\n* two\n* three\n* four\n* five`);
 });
-
 test('Remove items', () => {
-    expect(shortList.withItemReplaced(1, fourFormat)?.toBookdown()).toBe(
-        `* one\n* four\n* three`
-    );
+    expect(shortList.withItemReplaced(1, fourFormat)?.toBookdown()).toBe(`* one\n* four\n* three`);
     expect(shortList.withoutItemAt(0)?.toBookdown()).toBe(`* two\n* three`);
 });
-
 test('Split', () => {
-    expect(
-        shortList.withItemSplit({ node: threeText, index: 2 })?.toBookdown()
-    ).toBe('* one\n* two\n* th\n* ree');
+    expect(shortList.withItemSplit({ node: threeText, index: 2 })?.toBookdown()).toBe('* one\n* two\n* th\n* ree');
 });
-
 test('Merge', () => {
     const merged = shortList.withItemMergedBackwards(1);
     expect(merged).not.toBeUndefined();
     if (merged !== undefined)
         expect(merged[0].toBookdown()).toBe('* onetwo\n* three');
 });
-
 test('Indent', () => {
-    expect(list.withItemIndented(oneFormat)?.toBookdown()).toBe(
-        `** one\n** two\n** three\n** four\n* five`
-    );
-    expect(list.withItemIndented(twoFormat)?.toBookdown()).toBe(
-        `* one\n*** two\n** three\n** four\n* five`
-    );
-    expect(list.withItemIndented(fiveFormat)?.toBookdown()).toBe(
-        `* one\n** two\n** three\n** four\n** five`
-    );
+    expect(list.withItemIndented(oneFormat)?.toBookdown()).toBe(`** one\n** two\n** three\n** four\n* five`);
+    expect(list.withItemIndented(twoFormat)?.toBookdown()).toBe(`* one\n*** two\n** three\n** four\n* five`);
+    expect(list.withItemIndented(fiveFormat)?.toBookdown()).toBe(`* one\n** two\n** three\n** four\n** five`);
 });
-
 test('Unindent', () => {
-    expect(list.withItemUnindented(twoFormat)?.toBookdown()).toBe(
-        `* one\n* two\n** three\n** four\n* five`
-    );
+    expect(list.withItemUnindented(twoFormat)?.toBookdown()).toBe(`* one\n* two\n** three\n** four\n* five`);
     expect(list.withItemUnindented(oneFormat)?.toBookdown()).toBeUndefined();
-    expect(list.withItemUnindented(threeFormat)?.toBookdown()).toBe(
-        `* one\n** two\n* three\n** four\n* five`
-    );
+    expect(list.withItemUnindented(threeFormat)?.toBookdown()).toBe(`* one\n** two\n* three\n** four\n* five`);
 });

package/models/chapter/MetadataNode.d.ts

@@ -0,0 +1,17 @@
+import type { CaretRange } from './Caret';
+import Node from './Node';
+import type TextNode from './TextNode';
+export default abstract class MetadataNode<MetaType> extends Node {
+    #private;
+    constructor(text: TextNode, meta: MetaType);
+    getMeta(): MetaType;
+    getText(): TextNode;
+    abstract withMeta(meta: MetaType): MetadataNode<MetaType>;
+    abstract withText(text: TextNode): MetadataNode<MetaType>;
+    abstract toText(): string;
+    abstract toBookdown(): string;
+    getChildren(): TextNode[];
+    getParentOf(node: Node): Node | undefined;
+    withChildReplaced(node: TextNode, replacement: TextNode | undefined): this | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/MetadataNode.js

@@ -0,0 +1,32 @@
+import Node from './Node';
+export default class MetadataNode extends Node {
+    #text;
+    #meta;
+    constructor(text, meta) {
+        super();
+        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;
+    }
+    withChildReplaced(node, replacement) {
+        if (this.#text === node && replacement !== undefined)
+            return this.withText(replacement);
+    }
+    withContentInRange(range) {
+        const selectedText = this.#text.withContentInRange(range);
+        if (selectedText === undefined)
+            return undefined;
+        return this.withText(selectedText);
+    }
+}

package/models/chapter/Node.d.ts

@@ -0,0 +1,38 @@
+import type Caret from './Caret';
+import type { CaretRange } from './Caret';
+import type Edit from './Edit';
+export default abstract class Node {
+    readonly nodeID: number;
+    constructor();
+    abstract toText(): string;
+    abstract toBookdown(): string;
+    abstract toHTML(): string;
+    abstract getType(): string;
+    abstract copy(): this;
+    abstract withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    abstract getChildren(): Node[];
+    abstract getParentOf(node: Node): Node | undefined;
+    getID(): number;
+    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;
+    contains(node: Node): boolean;
+    getParentsOf(node: Node): Node[] | undefined;
+    getParent(root: Node): Node | undefined;
+    hasAncestor(root: Node, node: Node): boolean;
+    getClosestParentOfType<T extends Node>(root: Node, type: Function): T | undefined;
+    isInside(root: Node, type: Function): boolean;
+    getClosestParentMatching(root: Node, match: (node: Node) => boolean): Node | undefined;
+    getFarthestParentMatching(root: Node, match: (node: Node) => boolean): Node | undefined;
+    getAncestors(root: Node): Node[];
+    getCommonAncestor(root: Node, node: Node): Node | undefined;
+    withNodeReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    abstract withContentInRange(range: CaretRange): this | undefined;
+    withNodeInserted(caret: Caret, node: Node): Edit;
+    copyRange(range: CaretRange): Node | undefined;
+}

package/{src/lib/models/chapter/Node.ts → models/chapter/Node.js}

@@ -1,106 +1,56 @@
-import type Caret from './Caret';
-import type { CaretRange } from './Caret';
-import type Edit from './Edit';
-
 // A global node ID generator, for mapping views back to models.
 let nodeID = 1;
-
-export default abstract class Node {
+export default class Node {
     // A globally unique identifier, helpful for mapping things back to nodes.
-    readonly nodeID: number;
-
+    nodeID;
     constructor() {
         this.nodeID = nodeID++;
     }
-
-    // Returns space-separated text in the string, helpful for searching.
-    abstract toText(): string;
-
-    // Returns a syntactically valid Bookdown string representing the node and it's children.
-    abstract toBookdown(): string;
-
-    // Returns valid HTML representing the node and it's children.
-    abstract toHTML(): string;
-
-    // Returns a string represent the type of node this is.
-    abstract getType(): string;
-
-    // Returns an exact copy of this now.
-    abstract copy(): this;
-
-    // Returns a new node with the given child node replaced, or undefined if it didn't contain such a child.
-    abstract withChildReplaced(
-        node: Node,
-        replacement: Node | undefined
-    ): this | undefined;
-
-    // Returns an ordered list of the child nodes.
-    abstract getChildren(): Node[];
-
-    // Recursively returns the parent of the given node.
-    abstract getParentOf(node: Node): Node | undefined;
-
     getID() {
         return this.nodeID;
     }
-
-    traverse(
-        fn: (node: Node, parents: Node[]) => void,
-        parents?: Node[]
-    ): void {
+    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: (node: Node, parents: Node[]) => void,
-        parents: Node[]
-    ): void {
+    traverseChildren(fn, parents) {
         const children = this.getChildren();
         children.forEach((child) => child.traverse(fn, parents));
     }
-
     // Depth first sequence of all nodes in this tree.
-    getNodes(): Node[] {
-        const nodes: Node[] = [];
+    getNodes() {
+        const nodes = [];
         this.traverse((node) => nodes.push(node));
         return nodes;
     }
-
-    getNodeBefore<Kind extends Node>(
-        node: Node,
-        matcher: (node: Kind) => boolean
-    ): Kind | undefined {
+    getNodeBefore(node, matcher) {
         const nodes = this.getNodes();
-        let previous: Kind | undefined = undefined;
+        let previous = undefined;
         for (const currentNode of nodes) {
-            if (currentNode === node) return previous;
-            if (matcher(currentNode as Kind)) previous = currentNode as Kind;
+            if (currentNode === node)
+                return previous;
+            if (matcher(currentNode))
+                previous = currentNode;
         }
         return undefined;
     }
-
-    getNodeAfter<Kind extends Node>(
-        node: Node,
-        matcher: (node: Kind) => boolean
-    ): Kind | undefined {
+    getNodeAfter(node, matcher) {
         const nodes = this.getNodes();
-        let found: boolean = false;
+        let found = false;
         for (const currentNode of nodes) {
-            if (found && matcher(currentNode as Kind))
-                return currentNode as Kind;
-            if (currentNode === node) found = true;
+            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: CaretRange): CaretRange {
+    sortRange(range) {
         const start = range.start.node;
         const end = range.end.node;
-
         if (start === end)
             return {
                 start: {
@@ -112,128 +62,108 @@ export default abstract class Node {
                     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;
-
+        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: number) {
+                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: Node): number | undefined {
+    getIndexOf(node) {
         const index = this.getNodes().indexOf(node);
         return index >= 0 ? index : undefined;
     }
-
     // True if this tree contains the given node.
-    contains(node: Node) {
+    contains(node) {
         let found = false;
         this.traverse((n) => {
-            if (n === node) found = true;
+            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: Node): Node[] | undefined {
+    getParentsOf(node) {
         let parents = undefined;
         this.traverse((n, p) => {
-            if (n === node) parents = p;
+            if (n === node)
+                parents = p;
         });
-        if (parents === undefined) return;
+        if (parents === undefined)
+            return;
         const withoutNode = [...parents];
         withoutNode.pop();
         return withoutNode;
     }
-
-    getParent(root: Node): Node | undefined {
+    getParent(root) {
         return root.getParentOf(this);
     }
-
-    hasAncestor(root: Node, node: Node): boolean {
+    hasAncestor(root, node) {
         let parent = root.getParentOf(this);
         while (parent) {
-            if (parent === node) return true;
+            if (parent === node)
+                return true;
             parent = root.getParentOf(parent);
         }
         return false;
     }
-
-    getClosestParentOfType<T extends Node>(
-        root: Node,
-        type: Function
-    ): T | undefined {
+    getClosestParentOfType(root, type) {
         let parent = root.getParentOf(this);
         while (parent) {
-            if (parent instanceof type) return parent as unknown as T;
+            if (parent instanceof type)
+                return parent;
             parent = root.getParentOf(parent);
         }
         return undefined;
     }
-
-    isInside(root: Node, type: Function) {
-        return (
-            this.getClosestParentMatching(root, (p) => p instanceof type) !==
-            undefined
-        );
+    isInside(root, type) {
+        return (this.getClosestParentMatching(root, (p) => p instanceof type) !==
+            undefined);
     }
-
-    getClosestParentMatching(
-        root: Node,
-        match: (node: Node) => boolean
-    ): Node | undefined {
+    getClosestParentMatching(root, match) {
         let parent = root.getParentOf(this);
         while (parent) {
-            if (match.call(undefined, parent)) return parent;
+            if (match.call(undefined, parent))
+                return parent;
             parent = root.getParentOf(parent);
         }
         return undefined;
     }
-
-    getFarthestParentMatching(
-        root: Node,
-        match: (node: Node) => boolean
-    ): Node | undefined {
+    getFarthestParentMatching(root, match) {
         const matchingParents = this.getAncestors(root).filter(match);
         return matchingParents.length > 0
             ? matchingParents[matchingParents.length - 1]
             : undefined;
     }
-
-    getAncestors(root: Node) {
+    getAncestors(root) {
         const ancestors = [];
         let parent = root.getParentOf(this);
         while (parent) {
@@ -242,27 +172,22 @@ export default abstract class Node {
         }
         return ancestors;
     }
-
-    getCommonAncestor(root: Node, node: Node): Node | undefined {
+    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];
+                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: Node,
-        replacement: Node | undefined
-    ): this | undefined {
+    withNodeReplaced(node, replacement) {
         // Is this the node we're replacing? Return the replacement.
-        if (node === this) return replacement as this;
-
+        if (node === this)
+            return replacement;
         // Find all the children
         const children = this.getChildren();
         // Search each one for a match.
@@ -271,34 +196,25 @@ export default abstract class Node {
             // 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);
         }
     }
-
-    // Given a range, return either a full copy of the node, or a partial copy if it contains the range.
-    // If there's a problem, it returns undefined. Assumes the range is sorted in parse order.
-    abstract withContentInRange(range: CaretRange): this | undefined;
-
     // 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: Caret, node: Node): Edit {
+    withNodeInserted(caret, node) {
         caret;
         node;
         return undefined;
     }
-
-    copyRange(range: CaretRange): Node | 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;
+        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/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;
+}