bookish-press 0.4.1 → 0.4.16

package/models/chapter/Bookkeeping.d.ts

@@ -1,4 +1,4 @@
-declare type Bookkeeping = {
+type Bookkeeping = {
     symbols: Record<string, string>;
 };
 export default Bookkeeping;

package/models/chapter/CalloutNode.d.ts

@@ -1,6 +1,6 @@
-import BlocksNode from "./BlocksNode";
-import type BlockNode from "./BlockNode";
-import type Position from "./Position";
+import BlocksNode from './BlocksNode';
+import type BlockNode from './BlockNode';
+import type Position from './Position';
 export default class CalloutNode extends BlocksNode {
     #private;
     constructor(elements: BlockNode[], position?: Position);

package/models/chapter/CalloutNode.js

@@ -1,33 +1,55 @@
-import BlocksNode from "./BlocksNode";
+import BlocksNode from './BlocksNode';
 export default class CalloutNode extends BlocksNode {
     #position;
-    constructor(elements, position = "|") {
+    constructor(elements, position = '|') {
         super(elements);
         this.#position = position;
     }
-    getType() { return "callout"; }
-    getPosition() { return this.#position; }
+    getType() {
+        return 'callout';
+    }
+    getPosition() {
+        return this.#position;
+    }
     toText() {
-        return this.getBlocks().map(element => element.toText()).join(" ");
+        return this.getBlocks()
+            .map((element) => element.toText())
+            .join(' ');
     }
     toHTML() {
         return `<hr/>${super.toHTML()}<hr/>`;
     }
     toBookdown() {
-        return "=\n" + this.getBlocks().map(element => element.toBookdown()).join("\n\n") + "\n=" + (this.#position !== "|" ? this.#position : "");
+        return ('=\n' +
+            this.getBlocks()
+                .map((element) => element.toBookdown())
+                .join('\n\n') +
+            '\n=' +
+            (this.#position !== '|' ? this.#position : ''));
+    }
+    getChildren() {
+        return this.getBlocks();
     }
-    getChildren() { return this.getBlocks(); }
     copy() {
-        return new CalloutNode(this.getBlocks().map(e => e.copy()), this.#position);
+        return new CalloutNode(this.getBlocks().map((e) => e.copy()), this.#position);
+    }
+    withPosition(position) {
+        return new CalloutNode(this.getBlocks(), position);
     }
-    withPosition(position) { return new CalloutNode(this.getBlocks(), position); }
     withChildReplaced(node, replacement) {
         const index = this.getBlocks().indexOf(node);
         if (index < 0)
             return;
-        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)];
+        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 CalloutNode(blocks, this.#position);
     }
     create(blocks) {

package/models/chapter/Caret.d.ts

@@ -1,16 +1,18 @@
-import type Node from "./Node";
-import AtomNode from "./AtomNode";
-import TextNode from "./TextNode";
-declare type Caret = {
-    node: TextNode | AtomNode<any>;
+import type Node from './Node';
+import AtomNode from './AtomNode';
+import TextNode from './TextNode';
+import type EmbedNode from './EmbedNode';
+export type SelectableNode = TextNode | AtomNode<any> | EmbedNode;
+type Caret = {
+    node: SelectableNode;
     index: number;
 };
 export default Caret;
-export declare type CaretRange = {
+export type CaretRange = {
     start: Caret;
     end: Caret;
 };
-export declare type IndexRange = {
+export type IndexRange = {
     start: number;
     end: number;
 };

package/models/chapter/Caret.js

@@ -1,13 +1,17 @@
-import AtomNode from "./AtomNode";
-import TextNode from "./TextNode";
-import FormatNode from "./FormatNode";
+import AtomNode from './AtomNode';
+import TextNode from './TextNode';
+import FormatNode from './FormatNode';
 export function getTextAndAtomNodes(node) {
-    return node.getNodes().filter(n => n instanceof TextNode || n instanceof AtomNode);
+    return node
+        .getNodes()
+        .filter((n) => n instanceof TextNode || n instanceof AtomNode);
 }
 function getFormatRoots(node) {
     const roots = [];
     node.traverse((node, parents) => {
-        if (node instanceof FormatNode && parents.length > 0 && !(parents[parents.length - 1] instanceof FormatNode))
+        if (node instanceof FormatNode &&
+            parents.length > 0 &&
+            !(parents[parents.length - 1] instanceof FormatNode))
             roots.push(node);
     });
     return roots;
@@ -39,7 +43,8 @@ export function indexToCaret(node, index) {
         const nodes = getTextAndAtomNodes(roots[n]);
         for (let i = 0; i < nodes.length; i++) {
             const t = nodes[i];
-            if (index >= currentIndex && index <= currentIndex + t.getCaretPositionCount()) {
+            if (index >= currentIndex &&
+                index <= currentIndex + t.getCaretPositionCount()) {
                 // Prefer empty nodes to enable zero width formats.
                 if (i < nodes.length - 1) {
                     const next = nodes[i + 1];

package/models/chapter/ChapterNode.d.ts

@@ -1,14 +1,14 @@
-import type Bookkeeping from "./Bookkeeping";
-import type BlockNode from "./BlockNode";
-import ErrorNode from "./ErrorNode";
-import type TextNode from "./TextNode";
-import FootnoteNode from "./FootnoteNode";
-import EmbedNode from "./EmbedNode";
-import ParagraphNode from "./ParagraphNode";
-import type AtomNode from "./AtomNode";
-import LabelNode from "./LabelNode";
-import CommentNode from "./CommentNode";
-import BlocksNode from "./BlocksNode";
+import type Bookkeeping from './Bookkeeping';
+import type BlockNode from './BlockNode';
+import ErrorNode from './ErrorNode';
+import type TextNode from './TextNode';
+import FootnoteNode from './FootnoteNode';
+import EmbedNode from './EmbedNode';
+import ParagraphNode from './ParagraphNode';
+import type AtomNode from './AtomNode';
+import LabelNode from './LabelNode';
+import CommentNode from './CommentNode';
+import BlocksNode from './BlocksNode';
 export default class ChapterNode extends BlocksNode {
     #private;
     constructor(blocks: BlockNode[], metadata?: Bookkeeping);

package/models/chapter/ChapterNode.js

@@ -1,11 +1,11 @@
-import ErrorNode from "./ErrorNode";
-import FootnoteNode from "./FootnoteNode";
-import EmbedNode from "./EmbedNode";
-import ParagraphNode from "./ParagraphNode";
-import CitationsNode from "./CitationsNode";
-import LabelNode from "./LabelNode";
-import CommentNode from "./CommentNode";
-import BlocksNode from "./BlocksNode";
+import ErrorNode from './ErrorNode';
+import FootnoteNode from './FootnoteNode';
+import EmbedNode from './EmbedNode';
+import ParagraphNode from './ParagraphNode';
+import CitationsNode from './CitationsNode';
+import LabelNode from './LabelNode';
+import CommentNode from './CommentNode';
+import BlocksNode from './BlocksNode';
 export default class ChapterNode extends BlocksNode {
     #metadata;
     constructor(blocks, metadata) {
@@ -13,68 +13,105 @@ export default class ChapterNode extends BlocksNode {
         // Content extracted during parsing.
         this.#metadata = metadata === undefined ? { symbols: {} } : metadata;
     }
-    getType() { return "chapter"; }
-    getChapter() { return this; }
+    getType() {
+        return 'chapter';
+    }
+    getChapter() {
+        return this;
+    }
     create(blocks) {
         return new ChapterNode(blocks, this.#metadata);
     }
-    getErrors() { return this.getNodes().filter(n => n instanceof ErrorNode); }
+    getErrors() {
+        return this.getNodes().filter((n) => n instanceof ErrorNode);
+    }
     getCitations() {
         const citations = new Set();
-        this.getNodes().filter(n => n instanceof CitationsNode).forEach(cites => cites.getMeta().forEach(citationID => citations.add(citationID)));
+        this.getNodes().filter((n) => n instanceof CitationsNode).forEach((cites) => cites.getMeta().forEach((citationID) => citations.add(citationID)));
         return citations;
     }
-    getFootnotes() { return this.getNodes().filter(n => n instanceof FootnoteNode); }
-    getHeaders() { return this.getNodes().filter(n => n instanceof ParagraphNode && n.getLevel() > 0); }
-    getEmbeds() { return this.getNodes().filter(n => n instanceof EmbedNode); }
-    getComments() { return this.getNodes().filter(n => n instanceof CommentNode); }
+    getFootnotes() {
+        return this.getNodes().filter((n) => n instanceof FootnoteNode);
+    }
+    getHeaders() {
+        return this.getNodes().filter((n) => n instanceof ParagraphNode && n.getLevel() > 0);
+    }
+    getEmbeds() {
+        return this.getNodes().filter((n) => n instanceof EmbedNode);
+    }
+    getComments() {
+        return this.getNodes().filter((n) => n instanceof CommentNode);
+    }
     getLabels() {
-        return this.getNodes().filter(n => n instanceof LabelNode);
+        return this.getNodes().filter((n) => n instanceof LabelNode);
     }
     hasLabel(labelID) {
-        return this.getLabels().find(label => label.getMeta() === labelID) !== undefined;
+        return (this.getLabels().find((label) => label.getMeta() === labelID) !==
+            undefined);
     }
     getCitationNumber(citationID) {
-        const index = Array.from(this.getCitations()).sort().indexOf(citationID);
+        const index = Array.from(this.getCitations())
+            .sort()
+            .indexOf(citationID);
         return index < 0 ? null : index + 1;
     }
     toText() {
-        return this.getBlocks().map(block => block.toText()).join(" ");
+        return this.getBlocks()
+            .map((block) => block.toText())
+            .join(' ');
     }
     toBookdown() {
         // Render the symbols then all the blocks
-        return Object.keys(this.#metadata.symbols).sort().map(name => `@${name}: ${this.#metadata.symbols[name]}\n\n`).join("") +
-            this.getBlocks().map(b => b.toBookdown()).join("\n\n");
+        return (Object.keys(this.#metadata.symbols)
+            .sort()
+            .map((name) => `@${name}: ${this.#metadata.symbols[name]}\n\n`)
+            .join('') +
+            this.getBlocks()
+                .map((b) => b.toBookdown())
+                .join('\n\n'));
     }
     getNextTextOrAtom(node) {
         // Otherwise, find the next text node after this one.
         const nodes = this.getTextAndAtomNodes();
         const index = nodes.indexOf(node);
-        return index === undefined ? undefined :
-            index < nodes.length - 1 ? nodes[index + 1] :
-                undefined;
+        return index === undefined
+            ? undefined
+            : index < nodes.length - 1
+                ? nodes[index + 1]
+                : undefined;
     }
     getPreviousTextOrAtom(node) {
         // Otherwise, find the next text node after this one.
         const nodes = this.getTextAndAtomNodes();
         const index = nodes.indexOf(node);
-        return index === undefined ? undefined :
-            index > 0 ? nodes[index - 1] :
-                undefined;
+        return index === undefined
+            ? undefined
+            : index > 0
+                ? nodes[index - 1]
+                : undefined;
+    }
+    getChildren() {
+        return this.getBlocks();
     }
-    getChildren() { return this.getBlocks(); }
     withChildReplaced(node, replacement) {
         const index = this.getBlocks().indexOf(node);
         /// If we couldn't find the requested node, don't change anything.
         if (index < 0)
             return undefined;
         // 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)];
+        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 ChapterNode(blocks, this.#metadata);
     }
     copy() {
-        return new ChapterNode(this.getBlocks().map(b => b.copy()), this.#metadata);
+        return new ChapterNode(this.getBlocks().map((b) => b.copy()), this.#metadata);
     }
 }

package/models/chapter/CitationsNode.d.ts

@@ -1,6 +1,6 @@
-import AtomNode from "./AtomNode";
-import type Caret from "./Caret";
-import type Node from "./Node";
+import AtomNode from './AtomNode';
+import type Caret from './Caret';
+import type Node from './Node';
 export default class CitationsNode extends AtomNode<string[]> {
     constructor(citations: string[]);
     getType(): string;

package/models/chapter/CitationsNode.js

@@ -1,17 +1,36 @@
-import AtomNode from "./AtomNode";
+import AtomNode from './AtomNode';
 export default class CitationsNode extends AtomNode {
     constructor(citations) {
         super(citations);
     }
-    getType() { return "citations"; }
-    getDefaultCaret() { return { node: this, index: 0 }; }
-    ;
-    toText() { return ""; }
-    toBookdown() { return `<${this.getMeta().join(",")}>`; }
-    toHTML() { return `(${this.getMeta().join(",")})`; }
-    getParentOf() { return undefined; }
-    copy() { return new CitationsNode([...this.getMeta()]); }
-    withMeta(citations) { return new CitationsNode(citations); }
-    withChildReplaced() { return undefined; }
-    withContentInRange() { return this.copy(); }
+    getType() {
+        return 'citations';
+    }
+    getDefaultCaret() {
+        return { node: this, index: 0 };
+    }
+    toText() {
+        return '';
+    }
+    toBookdown() {
+        return `<${this.getMeta().join(',')}>`;
+    }
+    toHTML() {
+        return `(${this.getMeta().join(',')})`;
+    }
+    getParentOf() {
+        return undefined;
+    }
+    copy() {
+        return new CitationsNode([...this.getMeta()]);
+    }
+    withMeta(citations) {
+        return new CitationsNode(citations);
+    }
+    withChildReplaced() {
+        return undefined;
+    }
+    withContentInRange() {
+        return this.copy();
+    }
 }

package/models/chapter/CodeNode.d.ts

@@ -1,9 +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";
+import type Node from './Node';
+import type Position from './Position';
+import FormatNode, { type Format } from './FormatNode';
+import TextNode from './TextNode';
+import BlockNode from './BlockNode';
+import type { CaretRange } from './Caret';
+import type Edit from './Edit';
+import type Caret from './Caret';
 export default class CodeNode extends BlockNode {
     #private;
     constructor(code: TextNode, language: string, position: Position, caption?: FormatNode);
@@ -27,4 +29,7 @@ export default class CodeNode extends BlockNode {
     withExecutable(executable: boolean): CodeNode;
     withCaption(caption: FormatNode): CodeNode;
     withContentInRange(range: CaretRange): this | undefined;
+    /** Overrides super, special casing TextNode, since super only handles formats. */
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit;
+    withNodeInserted(caret: Caret, node: Node): Edit;
 }

package/models/chapter/CodeNode.js

@@ -1,6 +1,6 @@
-import FormatNode from "./FormatNode";
-import TextNode from "./TextNode";
-import BlockNode from "./BlockNode";
+import FormatNode, {} from './FormatNode';
+import TextNode from './TextNode';
+import BlockNode from './BlockNode';
 export default class CodeNode extends BlockNode {
     #code;
     #caption;
@@ -9,56 +9,165 @@ export default class CodeNode extends BlockNode {
     #executable;
     constructor(code, language, position, caption) {
         super();
-        const executable = language.charAt(language.length - 1) === "!";
+        const executable = language.charAt(language.length - 1) === '!';
         this.#code = code;
         this.#position = position;
         this.#language = executable ? language.slice(0, -1) : language;
         this.#executable = executable;
-        this.#caption = caption === undefined ? new FormatNode("", [new TextNode()]) : caption.withTextIfEmpty();
-    }
-    getType() { return "code"; }
-    getCodeNode() { return this.#code; }
-    getCode() { return this.#code.getText(); }
-    getCaption() { return this.#caption; }
-    getPosition() { return this.#position; }
-    getLanguage() { return this.#language; }
-    isExecutable() { return this.#executable; }
-    getFormats() { return [this.#caption]; }
-    toText() { return ""; }
-    toHTML() { return `<pre><code>${this.#code.toHTML()}</code><pre><center>${this.#caption.toHTML()}</center>`; }
+        this.#caption =
+            caption === undefined
+                ? new FormatNode('', [new TextNode()])
+                : caption.withTextIfEmpty();
+    }
+    getType() {
+        return 'code';
+    }
+    getCodeNode() {
+        return this.#code;
+    }
+    getCode() {
+        return this.#code.getText();
+    }
+    getCaption() {
+        return this.#caption;
+    }
+    getPosition() {
+        return this.#position;
+    }
+    getLanguage() {
+        return this.#language;
+    }
+    isExecutable() {
+        return this.#executable;
+    }
+    getFormats() {
+        return [this.#caption];
+    }
+    toText() {
+        return '';
+    }
+    toHTML() {
+        return `<pre><code>${this.#code.toHTML()}</code><pre><center>${this.#caption.toHTML()}</center>`;
+    }
     toBookdown() {
         // Remember to escape any back ticks.
-        return "`" +
-            (this.#language !== "plaintext" ? this.#language : "") +
-            "\n" +
+        return ('`' +
+            (this.#language !== 'plaintext' ? this.#language : '') +
+            (this.#executable ? '!' : '') +
+            '\n' +
             this.#code.getText().replace(/`/g, '\\`') +
-            "\n`" +
-            (this.#position !== "|" ? this.#position : "") +
-            this.#caption.toBookdown();
+            '\n`' +
+            (this.#position !== '|' ? this.#position : '') +
+            this.#caption.toBookdown());
+    }
+    getChildren() {
+        return [this.#code, this.#caption];
     }
-    getChildren() { return [this.#code, this.#caption]; }
     copy() {
         return new CodeNode(this.#code.copy(), this.#language, this.#position, this.#caption.copy());
     }
     getParentOf(node) {
-        return node == this.#code || node === this.#caption ? this : this.#caption.getParentOf(node);
+        return node == this.#code || node === this.#caption
+            ? this
+            : this.#caption.getParentOf(node);
     }
     withChildReplaced(node, replacement) {
-        const newCode = node === this.#code && replacement instanceof TextNode ? replacement : undefined;
-        const newCaption = node === this.#caption && (replacement instanceof FormatNode || replacement === undefined) ? replacement : undefined;
-        return newCode || newCaption ? new CodeNode(newCode ? newCode : this.#code, this.#language, this.#position, newCaption ? newCaption : this.#caption) : undefined;
-    }
-    withPosition(position) { return new CodeNode(this.#code, this.#language, position, this.#caption); }
-    withLanguage(language) { return new CodeNode(this.#code, language, this.#position, this.#caption); }
-    withExecutable(executable) { return new CodeNode(this.#code, executable ? this.#language + "!" : this.#language, this.#position, this.#caption); }
-    withCaption(caption) { return new CodeNode(this.#code, this.#language, this.#position, caption); }
+        const newCode = node === this.#code && replacement instanceof TextNode
+            ? replacement
+            : undefined;
+        const newCaption = node === this.#caption &&
+            (replacement instanceof FormatNode || replacement === undefined)
+            ? replacement
+            : undefined;
+        return newCode || newCaption
+            ? new CodeNode(newCode ? newCode : this.#code, this.#language, this.#position, newCaption ? newCaption : this.#caption)
+            : undefined;
+    }
+    withPosition(position) {
+        return new CodeNode(this.#code, this.#language, position, this.#caption);
+    }
+    withLanguage(language) {
+        return new CodeNode(this.#code, language, this.#position, this.#caption);
+    }
+    withExecutable(executable) {
+        return new CodeNode(this.#code, executable ? this.#language + '!' : this.#language, this.#position, this.#caption);
+    }
+    withCaption(caption) {
+        return new CodeNode(this.#code, this.#language, this.#position, caption);
+    }
     withContentInRange(range) {
         if (!this.contains(range.start.node) && !this.contains(range.end.node))
             return this.copy();
-        const newCode = this.#caption.contains(range.start.node) ? new TextNode() : this.#code.withContentInRange(range);
-        const newCaption = range.end.node === this.#code ? new FormatNode("", [new TextNode()]) : this.#caption.withContentInRange(range);
+        const newCode = this.#caption.contains(range.start.node)
+            ? new TextNode()
+            : this.#code.withContentInRange(range);
+        const newCaption = range.end.node === this.#code
+            ? new FormatNode('', [new TextNode()])
+            : this.#caption.withContentInRange(range);
         if (newCode === undefined || newCaption === undefined)
             return;
         return new CodeNode(newCode, this.#language, this.#position, newCaption);
     }
+    /** Overrides super, special casing TextNode, since super only handles formats. */
+    withRangeFormatted(range, format) {
+        let editedNode = this;
+        // First, handle the caption, if necessary.
+        let captionEdit = super.withRangeFormatted(range, format);
+        // If we're asking for format, skip it, code can't be formatted. Just return the caption edit.
+        if (format !== undefined)
+            return captionEdit;
+        // Grab the new CodeNode if the caption was edited.
+        if (captionEdit)
+            editedNode = captionEdit.root;
+        // Next, see if part of the range included this text node.
+        const sortedRange = this.sortRange(range);
+        const containsStart = sortedRange.start.node === this.#code;
+        const containsEnd = sortedRange.end.node === this.#code;
+        if (containsStart) {
+            const revisedCode = this.#code.withoutRange({
+                start: { node: this.#code, index: sortedRange.start.index },
+                end: {
+                    node: this.#code,
+                    index: containsEnd
+                        ? sortedRange.end.index
+                        : this.#code.getLength(),
+                },
+            });
+            if (revisedCode === undefined)
+                return;
+            editedNode = editedNode.withChildReplaced(this.#code, revisedCode);
+            if (editedNode === undefined)
+                return;
+            const revisedCaret = {
+                node: revisedCode,
+                index: sortedRange.start.index,
+            };
+            return {
+                root: editedNode,
+                range: { start: revisedCaret, end: revisedCaret },
+            };
+        }
+        else {
+            return captionEdit;
+        }
+    }
+    withNodeInserted(caret, node) {
+        // Only insert if the caret is in the code node.
+        if (caret.node !== this.#code)
+            return undefined;
+        // Convert the node to text, then insert it at the position.
+        const text = node
+            .getNodes()
+            .filter((n) => n instanceof TextNode)
+            .map((t) => t.getText())
+            .join('');
+        const newCode = this.#code.withCharacterAt(text, caret.index);
+        if (newCode === undefined)
+            return undefined;
+        const newNode = this.withChildReplaced(this.#code, newCode);
+        if (newNode === undefined)
+            return;
+        const newCaret = { node: newCode, index: caret.index + text.length };
+        return { root: newNode, range: { start: newCaret, end: newCaret } };
+    }
 }

package/models/chapter/CommentNode.d.ts

@@ -1,8 +1,8 @@
-import AtomNode from "./AtomNode";
-import type Caret from "./Caret";
-import type { CaretRange } from "./Caret";
-import FormatNode from "./FormatNode";
-import type Node from "./Node";
+import AtomNode from './AtomNode';
+import type Caret from './Caret';
+import type { CaretRange } from './Caret';
+import FormatNode from './FormatNode';
+import type Node from './Node';
 export default class CommentNode extends AtomNode<FormatNode> {
     constructor(comment: FormatNode);
     getType(): string;