bookish-press 0.4.45 → 0.4.47

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

@@ -1,13 +1,19 @@
+import type Caret from './Caret';
+import type { CaretRange } from './Caret';
 import FormatNode from './FormatNode';
 import Node from './Node';
 import AtomNode from './AtomNode';
 import BlocksNode from './BlocksNode';
+import type RootNode from './RootNode';
+
 export default class TextNode extends Node {
-    #text;
-    constructor(text = '') {
+    readonly #text: string;
+
+    constructor(text: string = '') {
         super();
         this.#text = text;
     }
+
     getType() {
         return 'text';
     }
@@ -20,19 +26,21 @@ export default class TextNode extends Node {
     getCaretPositionCount() {
         return this.#text.length;
     }
-    getParentOf() {
+    getParentOf(): Node | undefined {
         return undefined;
     }
-    getFirstCaret() {
+    getFirstCaret(): Caret {
         return { node: this, index: 0 };
     }
-    getLastCaret() {
+    getLastCaret(): Caret {
         return { node: this, index: this.#text.length };
     }
-    toText() {
+
+    toText(): string {
         return this.#text;
     }
-    toBookdown() {
+
+    toBookdown(): string {
         // Escape all characters with special meaning inside content nodes: _*`<^{~\[@% and :'s with no space after
         return this.#text
             .replace(/\\/g, '\\\\') // This has to go first! Otherwise it breaks all of the others below.
@@ -48,6 +56,7 @@ export default class TextNode extends Node {
             .replace(/@/g, '\\@')
             .replace(/(:)([a-z])/g, '\\:$2');
     }
+
     toHTML() {
         return this.#text
             .replace('<', '&lt;')
@@ -56,121 +65,164 @@ export default class TextNode extends Node {
             .replace('"', '&quot;')
             .replace("'", '&#39;');
     }
+
     getChildren() {
         return [];
     }
+
     copy() {
-        return new TextNode(this.#text);
-    }
-    isItalic(root) {
-        return (this.getAncestors(root).filter((p) => p instanceof FormatNode && p.getFormat() === '_').length > 0);
-    }
-    isBold(root) {
-        return (this.getAncestors(root).filter((p) => p instanceof FormatNode && p.getFormat() === '*').length > 0);
-    }
+        return new TextNode(this.#text) as this;
+    }
+
+    isItalic(root: Node) {
+        return (
+            this.getAncestors(root).filter(
+                (p) => p instanceof FormatNode && p.getFormat() === '_'
+            ).length > 0
+        );
+    }
+    isBold(root: Node) {
+        return (
+            this.getAncestors(root).filter(
+                (p) => p instanceof FormatNode && p.getFormat() === '*'
+            ).length > 0
+        );
+    }
+
     isEmpty() {
         return this.getLength() === 0;
     }
-    getFormat(root) {
-        return this.getClosestParentOfType(root, FormatNode);
+
+    getFormat(root: Node): FormatNode | undefined {
+        return this.getClosestParentOfType<FormatNode>(root, FormatNode);
     }
-    getFormatRoot(root) {
+
+    getFormatRoot(root: Node): FormatNode | undefined {
         // The format root is the highest format in the tree that contains this text.
         // There is one exception to this, however: formats inside atom nodes shouldn't traverse
         // past the atom node, since should be isolated from edits outside the atom.
-        const atom = this.getClosestParentMatching(root, (p) => p instanceof AtomNode);
-        if (atom && atom.getMeta() instanceof FormatNode)
-            return atom.getMeta();
+        const atom = this.getClosestParentMatching(
+            root,
+            (p) => p instanceof AtomNode
+        ) as AtomNode<FormatNode>;
+        if (atom && atom.getMeta() instanceof FormatNode) return atom.getMeta();
+
         // If this isn't in an atom, just return the highest format this is in.
-        return this.getFarthestParentMatching(root, (p) => p instanceof FormatNode);
+        return this.getFarthestParentMatching(
+            root,
+            (p) => p instanceof FormatNode
+        ) as FormatNode;
     }
-    getBlocks(root) {
-        return this.getClosestParentOfType(root, BlocksNode);
+
+    getBlocks(root: Node): BlocksNode | undefined {
+        return this.getClosestParentOfType<BlocksNode>(root, BlocksNode);
     }
-    getNextCaret(index) {
+
+    getNextCaret(index: number): Caret | undefined {
         return index < this.#text.length
             ? { node: this, index: index + 1 }
             : undefined;
     }
-    getPreviousCaret(index) {
+
+    getPreviousCaret(index: number): Caret | undefined {
         return index > 0 ? { node: this, index: index - 1 } : undefined;
     }
-    nextWord(root, index) {
-        if (index === undefined)
-            index = 0;
+
+    nextWord(root: RootNode, index?: number): Caret {
+        if (index === undefined) index = 0;
+
         // Search for the space after the given index.
         let i = index + 1;
-        while (i < this.getLength() && this.#text.charAt(i).match(/\W/))
-            i++;
-        while (i < this.getLength() && this.#text.charAt(i).match(/\w/))
-            i++;
+        while (i < this.getLength() && this.#text.charAt(i).match(/\W/)) i++;
+        while (i < this.getLength() && this.#text.charAt(i).match(/\w/)) i++;
+
         // If we found one in this node, return it.
-        if (i < this.getLength() ||
-            (i === this.getLength() && this.#text.charAt(i - 1).match(/\w/)))
+        if (
+            i < this.getLength() ||
+            (i === this.getLength() && this.#text.charAt(i - 1).match(/\w/))
+        )
             return { node: this, index: i };
+
         // Otherwise, find the next text node's next word boundary.
         const format = this.getFormatRoot(root);
         const formatTextNodes = format ? format.getTextNodes() : undefined;
         const nextNode = root.getNextTextOrAtom(this);
         const nextWord = nextNode?.nextWord(root);
+
         // If there isn't one, just go to the end of this.
-        if (formatTextNodes &&
+        if (
+            formatTextNodes &&
             nextNode &&
-            this === formatTextNodes[formatTextNodes.length - 1])
+            this === formatTextNodes[formatTextNodes.length - 1]
+        )
             return { node: nextNode, index: 0 };
         else if (nextWord === undefined)
             return { node: this, index: this.#text.length };
-        else
-            return nextWord;
+        else return nextWord;
     }
-    previousWord(root, index) {
-        if (index === undefined)
-            index = this.#text.length;
+
+    previousWord(root: RootNode, index?: number): Caret {
+        if (index === undefined) index = this.#text.length;
+
         // Scan left until we find a word character, then keep scanning until we reach a non-word character.
         let i = index - 1;
-        while (i > 0 && this.#text.charAt(i - 1).match(/\W/))
-            i--;
-        while (i > 0 && this.#text.charAt(i - 1).match(/\w/))
-            i--;
+        while (i > 0 && this.#text.charAt(i - 1).match(/\W/)) i--;
+        while (i > 0 && this.#text.charAt(i - 1).match(/\w/)) i--;
+
         // If we found one in this node, return it.
         if (i > 0 || (i === 0 && this.#text.charAt(0).match(/\w/)))
             return { node: this, index: i };
+
         // Otherwise, find the next text node's next word boundary.
         const format = this.getFormatRoot(root);
         const formatTextNodes = format ? format.getTextNodes() : undefined;
         const previousNode = root.getPreviousTextOrAtom(this);
         const previousWord = previousNode?.previousWord(root);
+
         // If there isn't one, just go to the end of this.
         if (formatTextNodes && previousNode && this === formatTextNodes[0])
             return {
                 node: previousNode,
-                index: previousNode instanceof TextNode
-                    ? previousNode.getLength()
-                    : 0,
+                index:
+                    previousNode instanceof TextNode
+                        ? previousNode.getLength()
+                        : 0,
             };
-        else if (previousWord === undefined)
-            return { node: this, index: 0 };
-        else
-            return previousWord;
+        else if (previousWord === undefined) return { node: this, index: 0 };
+        else return previousWord;
     }
+
     withChildReplaced() {
         return undefined;
     }
-    withCharacterAt(char, index) {
-        if (index < 0 || index > this.#text.length)
-            return undefined;
-        return new TextNode(this.#text.slice(0, index) + char + this.#text.slice(index));
+
+    withCharacterAt(char: string, index: number): TextNode | undefined {
+        if (index < 0 || index > this.#text.length) return undefined;
+        return new TextNode(
+            this.#text.slice(0, index) + char + this.#text.slice(index)
+        );
     }
-    withoutRange(range) {
-        if (range.start.node !== this && range.end.node !== this)
-            return;
+
+    withoutRange(range: CaretRange): TextNode | undefined {
+        if (range.start.node !== this && range.end.node !== this) return;
         const min = Math.max(0, Math.min(range.start.index, range.end.index));
-        const max = Math.min(this.#text.length, Math.max(range.start.index, range.end.index));
-        return new TextNode(this.#text.substring(0, min) + this.#text.substring(max));
-    }
-    withContentInRange(range) {
+        const max = Math.min(
+            this.#text.length,
+            Math.max(range.start.index, range.end.index)
+        );
+        return new TextNode(
+            this.#text.substring(0, min) + this.#text.substring(max)
+        );
+    }
+
+    withContentInRange(range: CaretRange): this | undefined {
         const includesStart = range.start.node === this;
         const includesEnd = range.end.node === this;
-        return new TextNode(this.#text.substring(includesStart ? range.start.index : 0, includesEnd ? range.end.index : this.#text.length));
+        return new TextNode(
+            this.#text.substring(
+                includesStart ? range.start.index : 0,
+                includesEnd ? range.end.index : this.#text.length
+            )
+        ) as this;
     }
 }

package/{util/getSubdomain.js → src/lib/util/getSubdomain.ts}

@@ -1,6 +1,5 @@
 export function getSubdomain() {
-    if (typeof window === 'undefined')
-        return undefined;
+    if (typeof window === 'undefined') return undefined;
     // Determine if there's a subdomain.
     const hostParts = window.location.hostname.split('.');
     const firstPart = hostParts[0];
@@ -9,16 +8,23 @@ export function getSubdomain() {
         ? undefined
         : firstPart;
 }
-export function pathWithoutSubdomain(path) {
+
+export function pathWithoutSubdomain(path: string) {
     // If there's no subdomain, just return the path.
     const subdomain = getSubdomain();
-    if (subdomain === undefined)
-        return path;
+    if (subdomain === undefined) return path;
+
     // Otherwise, return a full URL without the subdomain
-    return `${window.location.protocol}//${window.location.host.replace(subdomain + '.', '')}${path}${window.location.search}`;
+    return `${window.location.protocol}//${window.location.host.replace(
+        subdomain + '.',
+        ''
+    )}${path}${window.location.search}`;
 }
-export function getSubdomainURL(subdomain) {
+
+export function getSubdomainURL(subdomain: string) {
     const parts = window.location.host.split('.');
     // Construct a URL from the subdomain and the last one or two parts of the host (accounting for localhost and normal domains and top level domains.)
-    return `${window.location.protocol}//${subdomain}.${parts.length > 1 ? `${parts[parts.length - 2]}.` : ''}${parts[parts.length - 1]}`;
+    return `${window.location.protocol}//${subdomain}.${
+        parts.length > 1 ? `${parts[parts.length - 2]}.` : ''
+    }${parts[parts.length - 1]}`;
 }

package/{util/isMobile.js → src/lib/util/isMobile.ts}

@@ -1,6 +1,7 @@
 export function isMobile() {
     return watchMobile().matches;
 }
+
 export function watchMobile() {
     return window.matchMedia('screen and (max-width: 1200px)');
 }

package/{util/mineReference.js → src/lib/util/mineReference.ts}

@@ -1,28 +1,35 @@
 import Reference from '../models/book/Reference';
-export function mineReference(ids, text) {
+
+export function mineReference(ids: string[], text: string): Reference {
     // First find the year, since it's the most easily detected. Optional parens.
     let yearMatches = text.match(/(\(?[0-9]{4}\)?)/);
-    let year = yearMatches !== null && yearMatches.length > 0
-        ? yearMatches[1].replace('(', '').replace(')', '')
-        : undefined;
-    if (year && yearMatches)
-        text = text.replace(yearMatches[1], '');
+    let year =
+        yearMatches !== null && yearMatches.length > 0
+            ? yearMatches[1].replace('(', '').replace(')', '')
+            : undefined;
+    if (year && yearMatches) 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()!@:%_\+.~#?&\/\/=]*)/);
+    let url: string | null = null;
+    let urlMatches = text.match(
+        /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()!@:%_\+.~#?&\/\/=]*)/
+    );
     if (urlMatches !== null && urlMatches.length > 0) {
         url = urlMatches[0];
         const index = text.indexOf(url);
         text = text.substring(0, index) + text.substring(index + url.length);
     }
+
     // Split the remaining portion into sentences.
     let chunks = splitIntoSentences(text);
+
     // Authors are usually lists of roman characters and periods optionally followed by commas or semicolons
     let authors = chunks.find((t) => /[a-zA-Z\.]+[,;]?/.test(t));
     if (authors) {
         chunks = chunks.filter((t) => t !== authors);
         authors = authors.trim();
     }
+
     // Titles are usually lists of roman characters and spaces and maybe a colon.
     let title = chunks.find((t) => /[a-zA-Z0-9:!#?]+/.test(t));
     if (title) {
@@ -31,21 +38,33 @@ export function mineReference(ids, text) {
             title = title + '?';
         title = title.trim();
     }
+
     // Source is whatever is left.
     let source = chunks.length > 0 ? chunks[0] : undefined;
     if (source) {
         chunks = chunks.filter((t) => t !== source);
         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);
+        : new Reference(
+              getUniqueReferenceID(ids, authors, year),
+              authors || '',
+              year || '',
+              title || '',
+              source || '',
+              url || '',
+              '',
+              false
+          );
 }
-export function splitIntoSentences(text) {
+
+export function splitIntoSentences(text: string): string[] {
     // Split the remaining text by period-space sequences, assuming chunks of information are segmented by sentences
     // unless they are single initials followed by a period.
-    let sentences = [];
+    let sentences: string[] = [];
     let priorLetterSequence = '';
     let accumulator = '';
     for (let i = 0; i < text.length; i++) {
@@ -53,24 +72,27 @@ export function splitIntoSentences(text) {
         if (/[a-zA-Z]/.test(char)) {
             priorLetterSequence += char;
             accumulator += char;
-        }
-        else {
+        } else {
             if (char === '.' && priorLetterSequence.length !== 1) {
                 sentences.push(accumulator);
                 accumulator = '';
                 priorLetterSequence = '';
-            }
-            else {
+            } else {
                 priorLetterSequence = '';
                 accumulator += char;
             }
         }
     }
-    if (accumulator.length > 0)
-        sentences.push(accumulator);
+    if (accumulator.length > 0) sentences.push(accumulator);
+
     return sentences;
 }
-export function getUniqueReferenceID(ids, authors, year) {
+
+export function getUniqueReferenceID(
+    ids: string[],
+    authors?: string,
+    year?: string
+): string {
     if (authors && year) {
         // Split the authors, combine the first initials of each, then append the year.
         const semicolons = authors.includes(';');
@@ -85,16 +107,14 @@ export function getUniqueReferenceID(ids, authors, year) {
             const letter = letters.shift();
             revisedID =
                 id +
-                    (letter !== undefined
-                        ? letter
-                        : Math.floor(Math.random() * 10));
+                (letter !== undefined
+                    ? letter
+                    : Math.floor(Math.random() * 10));
         }
         return revisedID;
-    }
-    else {
+    } else {
         let id = 'ref';
-        for (let i = 0; i < 4; i++)
-            id = id + Math.round(Math.random() * 9);
+        for (let i = 0; i < 4; i++) id = id + Math.round(Math.random() * 9);
         return id;
     }
 }

package/{util/scrollToEyeLevel.js → src/lib/util/scrollToEyeLevel.ts}

@@ -1,10 +1,12 @@
-let scrollToEyeLevel = (el) => {
+let scrollToEyeLevel = (el: Element) => {
     // Top of the target minus a third of window height.
     window.scrollTo({
-        top: el.getBoundingClientRect().top +
+        top:
+            el.getBoundingClientRect().top +
             window.scrollY -
             window.innerHeight / 3,
         behavior: 'smooth',
     });
 };
+
 export default scrollToEyeLevel;

package/src/params/edition.ts

@@ -0,0 +1,3 @@
+export function match(param: string) {
+    return /^\d+$/.test(param);
+}

package/src/routes/+error.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+    import Feedback from '$lib/components/app/Feedback.svelte';
+    import Lead from '$lib/components/app/Lead.svelte';
+    import Link from '$lib/components/app/Link.svelte';
+    import Large from '../lib/components/app/Large.svelte';
+</script>
+
+<Lead><Large>Oops</Large>.</Lead>
+
+<Feedback error>
+    This page doesn't exist. Want to go <Link to="/">home</Link>?
+</Feedback>