bookish-press 0.4.47 → 0.4.48

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

@@ -1,41 +1,28 @@
-import type Node from './Node';
 import BlockNode from './BlockNode';
 import FormatNode from './FormatNode';
 import TextNode from './TextNode';
-import type Caret from './Caret';
-import type { CaretRange } from './Caret';
 import AtomNode from './AtomNode';
 import MetadataNode from './MetadataNode';
-
 export default class ParagraphNode extends BlockNode {
-    readonly #format: FormatNode;
-    readonly #level: number;
-
-    constructor(level: number = 0, format?: FormatNode) {
+    #format;
+    #level;
+    constructor(level = 0, format) {
         super();
-
         // Always ensure the paragraphs have an empty space at the begining and end for insertion.
         let adjustedFormat = format ?? new FormatNode('', [new TextNode()]);
         if (adjustedFormat.getLength() > 0) {
             const first = adjustedFormat.getSegments()[0];
-            const last =
-                adjustedFormat.getSegments()[adjustedFormat.getLength() - 1];
+            const last = adjustedFormat.getSegments()[adjustedFormat.getLength() - 1];
             if (first instanceof AtomNode || first instanceof MetadataNode)
-                adjustedFormat = adjustedFormat.withSegmentPrepended(
-                    new TextNode()
-                );
+                adjustedFormat = adjustedFormat.withSegmentPrepended(new TextNode());
             if (last instanceof AtomNode || last instanceof MetadataNode)
-                adjustedFormat = adjustedFormat.withSegmentAppended(
-                    new TextNode()
-                );
+                adjustedFormat = adjustedFormat.withSegmentAppended(new TextNode());
         }
         // Always ensure a paragraph has at least an empty text node.
         adjustedFormat = adjustedFormat.withTextIfEmpty();
-
         this.#format = adjustedFormat;
         this.#level = level;
     }
-
     getType() {
         return 'paragraph';
     }
@@ -51,24 +38,22 @@ export default class ParagraphNode extends BlockNode {
     getChildren() {
         return [this.#format];
     }
-    getFirstTextNode(): TextNode {
+    getFirstTextNode() {
         return this.getFormat().getFirstTextNode();
     }
-    getLastTextNode(): TextNode {
+    getLastTextNode() {
         return this.getFormat().getLastTextNode();
     }
-    getTextNodes(): TextNode[] {
-        return this.getNodes().filter(
-            (n) => n instanceof TextNode
-        ) as TextNode[];
+    getTextNodes() {
+        return this.getNodes().filter((n) => n instanceof TextNode);
     }
-    getFirstCaret(): Caret | undefined {
+    getFirstCaret() {
         return this.#format.getFirstCaret();
     }
-    getLastCaret(): Caret | undefined {
+    getLastCaret() {
         return this.#format.getLastCaret();
     }
-    getSelection(): CaretRange {
+    getSelection() {
         const first = this.getFirstTextNode();
         const last = this.getLastTextNode();
         return {
@@ -76,110 +61,88 @@ export default class ParagraphNode extends BlockNode {
             end: { node: last, index: last.getLength() },
         };
     }
-    getParentOf(node: Node): Node | undefined {
+    getParentOf(node) {
         return node === this.#format ? this : this.#format.getParentOf(node);
     }
-
-    toText(): string {
+    toText() {
         return this.#format.toText();
     }
-
-    toBookdown(): string {
-        return (
-            (this.#level === 1
-                ? '# '
-                : this.#level === 2
+    toBookdown() {
+        return ((this.#level === 1
+            ? '# '
+            : this.#level === 2
                 ? '## '
                 : this.#level === 3
-                ? '### '
-                : '') + this.#format.toBookdown()
-        );
-    }
-
-    toHTML(): string {
-        const tag =
-            this.#level === 1
-                ? 'h1'
-                : this.#level === 2
+                    ? '### '
+                    : '') + this.#format.toBookdown());
+    }
+    toHTML() {
+        const tag = this.#level === 1
+            ? 'h1'
+            : this.#level === 2
                 ? 'h2'
                 : this.#level === 3
-                ? 'h2'
-                : 'p';
+                    ? 'h2'
+                    : 'p';
         return `<${tag}>${this.#format.toHTML()}</${tag}>`;
     }
-
-    withLevel(level: number): ParagraphNode {
+    withLevel(level) {
         return new ParagraphNode(level, this.#format);
     }
-
-    withContent(content: FormatNode): ParagraphNode {
+    withContent(content) {
         return new ParagraphNode(this.#level, content);
     }
-
-    withParagraphAppended(paragraph: ParagraphNode): ParagraphNode {
-        return new ParagraphNode(
-            this.#level,
-            new FormatNode('', [
-                ...this.#format.getSegments(),
-                ...paragraph.#format.getSegments(),
-            ])
-        );
-    }
-
-    withParagraphPrepended(paragraph: ParagraphNode): ParagraphNode {
-        return new ParagraphNode(
-            this.#level,
-            new FormatNode('', [
-                ...paragraph.#format.getSegments(),
-                ...this.#format.getSegments(),
-            ])
-        );
-    }
-
-    split(caret: Caret): [ParagraphNode, ParagraphNode] | undefined {
+    withParagraphAppended(paragraph) {
+        return new ParagraphNode(this.#level, new FormatNode('', [
+            ...this.#format.getSegments(),
+            ...paragraph.#format.getSegments(),
+        ]));
+    }
+    withParagraphPrepended(paragraph) {
+        return new ParagraphNode(this.#level, new FormatNode('', [
+            ...paragraph.#format.getSegments(),
+            ...this.#format.getSegments(),
+        ]));
+    }
+    split(caret) {
         // If we weren't given a text node, do nothing.
-        if (!(caret.node instanceof TextNode)) return;
-
+        if (!(caret.node instanceof TextNode))
+            return;
         // If this caret isn't in this paragraph, do nothing.
-        if (this.getParentOf(caret.node) === undefined) return;
-
+        if (this.getParentOf(caret.node) === undefined)
+            return;
         // If the caret is at the last position of the paragraph, insert a new empty paragraph.
         const lastTextNode = this.getLastTextNode();
-        if (
-            caret.node === lastTextNode &&
-            caret.index === lastTextNode.getLength()
-        )
+        if (caret.node === lastTextNode &&
+            caret.index === lastTextNode.getLength())
             return [this.copy(), new ParagraphNode()];
-
         // If the caret is in the first position of the paragraph, insert a new empty paragraph before.
         const firstTextNode = this.getFirstTextNode();
         if (caret.node === firstTextNode && caret.index === 0)
             return [new ParagraphNode(), this.copy()];
-
         // Otherwise, split the paragraph in two, with the caret at the beginning of the second.
         const before = this.#format.withoutContentAfter(caret);
         const after = this.#format.withoutContentBefore(caret);
-        if (after === undefined || before === undefined) return;
+        if (after === undefined || before === undefined)
+            return;
         return [
             new ParagraphNode(this.#level, before),
             new ParagraphNode(this.#level, after),
         ];
     }
-
     copy() {
-        return new ParagraphNode(this.#level, this.#format.copy()) as this;
+        return new ParagraphNode(this.#level, this.#format.copy());
     }
-
-    withChildReplaced(node: Node, replacement: Node | undefined) {
+    withChildReplaced(node, replacement) {
         return node === this.#format &&
             (replacement instanceof FormatNode || replacement === undefined)
-            ? (new ParagraphNode(this.#level, replacement) as this)
+            ? new ParagraphNode(this.#level, replacement)
             : undefined;
     }
-
-    withContentInRange(range: CaretRange): this | undefined {
+    withContentInRange(range) {
         const newFormat = this.#format.withContentInRange(range);
-        if (newFormat === undefined) return;
-        return new ParagraphNode(this.#level, newFormat) as this;
+        if (newFormat === undefined)
+            return;
+        return new ParagraphNode(this.#level, newFormat);
     }
 }

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

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

package/models/chapter/ParagraphNode.test.js

@@ -0,0 +1,30 @@
+import { test, expect } from 'vitest';
+import FootnoteNode from './FootnoteNode';
+import FormatNode from './FormatNode';
+import ParagraphNode from './ParagraphNode';
+import TextNode from './TextNode';
+const firstText = new TextNode('This is the first paragraph. What do you think of it?');
+const lastText = new TextNode("This is the second paragraph. I think it's redundant.");
+const combinedText = new TextNode(firstText.getText() + lastText.getText());
+const footnote = new FootnoteNode(new FormatNode('', [new TextNode('Side note!')]));
+const firstParagraph = new ParagraphNode(0, new FormatNode('', [firstText, footnote]));
+const lastParagraph = new ParagraphNode(0, new FormatNode('', [lastText]));
+const combinedParagraph = new ParagraphNode(0, new FormatNode('', [combinedText, footnote]));
+test('Combine/split', () => {
+    expect(firstParagraph.withParagraphAppended(lastParagraph).toBookdown()).toBe(`${firstText.getText()}${footnote.toBookdown()}${lastText.getText()}`);
+    const split = combinedParagraph.split({
+        node: combinedText,
+        index: combinedText.getText().indexOf('.') + 1,
+    });
+    expect(split).not.toBeUndefined();
+    if (split) {
+        expect(split[0].toBookdown()).toBe(firstText
+            .getText()
+            .substring(0, firstText.getText().indexOf('.') + 1));
+        expect(split[1].toBookdown()).toBe(firstText
+            .getText()
+            .substring(firstText.getText().indexOf('.') + 1) +
+            lastText.getText() +
+            footnote.toBookdown());
+    }
+});

package/models/chapter/Parser.d.ts

@@ -0,0 +1,75 @@
+import type Edition from '../book/Edition';
+import CalloutNode from './CalloutNode';
+import ChapterNode from './ChapterNode';
+import CitationsNode from './CitationsNode';
+import CodeNode from './CodeNode';
+import CommentNode from './CommentNode';
+import DefinitionNode from './DefinitionNode';
+import EmbedNode from './EmbedNode';
+import ErrorNode from './ErrorNode';
+import FootnoteNode from './FootnoteNode';
+import FormatNode from './FormatNode';
+import InlineCodeNode from './InlineCodeNode';
+import LabelNode from './LabelNode';
+import LinkNode from './LinkNode';
+import ListNode from './ListNode';
+import ParagraphNode from './ParagraphNode';
+import QuoteNode from './QuoteNode';
+import RuleNode from './RuleNode';
+import TableNode from './TableNode';
+import TextNode from './TextNode';
+import type Position from './Position';
+import type BlockNode from './BlockNode';
+import type Bookkeeping from './Bookkeeping';
+export default class Parser {
+    book: Edition | undefined;
+    text: string;
+    index: number;
+    openedDoubleQuote: boolean;
+    metadata: Bookkeeping;
+    constructor(book: Edition | undefined, text: string);
+    static preprocessSymbols(book: Edition, text: string): string;
+    static parseChapter(book: Edition | undefined, text: string): ChapterNode;
+    static parseFormat(book: Edition | undefined, text: string): FormatNode;
+    static parseEmbed(book: Edition | undefined, text: string): EmbedNode;
+    peek(): string | null;
+    more(): boolean;
+    nextIsEmptyParagraph(): boolean;
+    nextIsWhitespace(): boolean;
+    read(smarten?: boolean): string | null;
+    unread(): void;
+    rest(): string;
+    charBeforeNext(): string | null;
+    charAfterNext(): string | null;
+    restOfLine(): string;
+    nextIs(text: string): boolean;
+    nextIsContentDelimiter(): boolean;
+    nextMatches(regex: RegExp): boolean;
+    isBlankLine(): boolean;
+    readWhitespace(): void;
+    readUntilNewLine(): string;
+    readUntilNewlineOr(string: string): string;
+    parseChapter(): ChapterNode;
+    parseSymbols(): void;
+    parseBlock(): BlockNode;
+    parseParagraph(): ParagraphNode;
+    parseHeader(): ParagraphNode;
+    parseRule(): RuleNode;
+    parseList(): ListNode;
+    parseCode(): CodeNode;
+    parsePosition(): Position;
+    parseQuote(): QuoteNode;
+    parseCallout(): CalloutNode;
+    parseTable(): TableNode;
+    parseFormat(awaiting?: string): FormatNode;
+    parseEmbed(): EmbedNode;
+    parseComment(): CommentNode;
+    parseLabel(): LabelNode | ErrorNode;
+    parseStyle(awaiting: string): FormatNode | ErrorNode;
+    parseInlineCode(): InlineCodeNode;
+    parseCitations(): CitationsNode;
+    parseFootnote(): FootnoteNode;
+    parseDefinition(): DefinitionNode;
+    parseEscaped(): TextNode | ErrorNode;
+    parseLink(): LinkNode | ErrorNode;
+}