bookish-press 0.4.47 → 0.4.48

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

@@ -1,45 +1,28 @@
 import { test, expect } from 'vitest';
-
 import FormatNode from './FormatNode';
 import TextNode from './TextNode';
 import TableNode from './TableNode';
-
 const tl = new FormatNode('', [new TextNode('tl')]);
 const tr = new FormatNode('', [new TextNode('tr')]);
 const bl = new FormatNode('', [new TextNode('bl')]);
 const br = new FormatNode('', [new TextNode('br')]);
 const caption = new FormatNode('', [new TextNode('hi')]);
-const table = new TableNode(
-    [
-        [tl, tr],
-        [bl, br],
-    ],
-    '|',
-    caption
-);
-
+const table = new TableNode([
+    [tl, tr],
+    [bl, br],
+], '|', caption);
 test('Replace', () => {
-    expect(
-        table
-            .withChildReplaced(tl, new FormatNode('', [new TextNode('new')]))
-            ?.toBookdown()
-    ).toBe(',new|tr\n,bl|br\nhi');
-
-    expect(
-        table
-            .withChildReplaced(
-                caption,
-                new FormatNode('', [new TextNode('bye')])
-            )
-            ?.toBookdown()
-    ).toBe(',tl|tr\n,bl|br\nbye');
+    expect(table
+        .withChildReplaced(tl, new FormatNode('', [new TextNode('new')]))
+        ?.toBookdown()).toBe(',new|tr\n,bl|br\nhi');
+    expect(table
+        .withChildReplaced(caption, new FormatNode('', [new TextNode('bye')]))
+        ?.toBookdown()).toBe(',tl|tr\n,bl|br\nbye');
 });
-
 test('Insert', () => {
     expect(table.withNewRow(0)?.toBookdown()).toBe(',|\n,tl|tr\n,bl|br\nhi');
     expect(table.withNewColumn(0)?.toBookdown()).toBe(',|tl|tr\n,|bl|br\nhi');
 });
-
 test('Delete', () => {
     expect(table.withoutRow(0)?.toBookdown()).toBe(',bl|br\nhi');
     expect(table.withoutColumn(0)?.toBookdown()).toBe(',tr\n,br\nhi');

package/models/chapter/TextNode.d.ts

@@ -0,0 +1,36 @@
+import type Caret from './Caret';
+import type { CaretRange } from './Caret';
+import FormatNode from './FormatNode';
+import Node from './Node';
+import BlocksNode from './BlocksNode';
+import type RootNode from './RootNode';
+export default class TextNode extends Node {
+    #private;
+    constructor(text?: string);
+    getType(): string;
+    getText(): string;
+    getLength(): number;
+    getCaretPositionCount(): number;
+    getParentOf(): Node | undefined;
+    getFirstCaret(): Caret;
+    getLastCaret(): Caret;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): never[];
+    copy(): this;
+    isItalic(root: Node): boolean;
+    isBold(root: Node): boolean;
+    isEmpty(): boolean;
+    getFormat(root: Node): FormatNode | undefined;
+    getFormatRoot(root: Node): FormatNode | undefined;
+    getBlocks(root: Node): BlocksNode | undefined;
+    getNextCaret(index: number): Caret | undefined;
+    getPreviousCaret(index: number): Caret | undefined;
+    nextWord(root: RootNode, index?: number): Caret;
+    previousWord(root: RootNode, index?: number): Caret;
+    withChildReplaced(): undefined;
+    withCharacterAt(char: string, index: number): TextNode | undefined;
+    withoutRange(range: CaretRange): TextNode | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}

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

@@ -1,19 +1,13 @@
-import type Caret from './Caret';
-import type { CaretRange } from './Caret';
 import FormatNode from './FormatNode';
 import Node from './Node';
 import AtomNode from './AtomNode';
 import BlocksNode from './BlocksNode';
-import type RootNode from './RootNode';
-
 export default class TextNode extends Node {
-    readonly #text: string;
-
-    constructor(text: string = '') {
+    #text;
+    constructor(text = '') {
         super();
         this.#text = text;
     }
-
     getType() {
         return 'text';
     }
@@ -26,21 +20,19 @@ export default class TextNode extends Node {
     getCaretPositionCount() {
         return this.#text.length;
     }
-    getParentOf(): Node | undefined {
+    getParentOf() {
         return undefined;
     }
-    getFirstCaret(): Caret {
+    getFirstCaret() {
         return { node: this, index: 0 };
     }
-    getLastCaret(): Caret {
+    getLastCaret() {
         return { node: this, index: this.#text.length };
     }
-
-    toText(): string {
+    toText() {
         return this.#text;
     }
-
-    toBookdown(): string {
+    toBookdown() {
         // Escape all characters with special meaning inside content nodes: _*`<^{~\[@% and :'s with no space after
         return this.#text
             .replace(/\\/g, '\\\\') // This has to go first! Otherwise it breaks all of the others below.
@@ -56,7 +48,6 @@ export default class TextNode extends Node {
             .replace(/@/g, '\\@')
             .replace(/(:)([a-z])/g, '\\:$2');
     }
-
     toHTML() {
         return this.#text
             .replace('<', '&lt;')
@@ -65,164 +56,121 @@ export default class TextNode extends Node {
             .replace('"', '&quot;')
             .replace("'", '&#39;');
     }
-
     getChildren() {
         return [];
     }
-
     copy() {
-        return new TextNode(this.#text) as this;
-    }
-
-    isItalic(root: Node) {
-        return (
-            this.getAncestors(root).filter(
-                (p) => p instanceof FormatNode && p.getFormat() === '_'
-            ).length > 0
-        );
-    }
-    isBold(root: Node) {
-        return (
-            this.getAncestors(root).filter(
-                (p) => p instanceof FormatNode && p.getFormat() === '*'
-            ).length > 0
-        );
-    }
-
+        return new TextNode(this.#text);
+    }
+    isItalic(root) {
+        return (this.getAncestors(root).filter((p) => p instanceof FormatNode && p.getFormat() === '_').length > 0);
+    }
+    isBold(root) {
+        return (this.getAncestors(root).filter((p) => p instanceof FormatNode && p.getFormat() === '*').length > 0);
+    }
     isEmpty() {
         return this.getLength() === 0;
     }
-
-    getFormat(root: Node): FormatNode | undefined {
-        return this.getClosestParentOfType<FormatNode>(root, FormatNode);
+    getFormat(root) {
+        return this.getClosestParentOfType(root, FormatNode);
     }
-
-    getFormatRoot(root: Node): FormatNode | undefined {
+    getFormatRoot(root) {
         // The format root is the highest format in the tree that contains this text.
         // There is one exception to this, however: formats inside atom nodes shouldn't traverse
         // past the atom node, since should be isolated from edits outside the atom.
-        const atom = this.getClosestParentMatching(
-            root,
-            (p) => p instanceof AtomNode
-        ) as AtomNode<FormatNode>;
-        if (atom && atom.getMeta() instanceof FormatNode) return atom.getMeta();
-
+        const atom = this.getClosestParentMatching(root, (p) => p instanceof AtomNode);
+        if (atom && atom.getMeta() instanceof FormatNode)
+            return atom.getMeta();
         // If this isn't in an atom, just return the highest format this is in.
-        return this.getFarthestParentMatching(
-            root,
-            (p) => p instanceof FormatNode
-        ) as FormatNode;
+        return this.getFarthestParentMatching(root, (p) => p instanceof FormatNode);
     }
-
-    getBlocks(root: Node): BlocksNode | undefined {
-        return this.getClosestParentOfType<BlocksNode>(root, BlocksNode);
+    getBlocks(root) {
+        return this.getClosestParentOfType(root, BlocksNode);
     }
-
-    getNextCaret(index: number): Caret | undefined {
+    getNextCaret(index) {
         return index < this.#text.length
             ? { node: this, index: index + 1 }
             : undefined;
     }
-
-    getPreviousCaret(index: number): Caret | undefined {
+    getPreviousCaret(index) {
         return index > 0 ? { node: this, index: index - 1 } : undefined;
     }
-
-    nextWord(root: RootNode, index?: number): Caret {
-        if (index === undefined) index = 0;
-
+    nextWord(root, index) {
+        if (index === undefined)
+            index = 0;
         // Search for the space after the given index.
         let i = index + 1;
-        while (i < this.getLength() && this.#text.charAt(i).match(/\W/)) i++;
-        while (i < this.getLength() && this.#text.charAt(i).match(/\w/)) i++;
-
+        while (i < this.getLength() && this.#text.charAt(i).match(/\W/))
+            i++;
+        while (i < this.getLength() && this.#text.charAt(i).match(/\w/))
+            i++;
         // If we found one in this node, return it.
-        if (
-            i < this.getLength() ||
-            (i === this.getLength() && this.#text.charAt(i - 1).match(/\w/))
-        )
+        if (i < this.getLength() ||
+            (i === this.getLength() && this.#text.charAt(i - 1).match(/\w/)))
             return { node: this, index: i };
-
         // Otherwise, find the next text node's next word boundary.
         const format = this.getFormatRoot(root);
         const formatTextNodes = format ? format.getTextNodes() : undefined;
         const nextNode = root.getNextTextOrAtom(this);
         const nextWord = nextNode?.nextWord(root);
-
         // If there isn't one, just go to the end of this.
-        if (
-            formatTextNodes &&
+        if (formatTextNodes &&
             nextNode &&
-            this === formatTextNodes[formatTextNodes.length - 1]
-        )
+            this === formatTextNodes[formatTextNodes.length - 1])
             return { node: nextNode, index: 0 };
         else if (nextWord === undefined)
             return { node: this, index: this.#text.length };
-        else return nextWord;
+        else
+            return nextWord;
     }
-
-    previousWord(root: RootNode, index?: number): Caret {
-        if (index === undefined) index = this.#text.length;
-
+    previousWord(root, index) {
+        if (index === undefined)
+            index = this.#text.length;
         // Scan left until we find a word character, then keep scanning until we reach a non-word character.
         let i = index - 1;
-        while (i > 0 && this.#text.charAt(i - 1).match(/\W/)) i--;
-        while (i > 0 && this.#text.charAt(i - 1).match(/\w/)) i--;
-
+        while (i > 0 && this.#text.charAt(i - 1).match(/\W/))
+            i--;
+        while (i > 0 && this.#text.charAt(i - 1).match(/\w/))
+            i--;
         // If we found one in this node, return it.
         if (i > 0 || (i === 0 && this.#text.charAt(0).match(/\w/)))
             return { node: this, index: i };
-
         // Otherwise, find the next text node's next word boundary.
         const format = this.getFormatRoot(root);
         const formatTextNodes = format ? format.getTextNodes() : undefined;
         const previousNode = root.getPreviousTextOrAtom(this);
         const previousWord = previousNode?.previousWord(root);
-
         // If there isn't one, just go to the end of this.
         if (formatTextNodes && previousNode && this === formatTextNodes[0])
             return {
                 node: previousNode,
-                index:
-                    previousNode instanceof TextNode
-                        ? previousNode.getLength()
-                        : 0,
+                index: previousNode instanceof TextNode
+                    ? previousNode.getLength()
+                    : 0,
             };
-        else if (previousWord === undefined) return { node: this, index: 0 };
-        else return previousWord;
+        else if (previousWord === undefined)
+            return { node: this, index: 0 };
+        else
+            return previousWord;
     }
-
     withChildReplaced() {
         return undefined;
     }
-
-    withCharacterAt(char: string, index: number): TextNode | undefined {
-        if (index < 0 || index > this.#text.length) return undefined;
-        return new TextNode(
-            this.#text.slice(0, index) + char + this.#text.slice(index)
-        );
+    withCharacterAt(char, index) {
+        if (index < 0 || index > this.#text.length)
+            return undefined;
+        return new TextNode(this.#text.slice(0, index) + char + this.#text.slice(index));
     }
-
-    withoutRange(range: CaretRange): TextNode | undefined {
-        if (range.start.node !== this && range.end.node !== this) return;
+    withoutRange(range) {
+        if (range.start.node !== this && range.end.node !== this)
+            return;
         const min = Math.max(0, Math.min(range.start.index, range.end.index));
-        const max = Math.min(
-            this.#text.length,
-            Math.max(range.start.index, range.end.index)
-        );
-        return new TextNode(
-            this.#text.substring(0, min) + this.#text.substring(max)
-        );
-    }
-
-    withContentInRange(range: CaretRange): this | undefined {
+        const max = Math.min(this.#text.length, Math.max(range.start.index, range.end.index));
+        return new TextNode(this.#text.substring(0, min) + this.#text.substring(max));
+    }
+    withContentInRange(range) {
         const includesStart = range.start.node === this;
         const includesEnd = range.end.node === this;
-        return new TextNode(
-            this.#text.substring(
-                includesStart ? range.start.index : 0,
-                includesEnd ? range.end.index : this.#text.length
-            )
-        ) as this;
+        return new TextNode(this.#text.substring(includesStart ? range.start.index : 0, includesEnd ? range.end.index : this.#text.length));
     }
 }

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

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

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

@@ -1,7 +1,5 @@
 import { test, expect } from 'vitest';
-
 import TextNode from './TextNode';
-
 test('Insert character', () => {
     const text = new TextNode('Hello');
     expect(text.withCharacterAt('!', 5)?.toBookdown()).toBe('Hello!');