bookish-press 0.4.0

package/models/book/BookMedia.d.ts

@@ -0,0 +1,23 @@
+import type { StorageReference } from "firebase/storage";
+import type Book from "./Book";
+export declare type Image = {
+    url: string;
+    ref: StorageReference;
+};
+export default class BookMedia {
+    readonly book: Book;
+    _images: Image[] | undefined;
+    readonly observers: Set<(images: Image[]) => void>;
+    constructor(book: Book);
+    notify(observer: (images: Image[]) => void): void;
+    stopNotifying(observer: (images: Image[]) => void): void;
+    /** Get all non-thumbnail images. */
+    getImages(): Promise<Image[]>;
+    getImagePath(): string;
+    /** Get a listing of all of the images for the book. */
+    cacheImages(): Promise<Image[]>;
+    retrieveImages(): Promise<(Image | undefined)[]>;
+    getThumbnailURL(url: string, thumbnailRef: StorageReference, error: (message: string) => void, finished: (url: string, thumbnailURL: string) => void, attempt?: number): void;
+    upload(file: File, progressHandler: (progress: number) => void, errorHandler: (message: string) => void, finishedHandler: (url: string, thumbnailURL: string) => void): void;
+    remove(image: Image): Promise<Image[] | undefined>;
+}

package/models/book/BookMedia.js

@@ -0,0 +1,102 @@
+import { deleteObject, getDownloadURL, listAll, ref, uploadBytes } from "firebase/storage";
+import { v4 as uuidv4 } from 'uuid';
+import { storage } from "../Firebase";
+export default class BookMedia {
+    book;
+    _images;
+    // A list of functions to call when the book media changes.
+    observers = new Set();
+    constructor(book) {
+        this.book = book;
+    }
+    notify(observer) {
+        this.observers.add(observer);
+        // Notify it right away!
+        this.getImages().then(images => observer(images));
+    }
+    stopNotifying(observer) {
+        this.observers.delete(observer);
+    }
+    /** Get all non-thumbnail images. */
+    async getImages() {
+        return this._images === undefined ? this.cacheImages() : this._images;
+    }
+    getImagePath() { return `images/${this.book.getRefID()}/`; }
+    /** Get a listing of all of the images for the book. */
+    async cacheImages() {
+        if (storage === undefined)
+            return [];
+        // Find all the prefixes and items.
+        this._images = (await this.retrieveImages()).filter(image => image !== undefined);
+        // Notify observers
+        for (const observer of this.observers)
+            observer(this._images.slice());
+        return this._images;
+    }
+    async retrieveImages() {
+        if (storage === undefined)
+            return [];
+        // Create a reference under which you want to list
+        const listRef = ref(storage, this.getImagePath());
+        // Find all the prefixes and items.
+        return listAll(listRef)
+            .then((res) => Promise.all(res.items.map(itemRef => getDownloadURL(itemRef)
+            .then((url) => {
+            const image = { url: url, description: "", ref: itemRef };
+            if (this._images !== undefined) {
+                this._images.push(image);
+            }
+            return image;
+        }))));
+    }
+    getThumbnailURL(url, thumbnailRef, error, finished, attempt = 0) {
+        getDownloadURL(thumbnailRef)
+            .then(thumbnail => finished(url, thumbnail))
+            // Try again in a bit.
+            .catch(() => attempt > 10 ? error("Couldn't upload image") : setTimeout(() => this.getThumbnailURL(url, thumbnailRef, error, finished, attempt + 1), 250));
+    }
+    upload(file, progressHandler, errorHandler, finishedHandler) {
+        progressHandler;
+        if (storage === undefined)
+            return;
+        // The canonical path format for Bookish images in the store is image/{bookid}/{imageid}
+        // where {bookid} is the Firestore ID of the book being edited and {imageid} is just a random id.
+        const imageName = `image-${uuidv4()}`;
+        const imageRef = ref(storage, `${this.getImagePath()}/${imageName}`);
+        const thumbnailRef = ref(storage, `${this.getImagePath()}/thumbnails/${imageName}`);
+        uploadBytes(imageRef, file)
+            .then((snapshot) => {
+            getDownloadURL(snapshot.ref)
+                .then(url => {
+                // Give some time for the cloud function to create a thumbnail, then try to get it's URL.
+                setTimeout(() => this.getThumbnailURL(url, thumbnailRef, errorHandler, finishedHandler), 250);
+            })
+                .catch(() => errorHandler("Unable to get image URL."));
+        })
+            .then(() => this.cacheImages());
+        // This seems to be broken in Firebase right now. Switched above to a no-feedback approach.
+        // const uploadTask = uploadBytesResumable(imageRef, file);
+        // uploadTask.on("state_changed",
+        //     // During upload, notify of progress by sending an integer percent complete.
+        //     (snapshot) => progressHandler(Math.round((snapshot.bytesTransferred / snapshot.totalBytes) * 100)),
+        //     // If there's an error, map it to a message.
+        //     // https://firebase.google.com/docs/storage/web/handle-errors
+        //     (error) => {
+        //         console.error(error);
+        //         errorHandler( 
+        //             error.code === "storage/unauthorized" ? "Wrong permissions to upload" :
+        //             error.code === "storage/canceled" ? "Upload canceled" :                    
+        //             error.code === "storage/quota-exceeded" ? "Storage limit reached" :
+        //             error.code === "storage/unauthenticated" ? "Log in again to upload" :
+        //             "Unknown upload error"
+        //         )
+        //     }, 
+    }
+    async remove(image) {
+        if (storage === undefined)
+            return;
+        const imageRef = ref(storage, image.ref.fullPath);
+        await deleteObject(imageRef);
+        return await this.cacheImages();
+    }
+}

package/models/book/Chapter.d.ts

@@ -0,0 +1,70 @@
+import type ChapterNode from "../chapter/ChapterNode";
+import type Edition from "./Edition";
+import type { DocumentReference } from "firebase/firestore";
+export declare type ChapterSpecification = {
+    ref?: DocumentReference;
+    id: string;
+    title: string;
+    authors: string[];
+    image: string | null;
+    numbered: boolean;
+    forthcoming: boolean;
+    section?: string;
+    text?: string;
+};
+export declare type ChapterContent = {
+    text: string;
+};
+export declare type Match = {
+    left: string;
+    match: string;
+    right: string;
+};
+export default class Chapter {
+    readonly spec: ChapterSpecification;
+    edition: Edition;
+    ast: ChapterNode | undefined;
+    index: Record<string, Array<Match>> | undefined;
+    wordCount: number | undefined;
+    edits: {
+        resolve: Function;
+        reject: Function;
+    }[];
+    lastEdit: number;
+    listeners: Set<(text: string) => void>;
+    constructor(edition: Edition, spec: ChapterSpecification);
+    saveEdits(): void;
+    addListener(listener: (text: string) => void): void;
+    removeListener(listener: (text: string) => void): void;
+    notifyListeners(): void;
+    requestSave(): Promise<void>;
+    toObject(): any;
+    getBook(): Edition;
+    getRef(): DocumentReference<import("@firebase/firestore").DocumentData> | undefined;
+    getChapterID(): string;
+    setChapterID(id: string): Promise<void> | undefined;
+    getSection(): string | undefined;
+    setSection(section: string): Promise<void> | undefined;
+    isForthcoming(): boolean;
+    setForthcoming(forthcoming: boolean): Promise<void> | undefined;
+    isNumbered(): boolean;
+    setNumbered(numbered: boolean): Promise<void> | undefined;
+    getText(): string | undefined;
+    setText(text: string): void;
+    setAST(node: ChapterNode): Promise<void> | undefined;
+    addAuthor(name: string): Promise<void>;
+    getAuthors(): string[];
+    setAuthor(index: number, name: string): Promise<void> | undefined;
+    removeAuthor(index: number): Promise<void> | undefined;
+    getTitle(): string;
+    setTitle(title: string): Promise<void> | undefined;
+    getPosition(): number | undefined;
+    move(increment: number): Promise<void>;
+    delete(): Promise<void>;
+    getImage(): string | null;
+    setImage(embed: string | null): Promise<void> | undefined;
+    getIndex(): Record<string, Match[]> | undefined;
+    getAST(): ChapterNode | undefined;
+    getReadingTime(): number | undefined;
+    computeIndex(): Record<string, Match[]> | undefined;
+}

package/models/book/Chapter.js

@@ -0,0 +1,221 @@
+import Parser from "../chapter/Parser";
+import { BookSaveStatus } from "./Edition";
+import { loadChapterTextFromFirestore, updateChapterTextInFirestore } from "../Firestore";
+export default class Chapter {
+    // The metadata from the database.
+    spec;
+    edition;
+    // Caches
+    ast;
+    index;
+    wordCount;
+    // A list of requested edits, stored as promises, resolved
+    // when the book is ready to save.
+    edits = [];
+    lastEdit = 0;
+    // A set of listeners that are notified when the chapter text changes.
+    listeners = new Set();
+    constructor(edition, spec) {
+        this.edition = edition;
+        // Copy the spec, filling in defaults as necessary.
+        this.spec = {
+            ref: spec.ref,
+            id: spec.id,
+            title: spec.title,
+            authors: spec.authors ?? [],
+            image: spec.image ?? null,
+            numbered: spec.numbered === true || spec.numbered === undefined,
+            forthcoming: spec.forthcoming === true,
+            text: spec.text
+        };
+        // If the chapter has text, then parse it, count searchable words, and compute an index.
+        if (this.spec.text !== undefined)
+            this.setText(this.spec.text);
+        else if (this.spec.ref) {
+            loadChapterTextFromFirestore(this.spec.ref).then(text => this.setText(text.text));
+        }
+        // Otherwise, set them all to undefined.
+        else {
+            this.ast = undefined;
+            this.wordCount = 0;
+            this.index = undefined;
+        }
+    }
+    saveEdits() {
+        if (this.edition.editionRef && this.spec.ref && this.spec.text !== undefined) {
+            // If it's been more than a second since our last edit and there
+            // are edits that haven't been saved, try updating the book, 
+            // and if we succeed, resolve all of the edits, and if we fail,
+            // then reject them.
+            if (Date.now() - this.lastEdit > 1000 && this.edits.length > 0) {
+                // Tell listeners that this book model changed.
+                this.edition.notifyListeners(BookSaveStatus.Saving);
+                updateChapterTextInFirestore(this.edition.editionRef, this.spec.ref, this.spec.text)
+                    .then(() => {
+                    // Approve the edits.
+                    this.edits.forEach(edit => edit.resolve());
+                    this.edition.notifyListeners(BookSaveStatus.Saved);
+                })
+                    .catch(() => {
+                    // Reject the edits.
+                    this.edits.forEach(edit => edit.reject());
+                    this.edition.notifyListeners(BookSaveStatus.Error);
+                })
+                    .finally(() => {
+                    // Reset the edit queue.
+                    this.edits = [];
+                });
+            }
+        }
+    }
+    addListener(listener) { this.listeners.add(listener); }
+    removeListener(listener) { this.listeners.delete(listener); }
+    notifyListeners() {
+        this.listeners.forEach(listener => this.spec.text !== undefined ? listener.call(undefined, this.spec.text) : undefined);
+    }
+    // Adds a save request to the queue, to be resolved later after a period of
+    // inactivity. Returns a promise that will eventually be resolved.
+    requestSave() {
+        // Tell listeners that this chapter model changed.
+        this.edition.notifyListeners(BookSaveStatus.Changed);
+        // Return a promise that will resolve or reject later after this model saves the edits to the database.
+        this.lastEdit = Date.now();
+        const promise = new Promise((resolve, reject) => {
+            this.edits.push({ resolve: resolve, reject: reject });
+        });
+        return promise;
+    }
+    toObject() {
+        // Deep copy to prevent external mutations.
+        const payload = JSON.parse(JSON.stringify(this.spec));
+        // Reassign a copy of the Firebase ref, since the deep copy doesn't work for it.
+        payload.ref = this.spec.ref;
+        // Note that we don't include the chapter text in the payload; that's stored in the chapters subcollection.
+        // We just return the chapter metadata here, which is stored in the book collection.
+        delete payload.text;
+        return payload;
+    }
+    getBook() { return this.edition; }
+    getRef() { return this.spec.ref; }
+    getChapterID() { return this.spec.id; }
+    setChapterID(id) {
+        if (this.spec.id !== id) {
+            this.spec.id = id;
+            return this.edition.requestSave();
+        }
+    }
+    getSection() { return this.spec.section; }
+    setSection(section) {
+        if (this.spec.section !== section) {
+            this.spec.section = section;
+            return this.edition.requestSave();
+        }
+    }
+    isForthcoming() { return this.spec.forthcoming; }
+    setForthcoming(forthcoming) {
+        if (this.spec.forthcoming !== forthcoming) {
+            this.spec.forthcoming = forthcoming;
+            return this.edition.requestSave();
+        }
+    }
+    isNumbered() { return this.spec.numbered; }
+    setNumbered(numbered) {
+        if (numbered !== this.spec.numbered) {
+            this.spec.numbered = numbered;
+            return this.edition.requestSave();
+        }
+    }
+    getText() { return this.spec.text; }
+    setText(text) {
+        this.setAST(Parser.parseChapter(this.edition, text));
+    }
+    setAST(node) {
+        this.ast = node;
+        const newText = this.ast.toBookdown();
+        const changed = this.spec.text !== newText;
+        this.spec.text = newText;
+        this.wordCount = this.ast.toText().split(/\s+/).length;
+        this.index = this.computeIndex();
+        // Don't save if its the same. This is just an optimization.
+        if (changed) {
+            this.notifyListeners();
+            if (this.edition.editionRef && this.spec.ref)
+                return this.requestSave();
+        }
+    }
+    addAuthor(name) {
+        this.spec.authors.push(name);
+        return this.edition.requestSave();
+    }
+    getAuthors() { return this.spec.authors; }
+    setAuthor(index, name) {
+        if (index >= 0 && index < this.spec.authors.length) {
+            this.spec.authors[index] = name;
+            return this.edition.requestSave();
+        }
+    }
+    removeAuthor(index) {
+        if (index >= 0 && index < this.spec.authors.length) {
+            this.spec.authors.splice(index, 1);
+            return this.edition.requestSave();
+        }
+    }
+    getTitle() { return this.spec.title; }
+    setTitle(title) {
+        if (title !== this.spec.title) {
+            this.spec.title = title;
+            return this.edition.requestSave();
+        }
+    }
+    getPosition() { return this.edition.getChapterPosition(this.getChapterID()); }
+    move(increment) { return this.edition.moveChapter(this.getChapterID(), increment); }
+    delete() { return this.edition.deleteChapter(this.getChapterID()); }
+    getImage() { return this.spec.image; }
+    setImage(embed) {
+        if (this.spec.image === embed)
+            return;
+        this.spec.image = embed;
+        return this.edition.requestSave();
+    }
+    getIndex() { return this.index; }
+    getAST() { return this.ast; }
+    // Utility function
+    getReadingTime() { return this.isForthcoming() || !this.wordCount ? undefined : Math.max(1, Math.round(this.wordCount / 150)); }
+    computeIndex() {
+        if (!this.ast)
+            return;
+        // Build a list of common words
+        let commonWords = new Set();
+        ["a", "about", "all", "also", "and", "are", "as", "at", "be", "because", "but", "by", "can", "come", "could", "day", "do", "does", "even", "find", "first", "for", "from", "get", "give", "go", "has", "have", "he", "her", "here", "him", "his", "how", "I", "if", "in", "into", "is", "it", "its", "just", "know", "like", "look", "make", "man", "many", "me", "more", "my", "new", "no", "not", "now", "of", "on", "one", "only", "or", "other", "our", "out", "people", "say", "see", "she", "so", "some", "take", "tell", "than", "that", "the", "their", "them", "then", "there", "these", "they", "thing", "think", "this", "those", "time", "to", "two", "up", "use", "very", "want", "was", "way", "we", "well", "went", "what", "when", "which", "who", "will", "with", "would", "year", "yes", "you", "your"].forEach(word => commonWords.add(word));
+        // Get all the text in the chapter.
+        let text = this.ast.toText();
+        // Split by word boundaries.
+        const words = text.split(/\b/);
+        // Index the words
+        const index = {};
+        words.forEach((word, wordNumber) => {
+            // Skip non words. We keep them for search results.
+            if (!/[a-zA-Z\u2019]+/.test(word))
+                return;
+            word = word.toLowerCase();
+            // Should we include?
+            // • It shouldn't be a common word
+            // • It shouldn't have an apostrophe
+            // • It should be longer than two letters
+            // • It shouldn't end in 'ly'
+            if (!(commonWords.has(word)) && word.indexOf('\u2019') < 0 && (word.length > 2 && word.substring(word.length - 2, word.length) !== "ly")) {
+                // If we haven't started a list of occurrences, start one.
+                if (!(word in index))
+                    index[word] = [];
+                let match = {
+                    left: words.slice(Math.max(0, wordNumber - 10), Math.max(0, wordNumber - 1) + 1).join(""),
+                    match: words[wordNumber],
+                    right: words.slice(Math.min(words.length - 1, wordNumber + 1), Math.min(words.length - 1, wordNumber + 10) + 1).join("")
+                };
+                // Add the occurrence, but a lower case canonical version.
+                index[word.toLowerCase()].push(match);
+            }
+        });
+        return index;
+    }
+}

package/models/book/ChapterID.d.ts

@@ -0,0 +1,10 @@
+declare const ChapterIDs: {
+    TableOfContentsID: string;
+    ReferencesID: string;
+    SearchID: string;
+    MediaID: string;
+    IndexID: string;
+    GlossaryID: string;
+    UnknownID: string;
+};
+export default ChapterIDs;

package/models/book/ChapterID.js

@@ -0,0 +1,10 @@
+const ChapterIDs = {
+    TableOfContentsID: "",
+    ReferencesID: "references",
+    SearchID: "search",
+    MediaID: "media",
+    IndexID: "index",
+    GlossaryID: "glossary",
+    UnknownID: "unknown"
+};
+export default ChapterIDs;

package/models/book/Definition.d.ts

@@ -0,0 +1,6 @@
+declare type Definition = {
+    phrase: string;
+    definition: string;
+    synonyms?: string[];
+};
+export default Definition;

package/models/book/Definition.js

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

package/models/book/Edition.d.ts

@@ -0,0 +1,111 @@
+import Chapter from './Chapter';
+import type { ChapterSpecification } from './Chapter';
+import EmbedNode from "../chapter/EmbedNode";
+import type ReferenceNode from "../chapter/ReferenceNode";
+import type Theme from './Theme';
+import type Definition from './Definition.js';
+import type Book from './Book.js';
+import type { DocumentReference } from 'firebase/firestore';
+export declare type EditionSpecification = {
+    title: string;
+    authors: string[];
+    images: Record<string, string | null>;
+    description: string;
+    chapters: ChapterSpecification[];
+    license: string;
+    acknowledgements: string;
+    tags: string[];
+    revisions: [string, string][];
+    sources: Record<string, string>;
+    references: Record<string, string | string[]>;
+    symbols: Record<string, string>;
+    glossary: Record<string, Definition>;
+    theme: Theme | null;
+    uids: Array<string>;
+    bookRef?: DocumentReference;
+};
+export declare enum BookSaveStatus {
+    Changed = 0,
+    Saving = 1,
+    Saved = 2,
+    Error = 3
+}
+export default class Edition {
+    readonly specification: EditionSpecification;
+    readonly book: Book | undefined;
+    editionRef: DocumentReference | undefined;
+    chapters: Chapter[];
+    chaptersByID: Record<string, Chapter | undefined>;
+    listeners: Set<Function>;
+    edits: {
+        resolve: Function;
+        reject: Function;
+    }[];
+    lastEdit: number;
+    constructor(book?: Book, editionRef?: DocumentReference, specification?: EditionSpecification);
+    setRef(ref: DocumentReference): void;
+    saveEdits(): Promise<void>;
+    getBook(): Book | undefined;
+    addListener(listener: (status: BookSaveStatus) => void): void;
+    removeListener(listener: Function): void;
+    notifyListeners(status: BookSaveStatus): void;
+    requestSave(): Promise<void>;
+    toObject(): any;
+    getRef(): DocumentReference<import("@firebase/firestore").DocumentData> | undefined;
+    addUserID(uid: string): void;
+    getTitle(): string;
+    setTitle(title: string): Promise<void>;
+    getDescription(): string;
+    setDescription(text: string): Promise<void>;
+    getAcknowledgements(): string;
+    setAcknowledgements(text: string): Promise<void>;
+    getLicense(): string;
+    setLicense(text: string): Promise<void>;
+    getChapters(): Chapter[];
+    hasChapter(chapterID: string): boolean;
+    getChapter(chapterID: string): Chapter | undefined;
+    getChapterPosition(chapterID: string): number | undefined;
+    getChapterCount(): number;
+    addChapter(): Promise<void>;
+    moveChapter(chapterID: string, increment: number): Promise<void>;
+    deleteChapter(chapterID: string): Promise<void>;
+    getSymbols(): Record<string, string>;
+    hasReferences(): boolean;
+    getReferences(): Record<string, string | string[]>;
+    getReference(citationID: string): string | string[] | undefined;
+    addReferences(references: ReferenceNode[]): Promise<void>;
+    editReference(ref: ReferenceNode): Promise<void> | undefined;
+    editReferenceID(newCitationID: string, ref: ReferenceNode): Promise<void> | undefined;
+    removeReference(citationID: string): Promise<void> | undefined;
+    hasGlossary(): boolean;
+    getGlossary(): Record<string, Definition>;
+    hasDefinition(id: string): boolean;
+    addDefinition(id: string, phrase: string, definition: string, synonyms: string[]): Promise<void>;
+    removeDefinition(id: string): Promise<void>;
+    editDefinition(id: string, definition: Definition): Promise<void>;
+    editDefinitionID(id: string, newID: string): Promise<void> | undefined;
+    getTags(): string[];
+    getTheme(): Theme | null;
+    setTheme(theme: Theme | null): Promise<void>;
+    setThemeValue(group: string, name: string, value: string): Promise<void> | undefined;
+    getAuthors(): string[];
+    addAuthor(name: string): Promise<void>;
+    setAuthor(index: number, name: string): Promise<void>;
+    removeAuthor(index: number): Promise<void>;
+    getRevisions(): [string, string][];
+    hasImage(id: string): boolean;
+    getImage(id: string): string | null;
+    setImage(id: string, embed: string | null): Promise<void> | undefined;
+    getBookReadingTime(): number | undefined;
+    getChapterNumber(chapterID: string): undefined;
+    getSource(sourceID: string): string | null;
+    getChapterName(chapterID: string): string | undefined;
+    getChapterSection(chapterID: string): string | undefined;
+    getFootnoteSymbol(number: number): string;
+    getBookIndex(): Record<string, Set<string>>;
+    getNextChapterID(chapterID: string): string | null;
+    getPreviousChapterID(chapterID: string): string | null;
+    getEmbeds(): EmbedNode[];
+    isLatestPublishedEdition(): boolean;
+    getEditionNumber(): number | undefined;
+}