bookish-press 0.4.47 → 0.4.48

package/models/chapter/CommentNode.js

@@ -0,0 +1,48 @@
+import AtomNode from './AtomNode';
+import FormatNode from './FormatNode';
+export default class CommentNode extends AtomNode {
+    constructor(comment) {
+        super(comment.withTextIfEmpty());
+    }
+    getType() {
+        return 'comment';
+    }
+    toText() {
+        return '';
+    }
+    toHTML() {
+        return `(${this.getMeta().toHTML()})`;
+    }
+    getDefaultCaret() {
+        return this.getMeta().getFirstCaret();
+    }
+    toBookdown(format) {
+        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());
+    }
+    withChildReplaced(node, replacement) {
+        return node instanceof FormatNode &&
+            replacement instanceof FormatNode &&
+            node === this.getMeta()
+            ? new CommentNode(replacement)
+            : undefined;
+    }
+    getParentOf(node) {
+        return node === this.getMeta()
+            ? this
+            : this.getMeta().getParentOf(node);
+    }
+    withMeta(comment) {
+        return new CommentNode(comment);
+    }
+    withContentInRange(range) {
+        const newFormat = this.getMeta().withContentInRange(range);
+        if (newFormat === undefined)
+            return;
+        return this.withMeta(newFormat);
+    }
+}

package/models/chapter/DefinitionNode.d.ts

@@ -0,0 +1,12 @@
+import MetadataNode from './MetadataNode';
+import TextNode from './TextNode';
+export default class DefinitionNode extends MetadataNode<string> {
+    constructor(phrase?: TextNode, glossaryID?: string);
+    getType(): string;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    copy(): this;
+    withMeta(meta: string): MetadataNode<string>;
+    withText(text: TextNode): MetadataNode<string>;
+}

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

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

package/models/chapter/Edit.d.ts

@@ -0,0 +1,7 @@
+import type { CaretRange } from './Caret';
+import type Node from './Node';
+type Edit = undefined | {
+    root: Node;
+    range: CaretRange;
+};
+export default Edit;

package/models/chapter/Edit.js

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

package/models/chapter/EmbedNode.d.ts

@@ -0,0 +1,45 @@
+import type Node from './Node';
+import type Position from './Position';
+import FormatNode from './FormatNode';
+import BlockNode from './BlockNode';
+import type { CaretRange } from './Caret';
+import type RootNode from './RootNode';
+import type Caret from './Caret';
+export default class EmbedNode extends BlockNode {
+    #private;
+    constructor(url: string, description: string, caption?: FormatNode, credit?: FormatNode, position?: Position);
+    getType(): string;
+    isVideo(): boolean;
+    getURL(): string;
+    getSmallURL(): string;
+    hasSmallURL(): boolean;
+    isHosted(): boolean;
+    isLocal(): boolean;
+    getDescription(): string;
+    getCaption(): FormatNode;
+    getCredit(): FormatNode;
+    getPosition(): Position;
+    getFormats(): FormatNode[];
+    getChildren(): FormatNode[];
+    getParentOf(node: Node): Node | undefined;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    toJSON(): {
+        url: string;
+        alt: string;
+        caption: string;
+        credit: string;
+    };
+    copy(): this;
+    withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    withURL(url: string): EmbedNode;
+    withURLs(url: string, thumbnail: string): EmbedNode;
+    withDescription(description: string): EmbedNode;
+    withCaption(caption: FormatNode): EmbedNode;
+    withCredit(credit: FormatNode): EmbedNode;
+    withPosition(position: Position): EmbedNode;
+    withContentInRange(range: CaretRange): this | undefined;
+    nextWord(): Caret;
+    previousWord(root: RootNode): Caret;
+}

package/models/chapter/EmbedNode.js

@@ -0,0 +1,168 @@
+import FormatNode from './FormatNode';
+import TextNode from './TextNode';
+import BlockNode from './BlockNode';
+// 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.
+     */
+    #urls;
+    #description;
+    #caption;
+    #credit;
+    #position;
+    constructor(url, description, caption, credit, 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) {
+        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() {
+        return this.#caption.toText();
+    }
+    toHTML() {
+        return `<img src="${this.getURL()}" alt="${this.getDescription()}" />`;
+    }
+    toBookdown() {
+        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);
+    }
+    withChildReplaced(node, replacement) {
+        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)
+            : undefined;
+    }
+    withURL(url) {
+        // 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, thumbnail) {
+        return new EmbedNode(url + URL_SEPARATOR + thumbnail, this.#description, this.#caption, this.#credit, this.#position);
+    }
+    withDescription(description) {
+        return new EmbedNode(this.#urls, description, this.#caption, this.#credit, this.#position);
+    }
+    withCaption(caption) {
+        return new EmbedNode(this.#urls, this.#description, caption, this.#credit, this.#position);
+    }
+    withCredit(credit) {
+        return new EmbedNode(this.#urls, this.#description, this.#caption, credit, this.#position);
+    }
+    withPosition(position) {
+        return new EmbedNode(this.#urls, this.#description, this.#caption, this.#credit, position);
+    }
+    withContentInRange(range) {
+        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);
+    }
+    nextWord() {
+        return this.#caption.getFirstCaret();
+    }
+    previousWord(root) {
+        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.d.ts

@@ -0,0 +1,17 @@
+import BlockNode from './BlockNode';
+import type Node from './Node';
+export default class ErrorNode extends BlockNode {
+    #private;
+    constructor(text: string | undefined, error: string);
+    getType(): string;
+    getError(): string;
+    getFormats(): never[];
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): never[];
+    getParentOf(): Node | undefined;
+    copy(): this;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

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

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

package/models/chapter/FootnoteNode.d.ts

@@ -0,0 +1,18 @@
+import FormatNode from './FormatNode';
+import AtomNode from './AtomNode';
+import type Node from './Node';
+import type Caret from './Caret';
+import type { CaretRange } from './Caret';
+export default class FootnoteNode extends AtomNode<FormatNode> {
+    constructor(content?: FormatNode);
+    getType(): string;
+    getDefaultCaret(): Caret | undefined;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    copy(): this;
+    getParentOf(node: Node): Node | undefined;
+    withChildReplaced(node: FormatNode, replacement: FormatNode | undefined): this | undefined;
+    withMeta(footnote: FormatNode): FootnoteNode;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/FootnoteNode.js

@@ -0,0 +1,47 @@
+import FormatNode from './FormatNode';
+import AtomNode from './AtomNode';
+import TextNode from './TextNode';
+export default class FootnoteNode extends AtomNode {
+    constructor(content) {
+        super(content === undefined
+            ? new FormatNode('', [new TextNode()])
+            : content.withTextIfEmpty());
+    }
+    getType() {
+        return 'footnote';
+    }
+    getDefaultCaret() {
+        return this.getMeta().getFirstCaret();
+    }
+    toText() {
+        return this.getMeta().toText();
+    }
+    toBookdown() {
+        return `{${this.getMeta().toBookdown()}}`;
+    }
+    toHTML() {
+        return `(${this.getMeta().toHTML()})`;
+    }
+    copy() {
+        return new FootnoteNode(this.getMeta().copy());
+    }
+    getParentOf(node) {
+        return node === this.getMeta()
+            ? this
+            : this.getMeta().getParentOf(node);
+    }
+    withChildReplaced(node, replacement) {
+        return node === this.getMeta() && replacement !== undefined
+            ? new FootnoteNode(replacement)
+            : undefined;
+    }
+    withMeta(footnote) {
+        return new FootnoteNode(footnote);
+    }
+    withContentInRange(range) {
+        const newFormat = this.getMeta().withContentInRange(range);
+        if (newFormat === undefined)
+            return;
+        return this.withMeta(newFormat);
+    }
+}

package/models/chapter/FormatNode.d.ts

@@ -0,0 +1,60 @@
+import Node from './Node';
+import type ErrorNode from './ErrorNode';
+import TextNode from './TextNode';
+import type Caret from './Caret';
+import { type CaretRange } from './Caret';
+import MetadataNode from './MetadataNode';
+import AtomNode from './AtomNode';
+import type Edit from './Edit';
+export type Format = '' | '*' | '_' | '^' | 'v';
+export type FormatNodeSegmentType = FormatNode | TextNode | ErrorNode | MetadataNode<any> | AtomNode<any>;
+export default class FormatNode extends Node {
+    #private;
+    constructor(format: Format, segments: FormatNodeSegmentType[]);
+    getType(): string;
+    getFormat(): Format;
+    getSegments(): FormatNodeSegmentType[];
+    isEmpty(): boolean;
+    isEmptyText(): boolean;
+    getLength(): number;
+    getParentOf(node: Node): Node | undefined;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    getChildren(): FormatNodeSegmentType[];
+    getFirstTextNode(): TextNode;
+    getLastTextNode(): TextNode;
+    copy(): this;
+    getTextNodes(): TextNode[];
+    getTextAndAtomNodes(): (TextNode | AtomNode<any>)[];
+    getAdjacentTextOrAtom(node: TextNode | AtomNode<any>, next: boolean): TextNode | AtomNode<any> | undefined;
+    getNextTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getPreviousTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getAdjacentCaret(caret: Caret, next: boolean): Caret | undefined;
+    getFirstCaret(): Caret | undefined;
+    getLastCaret(): Caret | undefined;
+    getSelection(): CaretRange;
+    getIndexOfTextNode(node: TextNode): number | undefined;
+    getSelectedText(range: CaretRange): string | undefined;
+    withTextIfEmpty(): FormatNode;
+    withSegmentPrepended(segment: FormatNodeSegmentType): FormatNode;
+    withSegmentAppended(segment: FormatNodeSegmentType): FormatNode;
+    withSegmentReplaced(segment: FormatNodeSegmentType, replacement: FormatNodeSegmentType): this | undefined;
+    withoutSegment(segment: FormatNodeSegmentType): this | undefined;
+    withChildReplaced(node: FormatNodeSegmentType, replacement: FormatNodeSegmentType | undefined): this;
+    split(caret: Caret): [FormatNode, FormatNode] | undefined;
+    withoutRange(range: CaretRange): FormatNode | undefined;
+    withFormat(range: CaretRange, format: Format | undefined): FormatNode | undefined;
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit;
+    getFormats(root: Node): Format[];
+    withSegmentAt(segment: FormatNodeSegmentType, caret: Caret): FormatNode | undefined;
+    withSegmentAtSelection(range: CaretRange, nodeCreator: (text: string) => FormatNodeSegmentType): Edit;
+    withoutContentBefore(caret: Caret): FormatNode | undefined;
+    withoutContentAfter(caret: Caret): FormatNode | undefined;
+    withContentAt(caret: Caret, before: boolean): FormatNode | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+    withSegmentsAppended(format: FormatNode): FormatNode;
+    withoutAdjacentContent(caret: Caret, next: boolean): Edit | undefined;
+    withoutCharacter(caret: Caret, next: boolean): Edit | undefined;
+    withNodeInserted(caret: Caret, node: Node): Edit;
+}