bookish-press 0.4.45 → 0.4.47

package/src/lib/models/chapter/QuoteNode.ts

@@ -0,0 +1,135 @@
+import type Node from './Node';
+import BlockNode from './BlockNode';
+import type Position from './Position';
+import FormatNode from './FormatNode';
+import BlocksNode from './BlocksNode';
+import TextNode from './TextNode';
+import type { CaretRange } from './Caret';
+
+export default class QuoteNode extends BlocksNode {
+    readonly #credit: FormatNode;
+    readonly #position: Position;
+
+    constructor(
+        elements: BlockNode[],
+        credit?: FormatNode,
+        position: Position = '|'
+    ) {
+        super(elements);
+
+        this.#position = position;
+        this.#credit =
+            credit === undefined
+                ? new FormatNode('', [new TextNode()])
+                : credit.withTextIfEmpty();
+    }
+
+    getType() {
+        return 'quote';
+    }
+
+    getCredit() {
+        return this.#credit;
+    }
+    getPosition() {
+        return this.#position;
+    }
+
+    getFormats() {
+        return [this.#credit];
+    }
+
+    toText(): string {
+        return (
+            this.getBlocks()
+                .map((element) => element.toText())
+                .join(' ') + (this.#credit ? ' ' + this.#credit.toText() : '')
+        );
+    }
+
+    toBookdown(): string {
+        return `"\n${this.getBlocks()
+            .map((element) => element.toBookdown())
+            .join('\n\n')}\n"${this.#position === '|' ? '' : this.#position}${
+            this.#credit ? this.#credit.toBookdown() : ''
+        }`;
+    }
+    toHTML() {
+        return `"${super.toHTML()}"<center>${this.#credit.toHTML()}</center>`;
+    }
+
+    getChildren(): Node[] {
+        return [...this.getBlocks(), this.#credit];
+    }
+
+    getParentOf(node: Node): Node | undefined {
+        if (node === this.#credit) return this;
+        const creditParent = this.#credit.getParentOf(node);
+        if (creditParent !== undefined) return creditParent;
+        return super.getParentOf(node);
+    }
+
+    copy() {
+        return new QuoteNode(this.getBlocks().map((b) => b.copy())) as this;
+    }
+    create(blocks: BlockNode[]): BlocksNode {
+        return new QuoteNode(blocks, this.#credit, this.#position);
+    }
+
+    withChildReplaced(
+        node: BlockNode | FormatNode,
+        replacement: BlockNode | FormatNode | undefined
+    ) {
+        // Replace the credit.
+        if (
+            this.#credit === node &&
+            (replacement instanceof FormatNode || replacement === undefined)
+        )
+            return new QuoteNode(
+                this.getBlocks(),
+                replacement,
+                this.#position
+            ) as this;
+
+        // Replace a block.
+        if (replacement !== undefined && !(replacement instanceof BlockNode))
+            return;
+        const index = this.getBlocks().indexOf(node as BlockNode);
+        if (index < 0) return;
+
+        // Make a new blocks node, assigning and re-parenting the replacement.
+        const blocks =
+            replacement === undefined
+                ? [
+                      ...this.getBlocks().slice(0, index),
+                      ...this.getBlocks().slice(index + 1),
+                  ]
+                : [
+                      ...this.getBlocks().slice(0, index),
+                      replacement,
+                      ...this.getBlocks().slice(index + 1),
+                  ];
+
+        return new QuoteNode(blocks, this.#credit, this.#position) as this;
+    }
+
+    withCredit(credit: FormatNode | undefined): QuoteNode {
+        return new QuoteNode(this.getBlocks(), credit, this.#position);
+    }
+    withPosition(position: Position): QuoteNode {
+        return new QuoteNode(this.getBlocks(), this.#credit, position);
+    }
+
+    withContentInRange(range: CaretRange): this | undefined {
+        // First get the blocks in range.
+        const newQuote = super.withContentInRange(range);
+        if (newQuote === undefined) return;
+
+        const newCredit =
+            this.getBlocks().find((b) => b.contains(range.end.node)) !==
+            undefined
+                ? new FormatNode('', [new TextNode()])
+                : this.#credit.withContentInRange(range);
+        return newQuote.withNodeReplaced(this.#credit, newCredit) as this;
+    }
+}

package/{models/chapter/RootNode.d.ts → src/lib/models/chapter/RootNode.ts}

@@ -1,5 +1,7 @@
 import type ChapterNode from './ChapterNode';
 import type EmbedNode from './EmbedNode';
 import type FormatNode from './FormatNode';
+
+// Beware: BookishEditor checks for each of these in order to undo/redo. If you change this, check it's undo/redo logic too.
 type RootNode = ChapterNode | FormatNode | EmbedNode;
 export default RootNode;

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

@@ -1,36 +1,39 @@
+import type Node from './Node';
 import BlockNode from './BlockNode';
+
 export default class RuleNode extends BlockNode {
     constructor() {
         super();
     }
+
     getType() {
         return 'rule';
     }
-    toText() {
+    toText(): string {
         return '';
     }
-    toBookdown() {
+    toBookdown(): string {
         return '-';
     }
     toHTML() {
         return `<hr/>`;
     }
-    getParentOf() {
+    getParentOf(): Node | undefined {
         return undefined;
     }
     getFormats() {
         return [];
     }
-    getChildren() {
+    getChildren(): Node[] {
         return [];
     }
     copy() {
-        return new RuleNode();
+        return new RuleNode() as this;
     }
     withChildReplaced() {
         return undefined;
     }
-    withContentInRange() {
+    withContentInRange(): this | undefined {
         return this.copy();
     }
 }

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

@@ -1,28 +1,45 @@
 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/TableNode.js → src/lib/models/chapter/TableNode.ts}

@@ -1,11 +1,22 @@
+import type Node from './Node';
+import type Position from './Position';
 import FormatNode from './FormatNode';
 import TextNode from './TextNode';
 import BlockNode from './BlockNode';
+import type { CaretRange } from './Caret';
+
+type Location = { row: number; column: number };
+
 export default class TableNode extends BlockNode {
-    #rows;
-    #caption;
-    #position;
-    constructor(rows, position, caption) {
+    readonly #rows: FormatNode[][];
+    readonly #caption: FormatNode;
+    readonly #position: Position;
+
+    constructor(
+        rows: FormatNode[][],
+        position?: Position,
+        caption?: FormatNode
+    ) {
         super();
         this.#rows = rows.map((r) => r.map((c) => c.withTextIfEmpty()));
         this.#position = position ? position : '|';
@@ -14,9 +25,11 @@ export default class TableNode extends BlockNode {
                 ? new FormatNode('', [new TextNode()])
                 : caption.withTextIfEmpty();
     }
+
     getType() {
         return 'table';
     }
+
     getRows() {
         return this.#rows;
     }
@@ -33,64 +46,81 @@ export default class TableNode extends BlockNode {
         return this.#caption;
     }
     getFormats() {
-        const formats = [];
-        this.#rows.forEach((row) => row.forEach((cell) => {
-            formats.push(cell);
-        }));
+        const formats: FormatNode[] = [];
+        this.#rows.forEach((row) =>
+            row.forEach((cell) => {
+                formats.push(cell);
+            })
+        );
         return [...formats, this.#caption];
     }
-    getNextCell(format, direction = 1) {
-        let previous = undefined;
-        let found = false;
+
+    getNextCell(format: FormatNode, direction: -1 | 1 = 1) {
+        let previous: FormatNode | undefined = undefined;
+        let found: boolean = false;
         for (const row of this.#rows) {
             for (const cell of row) {
-                if (found)
-                    return cell;
+                if (found) return cell;
                 if (cell === format) {
-                    if (direction > 0)
-                        found = true;
-                    else
-                        return previous;
+                    if (direction > 0) found = true;
+                    else return previous;
                 }
                 previous = cell;
             }
         }
         return undefined;
     }
+
     toText() {
         return this.#rows
             .map((row) => row.map((cell) => cell.toText()).join(', '))
             .join(', ');
     }
-    toBookdown() {
-        return (this.#rows
-            .map((row) => `,${row.map((cell) => cell.toBookdown()).join('|')}`)
-            .join('\n') +
-            `\n${this.#position === '|' ? '' : this.#position}${this.#caption ? '' + this.#caption.toBookdown() : ''}`);
+
+    toBookdown(): string {
+        return (
+            this.#rows
+                .map(
+                    (row) =>
+                        `,${row.map((cell) => cell.toBookdown()).join('|')}`
+                )
+                .join('\n') +
+            `\n${this.#position === '|' ? '' : this.#position}${
+                this.#caption ? '' + this.#caption.toBookdown() : ''
+            }`
+        );
     }
+
     toHTML() {
         return `<table><tbody>${this.#rows
-            .map((row) => `<tr>${row
-            .map((cell) => `<td>${cell.toHTML()}</td>`)
-            .join('')}`)
-            .join('')}</tbody></table><center>${this.#caption.toHTML()}</center>`;
+            .map(
+                (row) =>
+                    `<tr>${row
+                        .map((cell) => `<td>${cell.toHTML()}</td>`)
+                        .join('')}`
+            )
+            .join(
+                ''
+            )}</tbody></table><center>${this.#caption.toHTML()}</center>`;
     }
+
     getChildren() {
         const children = [];
         this.#rows.forEach((row) => row.forEach((cell) => children.push(cell)));
         children.push(this.#caption);
         return children;
     }
-    locate(format) {
+
+    locate(format: FormatNode): Location | undefined {
         for (let r = 0; r < this.#rows.length; r++) {
             const row = this.#rows[r];
             for (let c = 0; c < row.length; c++) {
-                if (row[c] === format)
-                    return { row: r, column: c };
+                if (row[c] === format) return { row: r, column: c };
             }
         }
     }
-    getCell(row, col) {
+
+    getCell(row: number, col: number): FormatNode | undefined {
         return row >= 0 &&
             row < this.#rows.length &&
             this.#rows.length > 0 &&
@@ -99,33 +129,45 @@ export default class TableNode extends BlockNode {
             ? this.#rows[row][col]
             : undefined;
     }
-    getParentOf(node) {
+
+    getParentOf(node: Node): Node | undefined {
         for (let r = 0; r < this.#rows.length; r++) {
             const row = this.#rows[r];
             for (let c = 0; c < row.length; c++) {
-                if (row[c] === node)
-                    return this;
+                if (row[c] === node) return this;
                 const parent = row[c].getParentOf(node);
-                if (parent !== undefined)
-                    return parent;
+                if (parent !== undefined) return parent;
             }
         }
         return node === this.#caption ? this : this.#caption.getParentOf(node);
     }
+
     copy() {
-        const rows = [];
+        const rows: FormatNode[][] = [];
         this.#rows.forEach((row) => {
-            const cells = [];
+            const cells: FormatNode[] = [];
             row.forEach((cell) => cells.push(cell.copy()));
             rows.push(cells);
         });
-        return new TableNode(rows, this.#position, this.#caption ? this.#caption.copy() : undefined);
+        return new TableNode(
+            rows,
+            this.#position,
+            this.#caption ? this.#caption.copy() : undefined
+        ) as this;
     }
-    withChildReplaced(node, replacement) {
+
+    withChildReplaced(node: FormatNode, replacement: FormatNode | undefined) {
         // If it's just the caption, make a new node with the new credit.
-        if (node === this.#caption &&
-            (replacement instanceof FormatNode || replacement === undefined))
-            return new TableNode(this.#rows, this.#position, replacement);
+        if (
+            node === this.#caption &&
+            (replacement instanceof FormatNode || replacement === undefined)
+        )
+            return new TableNode(
+                this.#rows,
+                this.#position,
+                replacement
+            ) as this;
+
         // If it's a cell, update the cell.
         if (node instanceof FormatNode && replacement instanceof FormatNode) {
             // Does this table contain node we're replacing?
@@ -133,49 +175,59 @@ export default class TableNode extends BlockNode {
             let updateColumn = -1;
             for (; updateRow < this.#rows.length; updateRow++) {
                 updateColumn = this.#rows[updateRow].indexOf(node);
-                if (updateColumn >= 0)
-                    break;
+                if (updateColumn >= 0) break;
             }
+
             // Make new rows with the updated cell.
             if (updateRow < this.#rows.length && updateColumn >= 0) {
                 const newRows = this.#rows.map((row) => [...row]);
                 newRows[updateRow][updateColumn] = replacement;
-                return new TableNode(newRows, this.#position, this.#caption);
+                return new TableNode(
+                    newRows,
+                    this.#position,
+                    this.#caption
+                ) as this;
             }
         }
     }
-    withNewRow(index) {
-        if (index < 0 || index > this.#rows.length)
-            return;
+
+    withNewRow(index: number): TableNode | undefined {
+        if (index < 0 || index > this.#rows.length) return;
+
         // Figure out how many columns the first row has, then create a row with that many columns
         // and an empty FormatNode.
         const columnCount = this.#rows.length === 0 ? 0 : this.#rows[0].length;
-        const column = [];
+        const column: FormatNode[] = [];
+
         for (let c = 0; c < columnCount; c++)
             column.push(new FormatNode('', [new TextNode()]));
+
         const newRows = this.#rows.slice();
         newRows.splice(index, 0, column);
         return new TableNode(newRows, this.#position, this.#caption);
     }
-    withoutRow(index) {
-        if (index < 0 || index >= this.#rows.length)
-            return;
+
+    withoutRow(index: number): TableNode | undefined {
+        if (index < 0 || index >= this.#rows.length) return;
         const newRows = this.#rows.slice();
         newRows.splice(index, 1);
         return new TableNode(newRows, this.#position, this.#caption);
     }
-    withoutColumn(index) {
-        if (index < 0 || index >= this.getColumnCount())
-            return;
+
+    withoutColumn(index: number): TableNode | undefined {
+        if (index < 0 || index >= this.getColumnCount()) return;
         const newRows = this.#rows.slice();
-        for (let r = 0; r < this.#rows.length; r++)
-            newRows[r].splice(index, 1);
+        for (let r = 0; r < this.#rows.length; r++) newRows[r].splice(index, 1);
         return new TableNode(newRows, this.#position, this.#caption);
     }
-    withNewColumn(index) {
-        if (this.#rows.length > 0 &&
-            (index < 0 || index > this.#rows[0].length))
+
+    withNewColumn(index: number): TableNode | undefined {
+        if (
+            this.#rows.length > 0 &&
+            (index < 0 || index > this.#rows[0].length)
+        )
             return;
+
         // Figure out how many rows the table has and add a column
         const newRows = this.#rows.slice();
         for (let r = 0; r < this.#rows.length; r++) {
@@ -184,48 +236,55 @@ export default class TableNode extends BlockNode {
         }
         return new TableNode(newRows, this.#position, this.#caption);
     }
-    withContentInRange(range) {
+
+    withContentInRange(range: CaretRange): this | undefined {
         const containsStart = this.contains(range.start.node);
         const containsEnd = this.contains(range.end.node);
-        if (!containsStart && !containsEnd)
-            return this.copy();
+        if (!containsStart && !containsEnd) return this.copy();
+
         // If it contains the start, skip rows until we find the cell with the start node.
         // If it contains the end, skip rows after we find the cell with the end node.
-        let r = 0, c = 0;
+        let r = 0,
+            c = 0;
         let foundStart = false;
         let foundEnd = false;
-        let newRows = [];
+        let newRows: FormatNode[][] = [];
         for (; r < this.#rows.length; r++, c = 0) {
             const row = this.#rows[r];
+
             // Skip this row if this table contains the start node and we haven't found it and the row doesn't contain it
-            if (containsStart &&
+            if (
+                containsStart &&
                 !foundStart &&
-                row.find((r) => r.contains(range.start.node)) === undefined)
+                row.find((r) => r.contains(range.start.node)) === undefined
+            )
                 continue;
             // Stop if we found the end row.
-            if (containsEnd && foundEnd)
-                break;
-            newRows.push([]);
+            if (containsEnd && foundEnd) break;
+
+            newRows.push([] as FormatNode[]);
             for (; c < row.length; c++) {
                 if (!foundStart && row[c].contains(range.start.node))
                     foundStart = true;
                 const newCell = row[c].withContentInRange(range);
-                if (newCell === undefined)
-                    return;
-                newRows[newRows.length - 1].push(((containsStart && foundStart) || !containsStart) &&
-                    ((containsEnd && !foundEnd) || !containsEnd)
-                    ? newCell
-                    : new FormatNode('', [new TextNode()]));
-                if (row[c].contains(range.end.node))
-                    foundEnd = true;
+                if (newCell === undefined) return;
+                newRows[newRows.length - 1].push(
+                    ((containsStart && foundStart) || !containsStart) &&
+                        ((containsEnd && !foundEnd) || !containsEnd)
+                        ? newCell
+                        : new FormatNode('', [new TextNode()])
+                );
+                if (row[c].contains(range.end.node)) foundEnd = true;
             }
         }
+
         const newCaption = this.#caption.withContentInRange(range);
-        if (newCaption === undefined)
-            return;
-        return new TableNode(newRows, this.#position, newCaption);
+        if (newCaption === undefined) return;
+
+        return new TableNode(newRows, this.#position, newCaption) as this;
     }
-    withPosition(position) {
+
+    withPosition(position: Position) {
         return new TableNode(this.#rows, position, this.#caption);
     }
 }

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

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