bookish-press 0.4.46 → 0.4.47

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

@@ -1,14 +1,28 @@
 import Node from './Node';
-import { indexToCaret, caretToIndex, } from './Caret';
+import type Caret from './Caret';
+import {
+    type CaretRange,
+    indexToCaret,
+    caretToIndex,
+    type SelectableNode,
+} 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 class BlockNode extends Node {
+import type EmbedNode from './EmbedNode';
+
+export default abstract class BlockNode extends Node {
+    abstract getFormats(): FormatNode[];
+
     isEmpty() {
         return this.getFormats().every((f) => f.isEmptyText());
     }
-    getTextNodes() {
-        return this.getNodes().filter((n) => n instanceof TextNode);
+    getTextNodes(): TextNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof TextNode
+        ) as TextNode[];
     }
     getFirstCaret() {
         return this.getFormats()[0].getFirstCaret();
@@ -19,7 +33,8 @@ export default class BlockNode extends Node {
             ? undefined
             : formats[formats.length - 1].getLastCaret();
     }
-    getAdjacentCaret(caret, next) {
+
+    getAdjacentCaret(caret: Caret, next: boolean): Caret | undefined {
         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++) {
@@ -32,40 +47,50 @@ export default class BlockNode extends Node {
                             ? formats[i + 1].getFirstCaret()
                             : formats[i + 1].getLastCaret()
                         : undefined;
-                else
-                    return adjacentCaret;
+                else return adjacentCaret;
             }
         }
     }
-    getNextTextOrAtom(node) {
-        return this.getAdjacentCaret({
-            node: node,
-            index: node instanceof TextNode ? node.getLength() : 0,
-        }, true)?.node;
+
+    getNextTextOrAtom(node: SelectableNode): SelectableNode | undefined {
+        return this.getAdjacentCaret(
+            {
+                node: node,
+                index: node instanceof TextNode ? node.getLength() : 0,
+            },
+            true
+        )?.node;
     }
-    getPreviousTextOrAtom(node) {
+    getPreviousTextOrAtom(node: SelectableNode): SelectableNode | undefined {
         return this.getAdjacentCaret({ node: node, index: 0 }, true)?.node;
     }
-    withSegmentAtSelection(range, nodeCreator) {
-        let block = this;
+
+    withSegmentAtSelection(
+        range: CaretRange,
+        nodeCreator: (text: string) => FormatNodeSegmentType
+    ): Edit {
+        let block: BlockNode = this;
         let caret = range.start;
+
         // Only works at a text node.
-        if (!(caret.node instanceof TextNode))
-            return;
+        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;
+        const formatted = caret.node.getClosestParentOfType<FormatNode>(
+            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;
+        if (edit === undefined || !(edit.root instanceof FormatNode)) return;
         const newBlock = block.withNodeReplaced(formatted, edit.root);
-        if (newBlock === undefined)
-            return;
+        if (newBlock === undefined) return;
         return { root: newBlock, range: edit.range };
     }
-    withoutAdjacentContent(caret, next) {
+
+    withoutAdjacentContent(caret: Caret, next: boolean): Edit | undefined {
         const formats = next ? this.getFormats() : this.getFormats().reverse();
         let editedFormat = undefined;
         let newFormatEdit = undefined;
@@ -81,27 +106,30 @@ export default class BlockNode extends Node {
             }
         }
         if (newFormatEdit && editedFormat) {
-            const newRoot = this.withChildReplaced(editedFormat, newFormatEdit.root);
-            if (newRoot)
-                return { root: newRoot, range: newFormatEdit.range };
+            const newRoot = this.withChildReplaced(
+                editedFormat,
+                newFormatEdit.root
+            );
+            if (newRoot) return { root: newRoot, range: newFormatEdit.range };
         }
     }
-    withRangeFormatted(range, format) {
+
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit {
         const sortedRange = this.sortRange(range);
         const formats = this.getFormats();
-        let newRoot = this;
+        let newRoot: this | undefined = this;
         let inRange = false;
+
         const startIndex = caretToIndex(this, sortedRange.start);
         const endIndex = caretToIndex(this, sortedRange.end);
-        if (startIndex === undefined || endIndex === undefined)
-            return;
+        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 (containsStart || containsEnd) inRange = true;
             if (inRange) {
                 // Revise the entire format.
                 const first = containsStart
@@ -109,27 +137,32 @@ export default class BlockNode extends Node {
                     : 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() &&
+                    const edit = f.withRangeFormatted(
+                        { start: first, end: last },
+                        format
+                    );
+                    if (edit === undefined) return;
+                    const newFormat = edit.root as FormatNode;
+                    const deleteChild =
+                        newFormat.isEmptyText() &&
                         !containsStart &&
                         !containsEnd;
                     // Delete the format if it's empty.
-                    newRoot = newRoot.withNodeReplaced(f, deleteChild ? undefined : newFormat);
-                    if (newRoot === undefined)
-                        return;
+                    newRoot = newRoot.withNodeReplaced(
+                        f,
+                        deleteChild ? undefined : newFormat
+                    );
+                    if (newRoot === undefined) return;
                 }
             }
-            if (containsEnd)
-                inRange = false;
+            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;
+            const end =
+                format === undefined ? start : indexToCaret(newRoot, endIndex);
+            if (start === undefined || end === undefined) return;
             return { root: newRoot, range: { start: start, end: end } };
         }
     }