bookish-press 0.4.0

package/models/chapter/AtomNode.js

@@ -0,0 +1,31 @@
+import FormatNode from "./FormatNode";
+import Node from "./Node";
+import TextNode from "./TextNode";
+export default class AtomNode extends Node {
+    #meta;
+    constructor(meta) {
+        super();
+        this.#meta = meta;
+    }
+    getMeta() { return this.#meta; }
+    // Include the meta node if it's a node, to include it in normal operations.
+    // We special case it in other places to avoid breaking other conventions (such as formatting changes, which
+    // the atom node should be isolated from).
+    getChildren() { return this.#meta instanceof Node ? [this.#meta] : []; }
+    nextWord(root) {
+        const next = root.getNextTextOrAtom(this);
+        return next ?
+            { node: next, index: 0 } :
+            { node: this, index: 0 };
+    }
+    previousWord(root) {
+        const previous = root.getPreviousTextOrAtom(this);
+        return previous ?
+            { node: previous, index: previous instanceof TextNode ? previous.getLength() : 0 } :
+            { node: this, index: 0 };
+    }
+    getFormatRoot(root) {
+        return this.getFarthestParentMatching(root, p => p instanceof FormatNode);
+    }
+    getCaretPositionCount() { return 1; }
+}

package/models/chapter/BlockNode.d.ts

@@ -0,0 +1,21 @@
+import Node from "./Node";
+import type Caret from "./Caret";
+import { type CaretRange } from "./Caret";
+import type Edit from "./Edit";
+import FormatNode from "./FormatNode";
+import type { Format, FormatNodeSegmentType } from "./FormatNode";
+import TextNode from "./TextNode";
+import AtomNode from "./AtomNode";
+export default abstract class BlockNode extends Node {
+    abstract getFormats(): FormatNode[];
+    isEmpty(): boolean;
+    getTextNodes(): TextNode[];
+    getFirstCaret(): Caret | undefined;
+    getLastCaret(): Caret | undefined;
+    getAdjacentCaret(caret: Caret, next: boolean): Caret | undefined;
+    getNextTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getPreviousTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    withSegmentAtSelection(range: CaretRange, nodeCreator: (text: string) => FormatNodeSegmentType): Edit;
+    withoutAdjacentContent(caret: Caret, next: boolean): Edit | undefined;
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit;
+}

package/models/chapter/BlockNode.js

@@ -0,0 +1,117 @@
+import Node from "./Node";
+import { indexToCaret, caretToIndex } from "./Caret";
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import AtomNode from "./AtomNode";
+export default class BlockNode extends Node {
+    isEmpty() { return this.getFormats().every(f => f.isEmptyText()); }
+    getTextNodes() { return this.getNodes().filter(n => n instanceof TextNode); }
+    getFirstCaret() { return this.getFormats()[0].getFirstCaret(); }
+    getLastCaret() {
+        const formats = this.getFormats();
+        return formats.length === 0 ? undefined : formats[formats.length - 1].getLastCaret();
+    }
+    getAdjacentCaret(caret, next) {
+        const formats = next ? this.getFormats() : this.getFormats().reverse();
+        // Iterate throught the formats and find the one that contains the caret.
+        for (let i = 0; i < formats.length; i++) {
+            const format = formats[i];
+            if (format.contains(caret.node)) {
+                const adjacentCaret = format.getAdjacentCaret(caret, next);
+                if (adjacentCaret === undefined)
+                    return i < formats.length - 1 ? (next ? formats[i + 1].getFirstCaret() : formats[i + 1].getLastCaret()) : undefined;
+                else
+                    return adjacentCaret;
+            }
+        }
+    }
+    getNextTextOrAtom(node) {
+        return this.getAdjacentCaret({ node: node, index: node instanceof AtomNode ? 0 : node.getLength() }, true)?.node;
+    }
+    getPreviousTextOrAtom(node) {
+        return this.getAdjacentCaret({ node: node, index: 0 }, true)?.node;
+    }
+    withSegmentAtSelection(range, nodeCreator) {
+        let block = this;
+        let caret = range.start;
+        // Only works at a text node.
+        if (!(caret.node instanceof TextNode))
+            return;
+        // Get the nearest FormatNode parent of the selected text. Bail on fail.
+        const formatted = caret.node.getClosestParentOfType(block, FormatNode);
+        if (formatted === undefined)
+            return;
+        // Update the format and replace it in the blocks.
+        const edit = formatted.withSegmentAtSelection(range, nodeCreator);
+        if (edit === undefined || !(edit.root instanceof FormatNode))
+            return;
+        const newBlock = block.withNodeReplaced(formatted, edit.root);
+        if (newBlock === undefined)
+            return;
+        return { root: newBlock, range: edit.range };
+    }
+    withoutAdjacentContent(caret, next) {
+        const formats = next ? this.getFormats() : this.getFormats().reverse();
+        let editedFormat = undefined;
+        let newFormatEdit = undefined;
+        while (formats.length > 0) {
+            const format = formats.shift();
+            if (format) {
+                const edit = format.withoutAdjacentContent(caret, next);
+                if (edit) {
+                    editedFormat = format;
+                    newFormatEdit = edit;
+                    break;
+                }
+            }
+        }
+        if (newFormatEdit && editedFormat) {
+            const newRoot = this.withChildReplaced(editedFormat, newFormatEdit.root);
+            if (newRoot)
+                return { root: newRoot, range: newFormatEdit.range };
+        }
+    }
+    withRangeFormatted(range, format) {
+        const sortedRange = this.sortRange(range);
+        const formats = this.getFormats();
+        let newRoot = this;
+        let inRange = false;
+        const startIndex = caretToIndex(this, sortedRange.start);
+        const endIndex = caretToIndex(this, sortedRange.end);
+        if (startIndex === undefined || endIndex === undefined)
+            return;
+        // Find all of the formats contained in the range and format then.
+        for (let i = 0; i < formats.length; i++) {
+            const f = formats[i];
+            const containsStart = f.contains(sortedRange.start.node);
+            const containsEnd = f.contains(sortedRange.end.node);
+            if (containsStart || containsEnd)
+                inRange = true;
+            if (inRange) {
+                // Revise the entire format.
+                const first = containsStart ? sortedRange.start : f.getFirstCaret();
+                const last = containsEnd ? sortedRange.end : f.getLastCaret();
+                if (first && last) {
+                    const edit = f.withRangeFormatted({ start: first, end: last }, format);
+                    if (edit === undefined)
+                        return;
+                    const newFormat = edit.root;
+                    const deleteChild = newFormat.isEmptyText() && !containsStart && !containsEnd;
+                    // Delete the format if it's empty.
+                    newRoot = newRoot.withNodeReplaced(f, deleteChild ? undefined : newFormat);
+                    if (newRoot === undefined)
+                        return;
+                }
+            }
+            if (containsEnd)
+                inRange = false;
+        }
+        if (newRoot) {
+            const start = indexToCaret(newRoot, startIndex);
+            const end = format === undefined ? start : indexToCaret(newRoot, endIndex);
+            if (start === undefined || end === undefined)
+                return;
+            return { root: newRoot, range: { start: start, end: end } };
+        }
+    }
+}

package/models/chapter/BlocksNode.d.ts

@@ -0,0 +1,50 @@
+import type Node from "./Node";
+import BlockNode from "./BlockNode";
+import ListNode from "./ListNode";
+import type Caret from "./Caret";
+import type { CaretRange } from "./Caret";
+import type { Format, FormatNodeSegmentType } from "./FormatNode";
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import AtomNode from "./AtomNode";
+import type Edit from "./Edit";
+export default abstract class BlocksNode extends BlockNode {
+    #private;
+    constructor(elements: BlockNode[]);
+    getBlocks(): BlockNode[];
+    getFormats(): FormatNode[];
+    getIndexOf(block: BlockNode): number | undefined;
+    getBlockBefore(anchor: BlockNode): BlockNode | undefined;
+    getBlockAfter(anchor: BlockNode): BlockNode | undefined;
+    getBlocksBetween(first: BlockNode, last: BlockNode): BlockNode[] | undefined;
+    getBlocksInRange(range: CaretRange): BlockNode[] | undefined;
+    getBlockOfCaret(caret: Caret): BlockNode | undefined;
+    getParentOf(node: Node): Node | undefined;
+    getTextNodes(): TextNode[];
+    getAtomNodes(): AtomNode<any>[];
+    getTextAndAtomNodes(): (TextNode | AtomNode<any>)[];
+    getIndexOfTextNode(node: TextNode): number | undefined;
+    getFirstCaret(): Caret | undefined;
+    getLastCaret(): Caret | undefined;
+    getAdjacentCaret(caret: Caret, next: boolean): Caret | undefined;
+    getSelectedFormatRange(format: FormatNode, range: CaretRange): CaretRange | undefined;
+    abstract create(blocks: BlockNode[]): BlocksNode;
+    withContentInRange(range: CaretRange): this | undefined;
+    withBlockInserted(anchor: BlockNode, block: BlockNode, before: boolean): BlocksNode | undefined;
+    withBlockAppended(block: BlockNode): BlocksNode;
+    withoutBlock(block: BlockNode): BlocksNode;
+    withBlockInsertedBefore(anchor: BlockNode, block: BlockNode): BlocksNode | undefined;
+    withBlockInsertedAfter(anchor: BlockNode, block: BlockNode): BlocksNode | undefined;
+    withSelectionSplit(range: CaretRange): Edit;
+    withoutRange(range: CaretRange): Edit;
+    withoutAtom(atom: AtomNode<any>): Edit;
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit;
+    withSegmentAtSelection(range: CaretRange, nodeCreator: (text: string) => FormatNodeSegmentType): Edit;
+    withParagraphsAsLists(range: CaretRange, numbered: boolean): BlocksNode | undefined;
+    withListsAsParagraphs(range: CaretRange): BlocksNode | undefined;
+    withListsIndented(range: CaretRange, indent: boolean): BlocksNode | undefined;
+    withListAsStyle(list: ListNode, numbered: boolean): BlocksNode | undefined;
+    withoutAdjacentContent(caret: Caret, next: boolean): Edit | undefined;
+    withNodeInserted(caret: Caret, node: Node): Edit;
+    toHTML(): string;
+}