bookish-press 0.4.1 → 0.4.16

package/models/chapter/AtomNode.js

@@ -1,31 +1,38 @@
-import FormatNode from "./FormatNode";
-import Node from "./Node";
-import TextNode from "./TextNode";
+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; }
+    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] : []; }
+    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 };
+        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 };
+        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);
+        return this.getFarthestParentMatching(root, (p) => p instanceof FormatNode);
+    }
+    getCaretPositionCount() {
+        return 1;
     }
-    getCaretPositionCount() { return 1; }
 }

package/models/chapter/BlockNode.d.ts

@@ -1,11 +1,10 @@
-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";
+import Node from './Node';
+import type Caret from './Caret';
+import { type CaretRange, type SelectableNode } from './Caret';
+import type Edit from './Edit';
+import FormatNode from './FormatNode';
+import type { Format, FormatNodeSegmentType } from './FormatNode';
+import TextNode from './TextNode';
 export default abstract class BlockNode extends Node {
     abstract getFormats(): FormatNode[];
     isEmpty(): boolean;
@@ -13,8 +12,8 @@ export default abstract class BlockNode extends Node {
     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;
+    getNextTextOrAtom(node: SelectableNode): SelectableNode | undefined;
+    getPreviousTextOrAtom(node: SelectableNode): SelectableNode | 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

@@ -1,15 +1,23 @@
-import Node from "./Node";
-import { indexToCaret, caretToIndex } from "./Caret";
-import FormatNode from "./FormatNode";
-import TextNode from "./TextNode";
-import AtomNode from "./AtomNode";
+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(); }
+    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();
+        return formats.length === 0
+            ? undefined
+            : formats[formats.length - 1].getLastCaret();
     }
     getAdjacentCaret(caret, next) {
         const formats = next ? this.getFormats() : this.getFormats().reverse();
@@ -19,14 +27,21 @@ export default class BlockNode extends Node {
             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;
+                    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;
+        return this.getAdjacentCaret({
+            node: node,
+            index: node instanceof TextNode ? node.getLength() : 0,
+        }, true)?.node;
     }
     getPreviousTextOrAtom(node) {
         return this.getAdjacentCaret({ node: node, index: 0 }, true)?.node;
@@ -89,14 +104,18 @@ export default class BlockNode extends Node {
                 inRange = true;
             if (inRange) {
                 // Revise the entire format.
-                const first = containsStart ? sortedRange.start : f.getFirstCaret();
+                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;
+                    const deleteChild = newFormat.isEmptyText() &&
+                        !containsStart &&
+                        !containsEnd;
                     // Delete the format if it's empty.
                     newRoot = newRoot.withNodeReplaced(f, deleteChild ? undefined : newFormat);
                     if (newRoot === undefined)

package/models/chapter/BlocksNode.d.ts

@@ -1,13 +1,13 @@
-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";
+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[]);