bookish-press 0.4.47 → 0.4.49

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

@@ -1,68 +1,50 @@
-import type Node from './Node';
 import AtomNode from './AtomNode';
 import TextNode from './TextNode';
 import FormatNode from './FormatNode';
-import type EmbedNode from './EmbedNode';
-
-export type SelectableNode = TextNode | AtomNode<any> | EmbedNode;
-type Caret = { node: SelectableNode; index: number };
-export default Caret;
-
-export type CaretRange = { start: Caret; end: Caret };
-export type IndexRange = { start: number; end: number };
-
-export function getTextAndAtomNodes(node: Node): (AtomNode<any> | TextNode)[] {
+export function getTextAndAtomNodes(node) {
     return node
         .getNodes()
-        .filter((n) => n instanceof TextNode || n instanceof AtomNode) as (
-        | AtomNode<any>
-        | TextNode
-    )[];
+        .filter((n) => n instanceof TextNode || n instanceof AtomNode);
 }
-
-function getFormatRoots(node: Node): FormatNode[] {
-    const roots: FormatNode[] = [];
+function getFormatRoots(node) {
+    const roots = [];
     node.traverse((node, parents) => {
-        if (
-            node instanceof FormatNode &&
+        if (node instanceof FormatNode &&
             parents.length > 0 &&
-            !(parents[parents.length - 1] instanceof FormatNode)
-        )
+            !(parents[parents.length - 1] instanceof FormatNode))
             roots.push(node);
     });
     return roots;
 }
-
-export function caretToIndex(node: Node, caret: Caret): number | undefined {
-    let roots: Node[] = getFormatRoots(node);
-    if (roots.length === 0) roots = [node];
-
+export function caretToIndex(node, caret) {
+    let roots = getFormatRoots(node);
+    if (roots.length === 0)
+        roots = [node];
     let currentIndex = 0;
     for (let n = 0; n < roots.length; n++) {
         const nodes = getTextAndAtomNodes(roots[n]);
         for (let i = 0; i < nodes.length; i++) {
             const t = nodes[i];
-            if (t !== caret.node) currentIndex += t.getCaretPositionCount();
-            else return currentIndex + caret.index;
+            if (t !== caret.node)
+                currentIndex += t.getCaretPositionCount();
+            else
+                return currentIndex + caret.index;
         }
         // Include one for the root.
         currentIndex++;
     }
 }
-
-export function indexToCaret(node: Node, index: number): Caret | undefined {
-    let roots: Node[] = getFormatRoots(node);
-    if (roots.length === 0) roots = [node];
-
+export function indexToCaret(node, index) {
+    let roots = getFormatRoots(node);
+    if (roots.length === 0)
+        roots = [node];
     let currentIndex = 0;
     for (let n = 0; n < roots.length; n++) {
         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];
@@ -76,23 +58,17 @@ export function indexToCaret(node: Node, index: number): Caret | undefined {
         currentIndex++;
     }
 }
-
-export function caretRangeToIndexRange(
-    node: Node,
-    range: CaretRange
-): IndexRange | undefined {
+export function caretRangeToIndexRange(node, range) {
     const startIndex = caretToIndex(node, range.start);
     const endIndex = caretToIndex(node, range.end);
-    if (startIndex === undefined || endIndex === undefined) return;
+    if (startIndex === undefined || endIndex === undefined)
+        return;
     return { start: startIndex, end: endIndex };
 }
-
-export function indexRangeToCaretRange(
-    node: Node,
-    range: IndexRange
-): CaretRange | undefined {
+export function indexRangeToCaretRange(node, range) {
     const start = indexToCaret(node, range.start);
     const end = indexToCaret(node, range.end);
-    if (start === undefined || end === undefined) return;
+    if (start === undefined || end === undefined)
+        return;
     return { start: start, end: end };
 }

package/models/chapter/ChapterNode.d.ts

@@ -0,0 +1,34 @@
+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);
+    getType(): string;
+    getChapter(): this;
+    create(blocks: BlockNode[]): BlocksNode;
+    getErrors(): ErrorNode[];
+    getCitations(): Set<string>;
+    getFootnotes(): FootnoteNode[];
+    getHeaders(): ParagraphNode[];
+    getEmbeds(): EmbedNode[];
+    getComments(): CommentNode[];
+    getLabels(): LabelNode[];
+    hasLabel(labelID: string): boolean;
+    getCitationNumber(citationID: string): number | null;
+    toText(): string;
+    toBookdown(): string;
+    getNextTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getPreviousTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getChildren(): BlockNode[];
+    withChildReplaced(node: BlockNode, replacement: BlockNode | undefined): this | undefined;
+    copy(): this;
+}

package/models/chapter/ChapterNode.js

@@ -0,0 +1,117 @@
+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) {
+        super(blocks);
+        // Content extracted during parsing.
+        this.#metadata = metadata === undefined ? { symbols: {} } : metadata;
+    }
+    getType() {
+        return 'chapter';
+    }
+    getChapter() {
+        return this;
+    }
+    create(blocks) {
+        return new ChapterNode(blocks, this.#metadata);
+    }
+    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)));
+        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);
+    }
+    getLabels() {
+        return this.getNodes().filter((n) => n instanceof LabelNode);
+    }
+    hasLabel(labelID) {
+        return (this.getLabels().find((label) => label.getMeta() === labelID) !==
+            undefined);
+    }
+    getCitationNumber(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(' ');
+    }
+    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'));
+    }
+    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;
+    }
+    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;
+    }
+    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),
+            ];
+        return new ChapterNode(blocks, this.#metadata);
+    }
+    copy() {
+        return new ChapterNode(this.getBlocks().map((b) => b.copy()), this.#metadata);
+    }
+}

package/models/chapter/CitationsNode.d.ts

@@ -0,0 +1,16 @@
+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;
+    getDefaultCaret(): Caret;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getParentOf(): Node | undefined;
+    copy(): this;
+    withMeta(citations: string[]): CitationsNode;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

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

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

package/models/chapter/CodeNode.d.ts

@@ -0,0 +1,35 @@
+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);
+    getType(): string;
+    getCodeNode(): TextNode;
+    getCode(): string;
+    getCaption(): FormatNode;
+    getPosition(): Position;
+    getLanguage(): string;
+    isExecutable(): boolean;
+    getFormats(): FormatNode[];
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    getChildren(): (FormatNode | TextNode)[];
+    copy(): this;
+    getParentOf(node: Node): Node | undefined;
+    withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    withPosition(position: Position): CodeNode;
+    withLanguage(language: string): CodeNode;
+    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/{src/lib/models/chapter/CodeNode.ts → models/chapter/CodeNode.js}

@@ -1,29 +1,15 @@
-import type Node from './Node';
-import type Position from './Position';
-import FormatNode, { type Format } from './FormatNode';
+import FormatNode, {} 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 {
-    readonly #code: TextNode;
-    readonly #caption: FormatNode;
-    readonly #position: Position;
-    readonly #language: string;
-    readonly #executable: boolean;
-
-    constructor(
-        code: TextNode,
-        language: string,
-        position: Position,
-        caption?: FormatNode
-    ) {
+    #code;
+    #caption;
+    #position;
+    #language;
+    #executable;
+    constructor(code, language, position, caption) {
         super();
-
         const executable = language.charAt(language.length - 1) === '!';
-
         this.#code = code;
         this.#position = position;
         this.#language = executable ? language.slice(0, -1) : language;
@@ -33,11 +19,9 @@ export default class CodeNode extends BlockNode {
                 ? new FormatNode('', [new TextNode()])
                 : caption.withTextIfEmpty();
     }
-
     getType() {
         return 'code';
     }
-
     getCodeNode() {
         return this.#code;
     }
@@ -59,132 +43,82 @@ export default class CodeNode extends BlockNode {
     getFormats() {
         return [this.#caption];
     }
-
     toText() {
         return '';
     }
-    toHTML(): string {
+    toHTML() {
         return `<pre><code>${this.#code.toHTML()}</code><pre><center>${this.#caption.toHTML()}</center>`;
     }
-
-    toBookdown(): string {
+    toBookdown() {
         // Remember to escape any back ticks.
-        return (
-            '`' +
+        return ('`' +
             (this.#language !== 'plaintext' ? this.#language : '') +
             (this.#executable ? '!' : '') +
             '\n' +
             this.#code.getText().replace(/`/g, '\\`') +
             '\n`' +
             (this.#position !== '|' ? this.#position : '') +
-            this.#caption.toBookdown()
-        );
+            this.#caption.toBookdown());
     }
-
     getChildren() {
         return [this.#code, this.#caption];
     }
-
     copy() {
-        return new CodeNode(
-            this.#code.copy(),
-            this.#language,
-            this.#position,
-            this.#caption.copy()
-        ) as this;
-    }
-
-    getParentOf(node: Node): Node | undefined {
+        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);
     }
-
-    withChildReplaced(node: Node, replacement: Node | undefined) {
-        const newCode =
-            node === this.#code && replacement instanceof TextNode
-                ? replacement
-                : undefined;
-        const newCaption =
-            node === this.#caption &&
+    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;
+            ? replacement
+            : undefined;
         return newCode || newCaption
-            ? (new CodeNode(
-                  newCode ? newCode : this.#code,
-                  this.#language,
-                  this.#position,
-                  newCaption ? newCaption : this.#caption
-              ) as this)
+            ? new CodeNode(newCode ? newCode : this.#code, this.#language, this.#position, newCaption ? newCaption : this.#caption)
             : undefined;
     }
-
-    withPosition(position: Position) {
-        return new CodeNode(
-            this.#code,
-            this.#language,
-            position,
-            this.#caption
-        );
-    }
-    withLanguage(language: string) {
-        return new CodeNode(
-            this.#code,
-            language,
-            this.#position,
-            this.#caption
-        );
-    }
-    withExecutable(executable: boolean) {
-        return new CodeNode(
-            this.#code,
-            executable ? this.#language + '!' : this.#language,
-            this.#position,
-            this.#caption
-        );
-    }
-    withCaption(caption: FormatNode) {
-        return new CodeNode(
-            this.#code,
-            this.#language,
-            this.#position,
-            caption
-        );
-    }
-
-    withContentInRange(range: CaretRange): this | 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);
-        if (newCode === undefined || newCaption === undefined) return;
-        return new CodeNode(
-            newCode,
-            this.#language,
-            this.#position,
-            newCaption
-        ) as this;
-    }
-
+        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: CaretRange, format: Format | undefined): Edit {
-        let editedNode: Node | undefined = this;
-
+    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;
-
+        if (format !== undefined)
+            return captionEdit;
         // Grab the new CodeNode if the caption was edited.
-        if (captionEdit) editedNode = captionEdit.root as this;
-
+        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;
@@ -199,9 +133,11 @@ export default class CodeNode extends BlockNode {
                         : this.#code.getLength(),
                 },
             });
-            if (revisedCode === undefined) return;
+            if (revisedCode === undefined)
+                return;
             editedNode = editedNode.withChildReplaced(this.#code, revisedCode);
-            if (editedNode === undefined) return;
+            if (editedNode === undefined)
+                return;
             const revisedCaret = {
                 node: revisedCode,
                 index: sortedRange.start.index,
@@ -210,26 +146,27 @@ export default class CodeNode extends BlockNode {
                 root: editedNode,
                 range: { start: revisedCaret, end: revisedCaret },
             };
-        } else {
+        }
+        else {
             return captionEdit;
         }
     }
-
-    withNodeInserted(caret: Caret, node: Node): Edit {
+    withNodeInserted(caret, node) {
         // Only insert if the caret is in the code node.
-        if (caret.node !== this.#code) return undefined;
-
+        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 is TextNode => n instanceof TextNode)
+            .filter((n) => n instanceof TextNode)
             .map((t) => t.getText())
             .join('');
-
         const newCode = this.#code.withCharacterAt(text, caret.index);
-        if (newCode === undefined) return undefined;
+        if (newCode === undefined)
+            return undefined;
         const newNode = this.withChildReplaced(this.#code, newCode);
-        if (newNode === undefined) return;
+        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

@@ -0,0 +1,18 @@
+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;
+    toText(): string;
+    toHTML(): string;
+    getDefaultCaret(): Caret | undefined;
+    toBookdown(format?: FormatNode): string;
+    copy(): this;
+    withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    getParentOf(node: Node): Node | undefined;
+    withMeta(comment: FormatNode): CommentNode;
+    withContentInRange(range: CaretRange): this | undefined;
+}