bookish-press 0.4.45 → 0.4.47

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

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

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

@@ -1,50 +1,68 @@
+import type Node from './Node';
 import AtomNode from './AtomNode';
 import TextNode from './TextNode';
 import FormatNode from './FormatNode';
-export function getTextAndAtomNodes(node) {
+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)[] {
     return node
         .getNodes()
-        .filter((n) => n instanceof TextNode || n instanceof AtomNode);
+        .filter((n) => n instanceof TextNode || n instanceof AtomNode) as (
+        | AtomNode<any>
+        | TextNode
+    )[];
 }
-function getFormatRoots(node) {
-    const roots = [];
+
+function getFormatRoots(node: Node): FormatNode[] {
+    const roots: FormatNode[] = [];
     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, caret) {
-    let roots = getFormatRoots(node);
-    if (roots.length === 0)
-        roots = [node];
+
+export function caretToIndex(node: Node, caret: Caret): number | undefined {
+    let roots: Node[] = 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, index) {
-    let roots = getFormatRoots(node);
-    if (roots.length === 0)
-        roots = [node];
+
+export function indexToCaret(node: Node, index: number): Caret | undefined {
+    let roots: Node[] = 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];
@@ -58,17 +76,23 @@ export function indexToCaret(node, index) {
         currentIndex++;
     }
 }
-export function caretRangeToIndexRange(node, range) {
+
+export function caretRangeToIndexRange(
+    node: Node,
+    range: CaretRange
+): IndexRange | undefined {
     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, range) {
+
+export function indexRangeToCaretRange(
+    node: Node,
+    range: IndexRange
+): CaretRange | undefined {
     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/src/lib/models/chapter/ChapterNode.ts

@@ -0,0 +1,169 @@
+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 CitationsNode from './CitationsNode';
+import LabelNode from './LabelNode';
+import CommentNode from './CommentNode';
+import BlocksNode from './BlocksNode';
+
+export default class ChapterNode extends BlocksNode {
+    #metadata: Bookkeeping;
+
+    constructor(blocks: BlockNode[], metadata?: Bookkeeping) {
+        super(blocks);
+
+        // Content extracted during parsing.
+        this.#metadata = metadata === undefined ? { symbols: {} } : metadata;
+    }
+
+    getType() {
+        return 'chapter';
+    }
+    getChapter() {
+        return this;
+    }
+
+    create(blocks: BlockNode[]): BlocksNode {
+        return new ChapterNode(blocks, this.#metadata);
+    }
+
+    getErrors(): ErrorNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof ErrorNode
+        ) as ErrorNode[];
+    }
+    getCitations(): Set<string> {
+        const citations = new Set<string>();
+        (
+            this.getNodes().filter(
+                (n) => n instanceof CitationsNode
+            ) as CitationsNode[]
+        ).forEach((cites) =>
+            cites.getMeta().forEach((citationID) => citations.add(citationID))
+        );
+        return citations;
+    }
+    getFootnotes(): FootnoteNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof FootnoteNode
+        ) as FootnoteNode[];
+    }
+    getHeaders(): ParagraphNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof ParagraphNode && n.getLevel() > 0
+        ) as ParagraphNode[];
+    }
+    getEmbeds(): EmbedNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof EmbedNode
+        ) as EmbedNode[];
+    }
+    getComments(): CommentNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof CommentNode
+        ) as CommentNode[];
+    }
+
+    getLabels(): LabelNode[] {
+        return this.getNodes().filter(
+            (n) => n instanceof LabelNode
+        ) as LabelNode[];
+    }
+
+    hasLabel(labelID: string) {
+        return (
+            this.getLabels().find((label) => label.getMeta() === labelID) !==
+            undefined
+        );
+    }
+
+    getCitationNumber(citationID: string) {
+        const index = Array.from(this.getCitations())
+            .sort()
+            .indexOf(citationID);
+        return index < 0 ? null : index + 1;
+    }
+
+    toText(): string {
+        return this.getBlocks()
+            .map((block) => block.toText())
+            .join(' ');
+    }
+
+    toBookdown(): string {
+        // 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: TextNode | AtomNode<any>
+    ): TextNode | AtomNode<any> | undefined {
+        // 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: TextNode | AtomNode<any>
+    ): TextNode | AtomNode<any> | undefined {
+        // 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: BlockNode, replacement: BlockNode | undefined) {
+        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) as this;
+    }
+
+    copy() {
+        return new ChapterNode(
+            this.getBlocks().map((b) => b.copy()),
+            this.#metadata
+        ) as this;
+    }
+}

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

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