bookish-press 0.4.47 → 0.4.49

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

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

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

@@ -1,30 +1,23 @@
 import { test, expect } from 'vitest';
-
 import Parser from './Parser';
-
 test('Empty chapter', () => {
     expect(Parser.parseChapter(undefined, '').toBookdown()).toBe('');
 });
-
 test('Single paragraph', () => {
     expect(Parser.parseChapter(undefined, 'hello').toBookdown()).toBe('hello');
 });
-
 test('Peek', () => {
     const p = new Parser(undefined, '# hello');
     expect(p.peek()).toBe('#');
     expect(p.read()).toBe('#');
     expect(p.peek()).toBe(' ');
 });
-
 test('More', () => {
     const p = new Parser(undefined, '#');
     expect(p.more()).toBe(true);
-
     const p2 = new Parser(undefined, '');
     expect(p2.more()).toBe(false);
 });
-
 test('Whitespace', () => {
     const p = new Parser(undefined, '    Hi');
     p.readWhitespace();

package/models/chapter/Position.js

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

package/models/chapter/QuoteNode.d.ts

@@ -0,0 +1,25 @@
+import type Node from './Node';
+import BlockNode from './BlockNode';
+import type Position from './Position';
+import FormatNode from './FormatNode';
+import BlocksNode from './BlocksNode';
+import type { CaretRange } from './Caret';
+export default class QuoteNode extends BlocksNode {
+    #private;
+    constructor(elements: BlockNode[], credit?: FormatNode, position?: Position);
+    getType(): string;
+    getCredit(): FormatNode;
+    getPosition(): Position;
+    getFormats(): FormatNode[];
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): Node[];
+    getParentOf(node: Node): Node | undefined;
+    copy(): this;
+    create(blocks: BlockNode[]): BlocksNode;
+    withChildReplaced(node: BlockNode | FormatNode, replacement: BlockNode | FormatNode | undefined): this | undefined;
+    withCredit(credit: FormatNode | undefined): QuoteNode;
+    withPosition(position: Position): QuoteNode;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/QuoteNode.js

@@ -0,0 +1,99 @@
+import BlockNode from './BlockNode';
+import FormatNode from './FormatNode';
+import BlocksNode from './BlocksNode';
+import TextNode from './TextNode';
+export default class QuoteNode extends BlocksNode {
+    #credit;
+    #position;
+    constructor(elements, credit, 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() {
+        return (this.getBlocks()
+            .map((element) => element.toText())
+            .join(' ') + (this.#credit ? ' ' + this.#credit.toText() : ''));
+    }
+    toBookdown() {
+        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() {
+        return [...this.getBlocks(), this.#credit];
+    }
+    getParentOf(node) {
+        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()));
+    }
+    create(blocks) {
+        return new QuoteNode(blocks, this.#credit, this.#position);
+    }
+    withChildReplaced(node, replacement) {
+        // Replace the credit.
+        if (this.#credit === node &&
+            (replacement instanceof FormatNode || replacement === undefined))
+            return new QuoteNode(this.getBlocks(), replacement, this.#position);
+        // Replace a block.
+        if (replacement !== undefined && !(replacement instanceof BlockNode))
+            return;
+        const index = this.getBlocks().indexOf(node);
+        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);
+    }
+    withCredit(credit) {
+        return new QuoteNode(this.getBlocks(), credit, this.#position);
+    }
+    withPosition(position) {
+        return new QuoteNode(this.getBlocks(), this.#credit, position);
+    }
+    withContentInRange(range) {
+        // 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);
+    }
+}

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

@@ -1,7 +1,5 @@
 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/RootNode.js

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

package/models/chapter/RuleNode.d.ts

@@ -0,0 +1,15 @@
+import type Node from './Node';
+import BlockNode from './BlockNode';
+export default class RuleNode extends BlockNode {
+    constructor();
+    getType(): string;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getParentOf(): Node | undefined;
+    getFormats(): never[];
+    getChildren(): Node[];
+    copy(): this;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

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

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

package/models/chapter/TableNode.d.ts

@@ -0,0 +1,37 @@
+import type Node from './Node';
+import type Position from './Position';
+import FormatNode from './FormatNode';
+import BlockNode from './BlockNode';
+import type { CaretRange } from './Caret';
+type Location = {
+    row: number;
+    column: number;
+};
+export default class TableNode extends BlockNode {
+    #private;
+    constructor(rows: FormatNode[][], position?: Position, caption?: FormatNode);
+    getType(): string;
+    getRows(): FormatNode[][];
+    getRowCount(): number;
+    getColumnCount(): number;
+    getPosition(): Position;
+    getCaption(): FormatNode;
+    getFormats(): FormatNode[];
+    getNextCell(format: FormatNode, direction?: -1 | 1): FormatNode | undefined;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): FormatNode[];
+    locate(format: FormatNode): Location | undefined;
+    getCell(row: number, col: number): FormatNode | undefined;
+    getParentOf(node: Node): Node | undefined;
+    copy(): this;
+    withChildReplaced(node: FormatNode, replacement: FormatNode | undefined): this | undefined;
+    withNewRow(index: number): TableNode | undefined;
+    withoutRow(index: number): TableNode | undefined;
+    withoutColumn(index: number): TableNode | undefined;
+    withNewColumn(index: number): TableNode | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+    withPosition(position: Position): TableNode;
+}
+export {};

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

@@ -1,22 +1,11 @@
-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 {
-    readonly #rows: FormatNode[][];
-    readonly #caption: FormatNode;
-    readonly #position: Position;
-
-    constructor(
-        rows: FormatNode[][],
-        position?: Position,
-        caption?: FormatNode
-    ) {
+    #rows;
+    #caption;
+    #position;
+    constructor(rows, position, caption) {
         super();
         this.#rows = rows.map((r) => r.map((c) => c.withTextIfEmpty()));
         this.#position = position ? position : '|';
@@ -25,11 +14,9 @@ export default class TableNode extends BlockNode {
                 ? new FormatNode('', [new TextNode()])
                 : caption.withTextIfEmpty();
     }
-
     getType() {
         return 'table';
     }
-
     getRows() {
         return this.#rows;
     }
@@ -46,81 +33,64 @@ export default class TableNode extends BlockNode {
         return this.#caption;
     }
     getFormats() {
-        const formats: FormatNode[] = [];
-        this.#rows.forEach((row) =>
-            row.forEach((cell) => {
-                formats.push(cell);
-            })
-        );
+        const formats = [];
+        this.#rows.forEach((row) => row.forEach((cell) => {
+            formats.push(cell);
+        }));
         return [...formats, this.#caption];
     }
-
-    getNextCell(format: FormatNode, direction: -1 | 1 = 1) {
-        let previous: FormatNode | undefined = undefined;
-        let found: boolean = false;
+    getNextCell(format, direction = 1) {
+        let previous = undefined;
+        let found = 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(): string {
-        return (
-            this.#rows
-                .map(
-                    (row) =>
-                        `,${row.map((cell) => cell.toBookdown()).join('|')}`
-                )
-                .join('\n') +
-            `\n${this.#position === '|' ? '' : this.#position}${
-                this.#caption ? '' + this.#caption.toBookdown() : ''
-            }`
-        );
+    toBookdown() {
+        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: FormatNode): Location | undefined {
+    locate(format) {
         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: number, col: number): FormatNode | undefined {
+    getCell(row, col) {
         return row >= 0 &&
             row < this.#rows.length &&
             this.#rows.length > 0 &&
@@ -129,45 +99,33 @@ export default class TableNode extends BlockNode {
             ? this.#rows[row][col]
             : undefined;
     }
-
-    getParentOf(node: Node): Node | undefined {
+    getParentOf(node) {
         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: FormatNode[][] = [];
+        const rows = [];
         this.#rows.forEach((row) => {
-            const cells: FormatNode[] = [];
+            const cells = [];
             row.forEach((cell) => cells.push(cell.copy()));
             rows.push(cells);
         });
-        return new TableNode(
-            rows,
-            this.#position,
-            this.#caption ? this.#caption.copy() : undefined
-        ) as this;
+        return new TableNode(rows, this.#position, this.#caption ? this.#caption.copy() : undefined);
     }
-
-    withChildReplaced(node: FormatNode, replacement: FormatNode | undefined) {
+    withChildReplaced(node, replacement) {
         // 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
-            ) as this;
-
+        if (node === this.#caption &&
+            (replacement instanceof FormatNode || replacement === undefined))
+            return new TableNode(this.#rows, this.#position, replacement);
         // If it's a cell, update the cell.
         if (node instanceof FormatNode && replacement instanceof FormatNode) {
             // Does this table contain node we're replacing?
@@ -175,59 +133,49 @@ 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
-                ) as this;
+                return new TableNode(newRows, this.#position, this.#caption);
             }
         }
     }
-
-    withNewRow(index: number): TableNode | undefined {
-        if (index < 0 || index > this.#rows.length) return;
-
+    withNewRow(index) {
+        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: FormatNode[] = [];
-
+        const column = [];
         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: number): TableNode | undefined {
-        if (index < 0 || index >= this.#rows.length) return;
+    withoutRow(index) {
+        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: number): TableNode | undefined {
-        if (index < 0 || index >= this.getColumnCount()) return;
+    withoutColumn(index) {
+        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: number): TableNode | undefined {
-        if (
-            this.#rows.length > 0 &&
-            (index < 0 || index > this.#rows[0].length)
-        )
+    withNewColumn(index) {
+        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++) {
@@ -236,55 +184,48 @@ export default class TableNode extends BlockNode {
         }
         return new TableNode(newRows, this.#position, this.#caption);
     }
-
-    withContentInRange(range: CaretRange): this | undefined {
+    withContentInRange(range) {
         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: FormatNode[][] = [];
+        let newRows = [];
         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([] as FormatNode[]);
+            if (containsEnd && foundEnd)
+                break;
+            newRows.push([]);
             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) as this;
+        if (newCaption === undefined)
+            return;
+        return new TableNode(newRows, this.#position, newCaption);
     }
-
-    withPosition(position: Position) {
+    withPosition(position) {
         return new TableNode(this.#rows, position, this.#caption);
     }
 }

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

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