bookish-press 0.5.32 → 0.5.71

package/dist/models/book/Edition.js

@@ -174,20 +174,15 @@ export default class Edition {
     withChapters(chapters) {
         return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.base, this.active);
     }
-    withChapterText(text) {
-        // No need to make a new edition if no chapter was changed.
-        let modified = false;
+    withChapterText(textByID) {
         const newChapters = this.chapters.map((chapter) => {
-            if (chapter.ref === undefined)
+            if (chapter.ref === undefined) {
                 return chapter;
-            const match = text.find(([ref, text]) => chapter.ref !== undefined &&
-                chapter.ref.id === ref.id &&
-                chapter.text !== text);
-            if (match)
-                modified = true;
-            return match ? chapter.withText(match[1]) : chapter;
+            }
+            const text = textByID.get(chapter.ref.id);
+            return text === undefined ? chapter : chapter.withText(text);
         });
-        return modified ? this.withChapters(newChapters) : this;
+        return this.withChapters(newChapters);
     }
     withRevisedChapter(previous, edited) {
         const index = this.chapters.indexOf(previous);
@@ -482,7 +477,7 @@ export default class Edition {
         return bookIndex;
     }
     // Given the current chapter, find the available chapter after it.
-    getNextChapterID(chapterID) {
+    getNextChapterID(chapterID, editable) {
         // Handle back matter chapters.
         switch (chapterID) {
             case ChapterIDs.ReferencesID:
@@ -508,7 +503,7 @@ export default class Edition {
                     if (chapter.getID() === chapterID)
                         after = true;
                     // If we're after the given chapter and it's not forthcoming.
-                    else if (after && !chapter.isForthcoming())
+                    else if (after && (!chapter.isForthcoming() || editable))
                         return chapter.getID();
                 }
                 // If the given ID was the last chapter, go to the next back matter chapter.
@@ -524,7 +519,7 @@ export default class Edition {
         }
     }
     // Given a chapter id, find the available chapter before it.
-    getPreviousChapterID(chapterID) {
+    getPreviousChapterID(chapterID, editable) {
         switch (chapterID) {
             // Handle back matter chapters.
             case ChapterIDs.ReferencesID:
@@ -556,7 +551,7 @@ export default class Edition {
                     if (chapter.getID() === chapterID)
                         before = true;
                     // If we're before the given chapter and it's not forthcoming.
-                    else if (before && !chapter.isForthcoming())
+                    else if (before && (!chapter.isForthcoming() || editable))
                         return chapter.getID();
                 }
                 // If the given ID was the last chapter, go to the next back matter chapter.

package/dist/models/chapter/Caret.d.ts

@@ -2,6 +2,7 @@ import type Node from './Node';
 import AtomNode from './AtomNode';
 import TextNode from './TextNode';
 import type EmbedNode from './EmbedNode';
+import LineBreakNode from './LineBreakNode';
 export type SelectableNode = TextNode | AtomNode<any> | EmbedNode;
 type Caret = {
     node: SelectableNode;
@@ -16,7 +17,7 @@ export type IndexRange = {
     start: number;
     end: number;
 };
-export declare function getTextAndAtomNodes(node: Node): (AtomNode<any> | TextNode)[];
+export declare function getNavigableNodes(node: Node): (AtomNode<any> | TextNode | LineBreakNode)[];
 export declare function caretToIndex(node: Node, caret: Caret): number | undefined;
 export declare function indexToCaret(node: Node, index: number): Caret | undefined;
 export declare function caretRangeToIndexRange(node: Node, range: CaretRange): IndexRange | undefined;

package/dist/models/chapter/Caret.js

@@ -1,10 +1,13 @@
 import AtomNode from './AtomNode';
 import TextNode from './TextNode';
 import FormatNode from './FormatNode';
-export function getTextAndAtomNodes(node) {
+import LineBreakNode from './LineBreakNode';
+export function getNavigableNodes(node) {
     return node
         .getNodes()
-        .filter((n) => n instanceof TextNode || n instanceof AtomNode);
+        .filter((n) => n instanceof TextNode ||
+        n instanceof AtomNode ||
+        n instanceof LineBreakNode);
 }
 function getFormatRoots(node) {
     const roots = [];
@@ -22,7 +25,7 @@ export function caretToIndex(node, caret) {
         roots = [node];
     let currentIndex = 0;
     for (let n = 0; n < roots.length; n++) {
-        const nodes = getTextAndAtomNodes(roots[n]);
+        const nodes = getNavigableNodes(roots[n]);
         for (let i = 0; i < nodes.length; i++) {
             const t = nodes[i];
             if (t !== caret.node)
@@ -40,9 +43,9 @@ export function indexToCaret(node, index) {
         roots = [node];
     let currentIndex = 0;
     for (let n = 0; n < roots.length; n++) {
-        const nodes = getTextAndAtomNodes(roots[n]);
+        const nodes = getNavigableNodes(roots[n]);
         for (let i = 0; i < nodes.length; i++) {
-            const t = nodes[i];
+            let t = nodes[i];
             if (index >= currentIndex &&
                 index <= currentIndex + t.getCaretPositionCount()) {
                 // Prefer empty nodes to enable zero width formats.
@@ -51,7 +54,18 @@ export function indexToCaret(node, index) {
                     if (next instanceof TextNode && next.getLength() === 0)
                         return { node: next, index: 0 };
                 }
-                return { node: t, index: index - currentIndex };
+                // If it's a line break node, find the next non-line break node.
+                if (t instanceof LineBreakNode) {
+                    while (i < nodes.length &&
+                        nodes[i] instanceof LineBreakNode)
+                        i++;
+                    t = nodes[i];
+                    if (i === nodes.length || t instanceof LineBreakNode)
+                        return undefined;
+                    return { node: t, index: 0 };
+                }
+                else
+                    return { node: t, index: index - currentIndex };
             }
             currentIndex += t.getCaretPositionCount();
         }

package/dist/models/chapter/FormatNode.d.ts

@@ -6,8 +6,9 @@ import { type CaretRange } from './Caret';
 import MetadataNode from './MetadataNode';
 import AtomNode from './AtomNode';
 import type Edit from './Edit';
+import LineBreakNode from './LineBreakNode';
 export type Format = '' | '*' | '_' | '^' | 'v';
-export type FormatNodeSegmentType = FormatNode | TextNode | ErrorNode | MetadataNode<any> | AtomNode<any>;
+export type FormatNodeSegmentType = FormatNode | TextNode | LineBreakNode | ErrorNode | MetadataNode<any> | AtomNode<any>;
 export default class FormatNode extends Node {
     #private;
     constructor(format: Format, segments: FormatNodeSegmentType[]);
@@ -57,4 +58,6 @@ export default class FormatNode extends Node {
     withoutAdjacentContent(caret: Caret, next: boolean): Edit | undefined;
     withoutCharacter(caret: Caret, next: boolean): Edit | undefined;
     withNodeInserted(caret: Caret, node: Node): Edit;
+    getSegmentAfter(segment: FormatNodeSegmentType): FormatNodeSegmentType | undefined;
+    getSegmentBefore(segment: FormatNodeSegmentType): FormatNodeSegmentType | undefined;
 }

package/dist/models/chapter/FormatNode.js

@@ -3,6 +3,7 @@ import TextNode from './TextNode';
 import { caretRangeToIndexRange, caretToIndex, indexToCaret, } from './Caret';
 import MetadataNode from './MetadataNode';
 import AtomNode from './AtomNode';
+import LineBreakNode from './LineBreakNode';
 export default class FormatNode extends Node {
     #format;
     #segments;
@@ -10,14 +11,22 @@ export default class FormatNode extends Node {
         super();
         this.#format = format;
         // Remove consecutive empty text nodes.
-        this.#segments = segments.filter((item, position, list) => {
+        this.#segments = segments
+            .filter((item, position, list) => {
             if (position === 0 ||
                 !(item instanceof TextNode) ||
                 item.getLength() > 0)
                 return true;
             const previous = list[position - 1];
             return !(previous instanceof TextNode && previous.getLength() === 0);
-        });
+        })
+            // Insert text nodes between consecutive line breaks without them.
+            .map((item, position, list) => item instanceof LineBreakNode &&
+            list[position + 1] instanceof LineBreakNode
+            ? [item, new TextNode()]
+            : [item])
+            // Flatten the mapped list we made.
+            .flat();
         // Always ensure an empty text node.
         if (this.#segments.length === 0)
             this.#segments.push(new TextNode());
@@ -127,6 +136,11 @@ export default class FormatNode extends Node {
         }
         // If there's not, is there an adjacent caret in the sequence of text and atom nodes?
         const adjacentNode = this.getAdjacentTextOrAtom(caret.node, next);
+        // If there's a line break adjacent to the next node, account for it.
+        const linebreak = adjacentNode &&
+            (next
+                ? this.getSegmentBefore(adjacentNode) instanceof LineBreakNode
+                : this.getSegmentAfter(adjacentNode) instanceof LineBreakNode);
         if (adjacentNode !== undefined) {
             // Normally we skip over node boundaries because they look identical to each other.
             // But some nodes are zero length, so we have to account for that.
@@ -134,18 +148,20 @@ export default class FormatNode extends Node {
                 node: adjacentNode,
                 index: next
                     ? adjacentNode instanceof TextNode
-                        ? adjacentNode.isEmpty()
+                        ? adjacentNode.isEmpty() || linebreak
                             ? 0
                             : 1
                         : 0
                     : adjacentNode instanceof TextNode
                         ? adjacentNode.isEmpty()
                             ? 0
-                            : adjacentNode.getLength() - 1
+                            : linebreak
+                                ? adjacentNode.getLength()
+                                : adjacentNode.getLength() - 1
                         : 0,
             };
         }
-        // Otherwise, there is no adjascent caret.
+        // Otherwise, there is no adjacent caret.
         return undefined;
     }
     getFirstCaret() {
@@ -519,6 +535,19 @@ export default class FormatNode extends Node {
                 // Increment the text index; atoms count for one character.
                 textIndex++;
             }
+            // Line break? Preserve the node, unless it's being deleted.
+            else if (node instanceof LineBreakNode) {
+                // Save any text prior to the line break as a text node in the current format.
+                saveText();
+                // Insert the line break unless we're deleting
+                if (format !== undefined ||
+                    textIndex < selectionStartIndex ||
+                    textIndex > selectionEndIndex) {
+                    newFormats[0].segments.push(node);
+                }
+                // Increment the text index; atoms count for one character.
+                textIndex++;
+            }
         });
         // Save any remaining text that we've accumulated.
         saveText();
@@ -726,18 +755,33 @@ export default class FormatNode extends Node {
         if (!(node instanceof FormatNode ||
             node instanceof TextNode ||
             node instanceof MetadataNode ||
+            node instanceof LineBreakNode ||
             node instanceof AtomNode))
             return;
         const newFormat = this.withSegmentAt(node, caret);
+        if (newFormat === undefined)
+            return;
+        const segmentAfter = newFormat.getSegmentAfter(node);
         const newCaret = node instanceof AtomNode
             ? node.getDefaultCaret()
             : node instanceof FormatNode
                 ? node.getLastCaret()
-                : node instanceof MetadataNode
-                    ? { node: node.getText(), index: node.getText().getLength() }
-                    : { node: node, index: node.getLength() };
-        if (newFormat === undefined || newCaret === undefined)
+                : // Line break? Place the caret just after the line break, whether a text node or something else
+                    node instanceof LineBreakNode
+                        ? segmentAfter !== undefined && segmentAfter instanceof TextNode
+                            ? { node: segmentAfter, index: 0 }
+                            : undefined
+                        : node instanceof MetadataNode
+                            ? { node: node.getText(), index: node.getText().getLength() }
+                            : { node: node, index: node.getLength() };
+        if (newCaret === undefined)
             return;
         return { root: newFormat, range: { start: newCaret, end: newCaret } };
     }
+    getSegmentAfter(segment) {
+        return this.#segments[this.#segments.indexOf(segment) + 1];
+    }
+    getSegmentBefore(segment) {
+        return this.#segments[this.#segments.indexOf(segment) - 1];
+    }
 }

package/dist/models/chapter/LineBreakNode.d.ts

@@ -0,0 +1,15 @@
+import type { CaretRange } from './Caret';
+import Node from './Node';
+export default class LineBreakNode extends Node {
+    constructor();
+    getType(): string;
+    getParentOf(): Node | undefined;
+    toText(): string;
+    toBookdown(): string;
+    getCaretPositionCount(): number;
+    toHTML(): string;
+    getChildren(): never[];
+    copy(): this;
+    withChildReplaced(): this | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/dist/models/chapter/LineBreakNode.js

@@ -0,0 +1,37 @@
+import Node from './Node';
+import { LINE_BREAK } from './Symbols';
+export default class LineBreakNode extends Node {
+    constructor() {
+        super();
+    }
+    getType() {
+        return 'linebreak';
+    }
+    getParentOf() {
+        return undefined;
+    }
+    toText() {
+        return LINE_BREAK;
+    }
+    toBookdown() {
+        return LINE_BREAK;
+    }
+    getCaretPositionCount() {
+        return 1;
+    }
+    toHTML() {
+        return '<br/>';
+    }
+    getChildren() {
+        return [];
+    }
+    copy() {
+        return new LineBreakNode();
+    }
+    withChildReplaced() {
+        return this;
+    }
+    withContentInRange(range) {
+        return this;
+    }
+}

package/dist/models/chapter/Parser.d.ts

@@ -21,6 +21,7 @@ import TextNode from './TextNode';
 import type Position from './Position';
 import type BlockNode from './BlockNode';
 import type Bookkeeping from './Bookkeeping';
+import LineBreakNode from './LineBreakNode';
 export default class Parser {
     book: Edition | undefined;
     text: string;
@@ -62,6 +63,7 @@ export default class Parser {
     parseCallout(): CalloutNode;
     parseTable(): TableNode;
     parseFormat(awaiting?: string): FormatNode;
+    parseLineBreak(): LineBreakNode;
     parseEmbed(): EmbedNode;
     parseComment(): CommentNode;
     parseLabel(): LabelNode | ErrorNode;

package/dist/models/chapter/Parser.js

@@ -14,10 +14,11 @@ import LinkNode from './LinkNode';
 import ListNode from './ListNode';
 import ParagraphNode from './ParagraphNode';
 import QuoteNode from './QuoteNode';
-import Reference from '../book/Reference';
 import RuleNode from './RuleNode';
 import TableNode from './TableNode';
 import TextNode from './TextNode';
+import LineBreakNode from './LineBreakNode';
+import { LINE_BREAK } from './Symbols';
 const numberedRE = /^[0-9]+\.+/;
 const bulletRE = /^\*+\s+/;
 // TODO This grammar is slightly out of date.
@@ -181,6 +182,7 @@ export default class Parser {
             next === '*' ||
             next === '`' ||
             next === '@' ||
+            next === LINE_BREAK ||
             next === '~' ||
             (next === ':' &&
                 charAfterNext !== null &&
@@ -578,7 +580,10 @@ export default class Parser {
             // Parse some bold, italic, subscript, superscript
             if (next === '_' || next === '*' || next === '^')
                 segments.push(this.parseStyle(next));
-            // Parse unformatted text
+            // Parse a line break
+            else if (this.nextIs(LINE_BREAK))
+                segments.push(this.parseLineBreak());
+            // Parse inline code text
             else if (this.nextIs('`'))
                 segments.push(this.parseInlineCode());
             // Parse a citation list
@@ -634,6 +639,11 @@ export default class Parser {
         }
         return new FormatNode('', segments);
     }
+    parseLineBreak() {
+        // Read the line break
+        this.read();
+        return new LineBreakNode();
+    }
     parseEmbed() {
         // Read |
         this.read();

package/dist/models/chapter/Symbols.d.ts

@@ -0,0 +1 @@
+export declare const LINE_BREAK = "\u21A9";

package/dist/models/chapter/Symbols.js

@@ -0,0 +1 @@
+export const LINE_BREAK = '↩';

package/dist/util/mineReference.js

@@ -1,12 +1,16 @@
 import Reference from '../models/book/Reference';
 export function mineReference(ids, text) {
     // First find the year, since it's the most easily detected. Optional parens.
-    let yearMatches = text.match(/(\(?[0-9]{4}\)?)/);
+    let yearMatches = text.match(/(\(?[0-9]{4}(,[a-zA-Z ]+)?\)?)/);
     let year = yearMatches !== null && yearMatches.length > 0
         ? yearMatches[1].replace('(', '').replace(')', '')
         : undefined;
-    if (year && yearMatches)
+    if (year && yearMatches) {
+        const digits = year.match(/([0-9]{4})/);
+        if (digits !== null)
+            year = digits[1];
         text = text.replace(yearMatches[1], '');
+    }
     // Next, find the URL
     let url = null;
     let urlMatches = text.match(/https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()!@:%_\+.~#?&\/\/=]*)/);
@@ -38,9 +42,7 @@ export function mineReference(ids, text) {
         source = source.trim();
     }
     // If there's anything left, fall back to just a string.
-    return chunks.length > 0
-        ? new Reference(getUniqueReferenceID(ids), text)
-        : new Reference(getUniqueReferenceID(ids, authors, year), authors || '', year || '', title || '', source || '', url || '', '', false);
+    return new Reference(getUniqueReferenceID(ids, authors, year), authors || '', year || '', title || '', source || '', url || '', '', false);
 }
 export function splitIntoSentences(text) {
     // Split the remaining text by period-space sequences, assuming chunks of information are segmented by sentences
@@ -92,7 +94,7 @@ export function getUniqueReferenceID(ids, authors, year) {
         return revisedID;
     }
     else {
-        let id = 'ref';
+        let id = '00';
         for (let i = 0; i < 4; i++)
             id = id + Math.round(Math.random() * 9);
         return id;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "bookish-press",
     "private": false,
-    "version": "0.5.32",
+    "version": "0.5.71",
     "type": "module",
     "description": "A platform for reading and writing readable, accessible, beautiful online books.",
     "license": "MIT",
@@ -28,37 +28,40 @@
     },
     "devDependencies": {
         "@sveltejs/adapter-static": "^2.0",
-        "@sveltejs/kit": "^1.2",
-        "@sveltejs/package": "^2.0",
+        "@sveltejs/adapter-auto": "^2.1.1",
+        "@sveltejs/kit": "^1.27",
+        "@sveltejs/package": "^2.2",
         "@types/prismjs": "^1.26",
-        "@types/smoothscroll-polyfill": "^0.3.1",
+        "@types/smoothscroll-polyfill": "^0",
         "@types/uuid": "^9.0",
-        "prettier": "^2.8",
-        "prettier-plugin-svelte": "^2.10",
+        "prettier": "^3",
+        "prettier-plugin-svelte": "^3",
         "svelte-adapter-firebase": "^0.15.0",
-        "svelte-check": "^3.4",
-        "svelte-preprocess": "^5.0",
-        "tslib": "^2.5",
-        "typescript": "^5.1",
-        "vite": "^4.1.2",
-        "vitest": "^0.29.2"
+        "svelte-check": "^3.6",
+        "svelte-preprocess": "^5.1",
+        "tslib": "^2",
+        "typescript": "^5",
+        "vite": "^4",
+        "vitest": "^0"
     },
     "dependencies": {
-        "ajv": "^8.12.0",
-        "ajv-formats": "^2.1.1",
+        "@sveltejs/kit": "^1.27",
+        "ajv": "^8",
+        "ajv-formats": "^2",
         "firebase": "latest",
-        "firebase-functions": "^4.4.0",
-        "prismjs": "^1.29.0",
-        "smoothscroll-polyfill": "^0.4.4",
-        "svelte": "^3.59",
-        "@sveltejs/kit": "^1.2",
+        "firebase-functions": "latest",
+        "prismjs": "^1.29",
+        "smoothscroll-polyfill": "^0.4",
+        "svelte": "^4.2",
         "uuid": "^9.0"
     },
     "types": "./dist/index.d.ts",
+    "main": "./dist/index.js",
     "exports": {
         "./package.json": "./package.json",
         ".": {
             "types": "./dist/index.d.ts",
+            "main": "./dist/index.js",
             "svelte": "./dist/index.js",
             "default": "./dist/index.js"
         },