bookish-press 0.4.46 → 0.4.47

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

@@ -1,15 +1,29 @@
-import FormatNode, {} from './FormatNode';
+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 {
-    #code;
-    #caption;
-    #position;
-    #language;
-    #executable;
-    constructor(code, language, position, caption) {
+    readonly #code: TextNode;
+    readonly #caption: FormatNode;
+    readonly #position: Position;
+    readonly #language: string;
+    readonly #executable: boolean;
+
+    constructor(
+        code: TextNode,
+        language: string,
+        position: Position,
+        caption?: FormatNode
+    ) {
         super();
+
         const executable = language.charAt(language.length - 1) === '!';
+
         this.#code = code;
         this.#position = position;
         this.#language = executable ? language.slice(0, -1) : language;
@@ -19,9 +33,11 @@ export default class CodeNode extends BlockNode {
                 ? new FormatNode('', [new TextNode()])
                 : caption.withTextIfEmpty();
     }
+
     getType() {
         return 'code';
     }
+
     getCodeNode() {
         return this.#code;
     }
@@ -43,82 +59,132 @@ export default class CodeNode extends BlockNode {
     getFormats() {
         return [this.#caption];
     }
+
     toText() {
         return '';
     }
-    toHTML() {
+    toHTML(): string {
         return `<pre><code>${this.#code.toHTML()}</code><pre><center>${this.#caption.toHTML()}</center>`;
     }
-    toBookdown() {
+
+    toBookdown(): string {
         // 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());
-    }
-    getParentOf(node) {
+        return new CodeNode(
+            this.#code.copy(),
+            this.#language,
+            this.#position,
+            this.#caption.copy()
+        ) as this;
+    }
+
+    getParentOf(node: Node): Node | undefined {
         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 &&
+
+    withChildReplaced(node: Node, replacement: Node | undefined) {
+        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)
+            ? (new CodeNode(
+                  newCode ? newCode : this.#code,
+                  this.#language,
+                  this.#position,
+                  newCaption ? newCaption : this.#caption
+              ) as 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) {
+
+    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 {
         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);
-    }
+        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;
+    }
+
     /** Overrides super, special casing TextNode, since super only handles formats. */
-    withRangeFormatted(range, format) {
-        let editedNode = this;
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit {
+        let editedNode: Node | undefined = 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;
+        if (captionEdit) editedNode = captionEdit.root as this;
+
         // Next, see if part of the range included this text node.
         const sortedRange = this.sortRange(range);
         const containsStart = sortedRange.start.node === this.#code;
@@ -133,11 +199,9 @@ 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,
@@ -146,27 +210,26 @@ export default class CodeNode extends BlockNode {
                 root: editedNode,
                 range: { start: revisedCaret, end: revisedCaret },
             };
-        }
-        else {
+        } else {
             return captionEdit;
         }
     }
-    withNodeInserted(caret, node) {
+
+    withNodeInserted(caret: Caret, node: Node): Edit {
         // 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 instanceof TextNode)
+            .filter((n): n is TextNode => 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/src/lib/models/chapter/CommentNode.ts

@@ -0,0 +1,61 @@
+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) {
+        super(comment.withTextIfEmpty());
+    }
+
+    getType() {
+        return 'comment';
+    }
+    toText(): string {
+        return '';
+    }
+    toHTML(): string {
+        return `(${this.getMeta().toHTML()})`;
+    }
+
+    getDefaultCaret(): Caret | undefined {
+        return this.getMeta().getFirstCaret();
+    }
+
+    toBookdown(format?: FormatNode): string {
+        const previousText = format?.getPreviousTextOrAtom(this)?.toBookdown();
+        // Insert a space before the % if there isn't one before this.
+        return `${
+            previousText?.endsWith(' ') ? '' : ' '
+        }%${this.getMeta().toBookdown()}%`;
+    }
+
+    copy() {
+        return new CommentNode(this.getMeta().copy()) as this;
+    }
+
+    withChildReplaced(node: Node, replacement: Node | undefined) {
+        return node instanceof FormatNode &&
+            replacement instanceof FormatNode &&
+            node === this.getMeta()
+            ? (new CommentNode(replacement) as this)
+            : undefined;
+    }
+
+    getParentOf(node: Node): Node | undefined {
+        return node === this.getMeta()
+            ? this
+            : this.getMeta().getParentOf(node);
+    }
+
+    withMeta(comment: FormatNode) {
+        return new CommentNode(comment);
+    }
+
+    withContentInRange(range: CaretRange): this | undefined {
+        const newFormat = this.getMeta().withContentInRange(range);
+        if (newFormat === undefined) return;
+        return this.withMeta(newFormat) as this;
+    }
+}

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

@@ -1,28 +1,34 @@
 import MetadataNode from './MetadataNode';
 import TextNode from './TextNode';
-export default class DefinitionNode extends MetadataNode {
-    constructor(phrase, glossaryID = '') {
+
+export default class DefinitionNode extends MetadataNode<string> {
+    constructor(phrase?: TextNode, glossaryID: string = '') {
         super(phrase === undefined ? new TextNode() : phrase, glossaryID);
     }
+
     getType() {
         return 'definition';
     }
-    toText() {
+
+    toText(): string {
         return this.getText().toText();
     }
-    toHTML() {
+    toHTML(): string {
         return `${this.getText().toHTML()}`;
     }
-    toBookdown() {
+
+    toBookdown(): string {
         return `~${this.getText().toBookdown()}~${this.getMeta()}`;
     }
+
     copy() {
-        return new DefinitionNode(this.getText(), this.getMeta());
+        return new DefinitionNode(this.getText(), this.getMeta()) as this;
     }
-    withMeta(meta) {
+
+    withMeta(meta: string): MetadataNode<string> {
         return new DefinitionNode(this.getText(), meta);
     }
-    withText(text) {
+    withText(text: TextNode): MetadataNode<string> {
         return new DefinitionNode(text, this.getMeta());
     }
 }

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

@@ -0,0 +1,6 @@
+import type { CaretRange } from './Caret';
+import type Node from './Node';
+
+// Edits can either result in no change (represented by undefined) or a new root node and a selection in it.
+type Edit = undefined | { root: Node; range: CaretRange };
+export default Edit;

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

@@ -0,0 +1,257 @@
+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 RootNode from './RootNode';
+import type Caret from './Caret';
+
+// This is what we use to encode URLs in the URL field of the embed node.
+const URL_SEPARATOR = '*';
+
+export default class EmbedNode extends BlockNode {
+    /**
+     * The URL is actually a list of up to two URLs. The first is a full-size image URL, the second is a smaller image.
+     * These are used for responsive rendering and to limit bandwidth usage. Any image URLs after the second are ignored.
+     */
+    readonly #urls: string;
+    readonly #description: string;
+    readonly #caption: FormatNode;
+    readonly #credit: FormatNode;
+    readonly #position: Position;
+
+    constructor(
+        url: string,
+        description: string,
+        caption?: FormatNode,
+        credit?: FormatNode,
+        position: Position = '|'
+    ) {
+        super();
+
+        this.#urls = url;
+        this.#description = description;
+        this.#caption =
+            caption === undefined
+                ? new FormatNode('', [new TextNode()])
+                : caption.withTextIfEmpty();
+        this.#credit =
+            credit == undefined
+                ? new FormatNode('', [new TextNode()])
+                : credit.withTextIfEmpty();
+        this.#position = position;
+    }
+
+    getType() {
+        return 'embed';
+    }
+
+    isVideo() {
+        return (
+            this.#urls.includes('https://www.youtube.com') ||
+            this.#urls.includes('https://youtu.be') ||
+            this.#urls.includes('https://www.tiktok.com') ||
+            this.#urls.includes('vimeo.com')
+        );
+    }
+    getURL() {
+        return this.#urls.split(URL_SEPARATOR)[0];
+    }
+    getSmallURL() {
+        return this.isLocal()
+            ? 'images/small/' + this.getURL()
+            : this.hasSmallURL()
+            ? this.#urls.split(URL_SEPARATOR)[1]
+            : this.getURL();
+    }
+    hasSmallURL() {
+        return (
+            this.#urls.split(URL_SEPARATOR).length > 1 &&
+            this.#urls.split(URL_SEPARATOR)[1].trim().length > 0
+        );
+    }
+    isHosted() {
+        return this.#urls.includes('bookish');
+    }
+    isLocal() {
+        return this.#urls.length > 0 && !this.#urls.startsWith('http');
+    }
+    getDescription() {
+        return this.#description;
+    }
+    getCaption() {
+        return this.#caption;
+    }
+    getCredit() {
+        return this.#credit;
+    }
+    getPosition() {
+        return this.#position;
+    }
+    getFormats() {
+        return [this.#caption, this.#credit];
+    }
+    getChildren() {
+        return [this.#caption, this.#credit];
+    }
+    getParentOf(node: Node): Node | undefined {
+        if (node === this.#caption || node === this.#credit) return this;
+        const captionParent = this.#caption.getParentOf(node);
+        if (captionParent) return captionParent;
+        const creditParent = this.#credit.getParentOf(node);
+        if (creditParent) return creditParent;
+    }
+
+    toText(): string {
+        return this.#caption.toText();
+    }
+    toHTML(): string {
+        return `<img src="${this.getURL()}" alt="${this.getDescription()}" />`;
+    }
+    toBookdown(): string {
+        return `|${this.#urls}|${
+            this.#description
+        }|${this.#caption.toBookdown()}|${this.#credit.toBookdown()}|`;
+    }
+    toJSON() {
+        return {
+            url: this.#urls,
+            alt: this.#description,
+            caption: this.#caption.toText(),
+            credit: this.#credit.toText(),
+        };
+    }
+
+    copy() {
+        return new EmbedNode(
+            this.#urls,
+            this.#description,
+            this.#caption.copy(),
+            this.#credit.copy(),
+            this.#position
+        ) as this;
+    }
+
+    withChildReplaced(node: Node, replacement: Node | undefined) {
+        const newCaption =
+            node === this.#caption &&
+            (replacement === undefined || replacement instanceof FormatNode)
+                ? replacement
+                : this.#caption;
+        const newCredit =
+            node === this.#credit &&
+            (replacement === undefined || replacement instanceof FormatNode)
+                ? replacement
+                : this.#credit;
+        return newCaption || newCredit
+            ? (new EmbedNode(
+                  this.#urls,
+                  this.#description,
+                  newCaption,
+                  newCredit,
+                  this.#position
+              ) as this)
+            : undefined;
+    }
+
+    withURL(url: string) {
+        // If the URL is a YouTube URL, convert to an embed URL, since a raw YouTube URL is never valid for embedding.
+        if (url.includes('www.youtube.com/watch?v='))
+            url = url.replace('/watch?v=', '/embed/');
+
+        return new EmbedNode(
+            url,
+            this.#description,
+            this.#caption,
+            this.#credit,
+            this.#position
+        );
+    }
+    withURLs(url: string, thumbnail: string) {
+        return new EmbedNode(
+            url + URL_SEPARATOR + thumbnail,
+            this.#description,
+            this.#caption,
+            this.#credit,
+            this.#position
+        );
+    }
+    withDescription(description: string) {
+        return new EmbedNode(
+            this.#urls,
+            description,
+            this.#caption,
+            this.#credit,
+            this.#position
+        );
+    }
+    withCaption(caption: FormatNode) {
+        return new EmbedNode(
+            this.#urls,
+            this.#description,
+            caption,
+            this.#credit,
+            this.#position
+        );
+    }
+    withCredit(credit: FormatNode) {
+        return new EmbedNode(
+            this.#urls,
+            this.#description,
+            this.#caption,
+            credit,
+            this.#position
+        );
+    }
+    withPosition(position: Position) {
+        return new EmbedNode(
+            this.#urls,
+            this.#description,
+            this.#caption,
+            this.#credit,
+            position
+        );
+    }
+
+    withContentInRange(range: CaretRange): this | undefined {
+        if (!this.contains(range.start.node) && !this.contains(range.end.node))
+            return this.copy();
+        const newCredit =
+            this.#credit.contains(range.end.node) ||
+            this.#credit.contains(range.start.node)
+                ? this.#credit.withContentInRange(range)
+                : new FormatNode('', [new TextNode()]);
+        const newCaption =
+            this.#caption.contains(range.start.node) ||
+            this.#caption.contains(range.end.node)
+                ? this.#caption.withContentInRange(range)
+                : new FormatNode('', [new TextNode()]);
+        if (newCaption === undefined || newCredit === undefined) return;
+
+        return new EmbedNode(
+            this.#urls,
+            this.#description,
+            newCaption,
+            newCredit,
+            this.#position
+        ) as this;
+    }
+
+    nextWord(): Caret {
+        return this.#caption.getFirstCaret() as Caret;
+    }
+
+    previousWord(root: RootNode): Caret {
+        const previous = root.getPreviousTextOrAtom(
+            this.#caption.getFirstTextNode()
+        );
+        return previous
+            ? {
+                  node: previous,
+                  index:
+                      previous instanceof TextNode ? previous.getLength() : 0,
+              }
+            : { node: this, index: 0 };
+    }
+}

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

@@ -1,12 +1,15 @@
 import BlockNode from './BlockNode';
+import type Node from './Node';
+
 export default class ErrorNode extends BlockNode {
-    #text;
-    #error;
-    constructor(text, error) {
+    #text: string | undefined;
+    #error: string;
+    constructor(text: string | undefined, error: string) {
         super();
         this.#text = text;
         this.#error = error;
     }
+
     getType() {
         return 'error';
     }
@@ -16,28 +19,32 @@ export default class ErrorNode extends BlockNode {
     getFormats() {
         return [];
     }
-    toText() {
+
+    toText(): string {
         return '';
     }
-    toBookdown() {
+    toBookdown(): string {
         return this.#text ?? '';
     }
     toHTML() {
         return this.#text ?? '';
     }
+
     getChildren() {
         return [];
     }
-    getParentOf() {
+    getParentOf(): Node | undefined {
         return undefined;
     }
+
     copy() {
-        return new ErrorNode(this.#text, this.#error);
+        return new ErrorNode(this.#text, this.#error) as this;
     }
+
     withChildReplaced() {
         return undefined;
     }
-    withContentInRange() {
+    withContentInRange(): this | undefined {
         return this.copy();
     }
 }