bookish-press 0.4.47 → 0.4.48

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

@@ -1,28 +1,14 @@
 import Node from './Node';
-import type Caret from './Caret';
-import {
-    type CaretRange,
-    indexToCaret,
-    caretToIndex,
-    type SelectableNode,
-} from './Caret';
-import type Edit from './Edit';
+import { indexToCaret, caretToIndex, } from './Caret';
 import FormatNode from './FormatNode';
-import type { Format, FormatNodeSegmentType } from './FormatNode';
 import TextNode from './TextNode';
 import AtomNode from './AtomNode';
-import type EmbedNode from './EmbedNode';
-
-export default abstract class BlockNode extends Node {
-    abstract getFormats(): FormatNode[];
-
+export default class BlockNode extends Node {
     isEmpty() {
         return this.getFormats().every((f) => f.isEmptyText());
     }
-    getTextNodes(): TextNode[] {
-        return this.getNodes().filter(
-            (n) => n instanceof TextNode
-        ) as TextNode[];
+    getTextNodes() {
+        return this.getNodes().filter((n) => n instanceof TextNode);
     }
     getFirstCaret() {
         return this.getFormats()[0].getFirstCaret();
@@ -33,8 +19,7 @@ export default abstract class BlockNode extends Node {
             ? undefined
             : formats[formats.length - 1].getLastCaret();
     }
-
-    getAdjacentCaret(caret: Caret, next: boolean): Caret | undefined {
+    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++) {
@@ -47,50 +32,40 @@ export default abstract class BlockNode extends Node {
                             ? formats[i + 1].getFirstCaret()
                             : formats[i + 1].getLastCaret()
                         : undefined;
-                else return adjacentCaret;
+                else
+                    return adjacentCaret;
             }
         }
     }
-
-    getNextTextOrAtom(node: SelectableNode): SelectableNode | undefined {
-        return this.getAdjacentCaret(
-            {
-                node: node,
-                index: node instanceof TextNode ? node.getLength() : 0,
-            },
-            true
-        )?.node;
+    getNextTextOrAtom(node) {
+        return this.getAdjacentCaret({
+            node: node,
+            index: node instanceof TextNode ? node.getLength() : 0,
+        }, true)?.node;
     }
-    getPreviousTextOrAtom(node: SelectableNode): SelectableNode | undefined {
+    getPreviousTextOrAtom(node) {
         return this.getAdjacentCaret({ node: node, index: 0 }, true)?.node;
     }
-
-    withSegmentAtSelection(
-        range: CaretRange,
-        nodeCreator: (text: string) => FormatNodeSegmentType
-    ): Edit {
-        let block: BlockNode = this;
+    withSegmentAtSelection(range, nodeCreator) {
+        let block = 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<FormatNode>(
-            block,
-            FormatNode
-        );
-        if (formatted === undefined) return;
-
+        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;
+        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: Caret, next: boolean): Edit | undefined {
+    withoutAdjacentContent(caret, next) {
         const formats = next ? this.getFormats() : this.getFormats().reverse();
         let editedFormat = undefined;
         let newFormatEdit = undefined;
@@ -106,30 +81,27 @@ export default abstract 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: CaretRange, format: Format | undefined): Edit {
+    withRangeFormatted(range, format) {
         const sortedRange = this.sortRange(range);
         const formats = this.getFormats();
-        let newRoot: this | undefined = this;
+        let newRoot = 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
@@ -137,32 +109,27 @@ export default abstract 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 as FormatNode;
-                    const deleteChild =
-                        newFormat.isEmptyText() &&
+                    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;
+                    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 } };
         }
     }

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;
+}