bookish-press 0.5.5 → 0.5.7

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.5",
+    "version": "0.5.7",
     "type": "module",
     "description": "A platform for reading and writing readable, accessible, beautiful online books.",
     "license": "MIT",
@@ -28,30 +28,31 @@
     },
     "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",
+        "svelte-check": "^3.6",
+        "svelte-preprocess": "^5.1",
+        "tslib": "^2",
         "typescript": "^5",
-        "vite": "^4.3",
-        "vitest": "^0.32"
+        "vite": "^4",
+        "vitest": "^0"
     },
     "dependencies": {
-        "ajv": "^8.12",
-        "ajv-formats": "^2.1",
+        "@sveltejs/kit": "^1.27",
+        "ajv": "^8",
+        "ajv-formats": "^2",
         "firebase": "latest",
         "firebase-functions": "latest",
         "prismjs": "^1.29",
         "smoothscroll-polyfill": "^0.4",
-        "svelte": "^4.0",
-        "@sveltejs/kit": "^1.20",
+        "svelte": "^4.2",
         "uuid": "^9.0"
     },
     "types": "./dist/index.d.ts",