bookish-press 0.4.0

package/models/chapter/CodeNode.js

@@ -0,0 +1,64 @@
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import BlockNode from "./BlockNode";
+export default class CodeNode extends BlockNode {
+    #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;
+        this.#executable = executable;
+        this.#caption = caption === undefined ? new FormatNode("", [new TextNode()]) : caption.withTextIfEmpty();
+    }
+    getType() { return "code"; }
+    getCodeNode() { return this.#code; }
+    getCode() { return this.#code.getText(); }
+    getCaption() { return this.#caption; }
+    getPosition() { return this.#position; }
+    getLanguage() { return this.#language; }
+    isExecutable() { return this.#executable; }
+    getFormats() { return [this.#caption]; }
+    toText() { return ""; }
+    toHTML() { return `<pre><code>${this.#code.toHTML()}</code><pre><center>${this.#caption.toHTML()}</center>`; }
+    toBookdown() {
+        // Remember to escape any back ticks.
+        return "`" +
+            (this.#language !== "plaintext" ? this.#language : "") +
+            "\n" +
+            this.#code.getText().replace(/`/g, '\\`') +
+            "\n`" +
+            (this.#position !== "|" ? this.#position : "") +
+            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 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 && (replacement instanceof FormatNode || replacement === undefined) ? replacement : undefined;
+        return newCode || newCaption ? new CodeNode(newCode ? newCode : this.#code, this.#language, this.#position, newCaption ? newCaption : this.#caption) : 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);
+    }
+}

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;
+}

package/models/chapter/CommentNode.js

@@ -0,0 +1,32 @@
+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/models/chapter/DefinitionNode.js

@@ -0,0 +1,20 @@
+import MetadataNode from "./MetadataNode";
+import TextNode from "./TextNode";
+export default class DefinitionNode extends MetadataNode {
+    constructor(phrase, glossaryID = "") {
+        super(phrase === undefined ? new TextNode() : phrase, glossaryID);
+    }
+    getType() { return "definition"; }
+    toText() {
+        return this.getText().toText();
+    }
+    toHTML() { return `${this.getText().toHTML()}`; }
+    toBookdown() {
+        return `~${this.getText().toBookdown()}~${this.getMeta()}`;
+    }
+    copy() {
+        return new DefinitionNode(this.getText(), this.getMeta());
+    }
+    withMeta(meta) { return new DefinitionNode(this.getText(), meta); }
+    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";
+declare 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,40 @@
+import type Node from "./Node";
+import type Position from "./Position";
+import FormatNode from "./FormatNode";
+import BlockNode from "./BlockNode";
+import type { CaretRange } from "./Caret";
+export default class EmbedNode extends BlockNode {
+    #private;
+    constructor(url: string, description: string, caption?: FormatNode, credit?: FormatNode, position?: Position);
+    getType(): string;
+    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;
+}

package/models/chapter/EmbedNode.js

@@ -0,0 +1,89 @@
+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"; }
+    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.startsWith("http"); }
+    getDescription() { return this.#description; }
+    getCaption() { return this.#caption; }
+    getCredit() { return this.#credit; }
+    getPosition() { return this.#position; }
+    getFormats() { return [this.#credit, this.#caption]; }
+    getChildren() { return [this.#credit, this.#caption]; }
+    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.#caption.contains(range.start.node) ? new FormatNode("", [new TextNode()]) : this.#credit.withContentInRange(range);
+        const newCaption = this.#credit.contains(range.end.node) ? new FormatNode("", [new TextNode()]) : this.#caption.withContentInRange(range);
+        if (newCaption === undefined || newCredit === undefined)
+            return;
+        return new EmbedNode(this.#urls, this.#description, newCaption, newCredit, this.#position);
+    }
+}

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/models/chapter/ErrorNode.js

@@ -0,0 +1,21 @@
+import BlockNode from "./BlockNode";
+export default class ErrorNode extends BlockNode {
+    #text;
+    #error;
+    constructor(text, error) {
+        super();
+        this.#text = text;
+        this.#error = error;
+    }
+    getType() { return "error"; }
+    getError() { return this.#error; }
+    getFormats() { return []; }
+    toText() { return ""; }
+    toBookdown() { return this.#text ?? ""; }
+    toHTML() { return this.#text ?? ""; }
+    getChildren() { return []; }
+    getParentOf() { return undefined; }
+    copy() { return new ErrorNode(this.#text, this.#error); }
+    withChildReplaced() { return 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,29 @@
+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 declare type Format = "" | "*" | "_" | "^" | "v";
+export declare 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;
+}