bookish-press 0.4.47 → 0.4.49

package/models/book/Book.js

@@ -0,0 +1,135 @@
+import BookMedia from './BookMedia';
+export default class Book {
+    ref;
+    title;
+    authors;
+    description;
+    cover;
+    published;
+    editions;
+    domain;
+    uids;
+    media;
+    constructor(ref, title, authors, description, cover, editions, domain, uids) {
+        this.ref = ref;
+        this.title = title;
+        this.authors = authors;
+        this.description = description;
+        this.cover = cover;
+        // The published state is always true if some edition's published flag isn't null.
+        this.published = editions.some((edition) => edition.published !== null);
+        // We always keep editions in reversed edition number for easy reference.
+        this.editions = editions.sort((a, b) => a.number - b.number);
+        this.domain = domain;
+        this.uids = uids;
+        this.media = new BookMedia(this);
+    }
+    getMedia() {
+        return this.media;
+    }
+    static fromJSON(ref, book) {
+        return new Book(ref, book.title, book.authors, book.description, book.cover, book.editions, book.domain, book.uids);
+    }
+    toJSON() {
+        const json = {
+            title: this.title,
+            authors: this.authors,
+            description: this.description,
+            cover: this.cover,
+            published: this.published,
+            domain: this.domain,
+            editions: this.editions,
+            uids: this.uids,
+            readuids: Array.from(new Set(this.editions
+                .map((edition) => [
+                ...edition.editionuids,
+                ...edition.chapteruids,
+            ])
+                .flat())),
+        };
+        return json;
+    }
+    getSubdomain() {
+        return this.domain;
+    }
+    withSubdomain(domain) {
+        return new Book(this.ref, this.title, this.authors, this.description, this.cover, this.editions, domain.length === 0 ? null : domain, this.uids);
+    }
+    getTitle() {
+        return this.title;
+    }
+    withTitle(title) {
+        return new Book(this.ref, title, this.authors, this.description, this.cover, this.editions, this.domain, this.uids);
+    }
+    getDescription() {
+        return this.description;
+    }
+    withDescription(description) {
+        return new Book(this.ref, this.title, this.authors, description, this.cover, this.editions, this.domain, this.uids);
+    }
+    getCover() {
+        return this.cover;
+    }
+    withCover(cover) {
+        return new Book(this.ref, this.title, this.authors, this.description, cover, this.editions, this.domain, this.uids);
+    }
+    getAuthors() {
+        return this.authors;
+    }
+    withAuthors(authors) {
+        return new Book(this.ref, this.title, authors, this.description, this.cover, this.editions, this.domain, this.uids);
+    }
+    getRef() {
+        return this.ref;
+    }
+    getRefID() {
+        return this.ref.id;
+    }
+    getEditionNumberID(number) {
+        // Get the ID corresponding to this number.
+        const edition = this.editions.find((ed) => ed.number === number);
+        return edition ? edition.ref.id : undefined;
+    }
+    getLatestPublishedEditionID() {
+        return this.editions.filter((ed) => ed.published !== null)[0]?.ref.id;
+    }
+    getLatestEditionID() {
+        return this.editions[0]?.ref.id;
+    }
+    getEditions() {
+        return this.editions.slice();
+    }
+    getPublishedEditionCount() {
+        return this.editions.filter((edition) => edition.published).length;
+    }
+    isEditor(uid) {
+        return this.uids.includes(uid);
+    }
+    withEditors(uids) {
+        return new Book(this.ref, this.title, this.authors, this.description, this.cover, this.editions, this.domain, uids);
+    }
+    withEditions(revisions) {
+        return new Book(this.ref, this.title, this.authors, this.description, this.cover, revisions, this.domain, this.uids);
+    }
+    withRevisedEdition(previous, revised) {
+        // Get the new info.
+        const info = revised.getInfo();
+        if (info === undefined)
+            return this;
+        // If no previous addition, just add it.
+        if (previous === undefined)
+            return this.withEditions([...this.editions, info]);
+        // Find the corresponding edition.
+        const index = this.editions.findIndex((edition) => edition.number === previous.number);
+        return index < 0
+            ? this
+            : this.withEditions([
+                ...this.editions.slice(0, index),
+                info,
+                ...this.editions.slice(index + 1),
+            ]);
+    }
+    hasPublishedEdition() {
+        return this.editions.some((revision) => revision.published !== null);
+    }
+}

package/models/book/BookMedia.d.ts

@@ -0,0 +1,23 @@
+import type { StorageReference } from 'firebase/storage';
+import type Book from './Book';
+export 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,108 @@
+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 > 25
+            ? error("Couldn't get the image URL. Connection issues?")
+            : 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/BookSaveStatus.d.ts

@@ -0,0 +1,7 @@
+declare enum BookSaveStatus {
+    Changed = 0,
+    Saving = 1,
+    Saved = 2,
+    Error = 3
+}
+export default BookSaveStatus;

package/models/book/BookSaveStatus.js

@@ -0,0 +1,8 @@
+var BookSaveStatus;
+(function (BookSaveStatus) {
+    BookSaveStatus[BookSaveStatus["Changed"] = 0] = "Changed";
+    BookSaveStatus[BookSaveStatus["Saving"] = 1] = "Saving";
+    BookSaveStatus[BookSaveStatus["Saved"] = 2] = "Saved";
+    BookSaveStatus[BookSaveStatus["Error"] = 3] = "Error";
+})(BookSaveStatus || (BookSaveStatus = {}));
+export default BookSaveStatus;

package/models/book/Chapter.d.ts

@@ -0,0 +1,81 @@
+import type ChapterNode from '../chapter/ChapterNode';
+import type Edition from './Edition';
+import type { DocumentReference } from 'firebase/firestore';
+export type ChapterSpecification = {
+    ref?: DocumentReference;
+    id: string;
+    title: string;
+    authors: string[];
+    image: string | null;
+    numbered: boolean;
+    forthcoming: boolean;
+    section?: string;
+    text?: string;
+    uids: string[];
+};
+export type ChapterContent = {
+    text: string;
+};
+export type Match = {
+    left: string;
+    match: string;
+    right: string;
+};
+export default class Chapter {
+    readonly ref: DocumentReference | undefined;
+    readonly id: string;
+    readonly title: string;
+    readonly authors: string[];
+    readonly image: string | null;
+    readonly numbered: boolean;
+    readonly forthcoming: boolean;
+    readonly section: string | undefined;
+    readonly text: string;
+    readonly uids: string[];
+    _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(ref: DocumentReference | undefined, id: string, title: string, authors: string[], image: string | null, numbered: boolean, forthcoming: boolean, section: string | undefined, text: string, uids: string[]);
+    /**
+     * Convert a chapter spec and it's text into a chapter object.
+     * The spec may contain the text itself, but it may not, so we require it to be
+     * repeated here to guarantee its provided.
+     */
+    static fromJSON(spec: ChapterSpecification, text: string): Chapter;
+    toJSON(): ChapterSpecification;
+    getRef(): DocumentReference<import("@firebase/firestore").DocumentData> | undefined;
+    withEditors(uids: string[]): Chapter;
+    withRef(ref: DocumentReference): Chapter;
+    withoutRef(): Chapter;
+    getID(): string;
+    withChapterID(id: string): Chapter;
+    getSection(): string | undefined;
+    withSection(section: string): Chapter;
+    isForthcoming(): boolean;
+    asForthcoming(forthcoming: boolean): Chapter;
+    isNumbered(): boolean;
+    asNumbered(numbered: boolean): Chapter;
+    isEditor(uid: string): boolean;
+    getText(): string;
+    withText(text: string): Chapter;
+    withAST(ast: ChapterNode): Chapter;
+    getAuthors(): string[];
+    withAuthor(name: string): Chapter;
+    withRenamedAuthor(index: number, name: string): Chapter;
+    withoutAuthor(index: number): Chapter;
+    getTitle(): string;
+    withTitle(title: string): Chapter;
+    getImage(): string | null;
+    withImage(image: string | null): Chapter;
+    getAST(edition: Edition): ChapterNode;
+    getWordCount(edition: Edition): number;
+    getReadingTime(edition: Edition): number | undefined;
+    getIndex(edition: Edition): Record<string, Match[]>;
+    toString(): string;
+}

package/models/book/Chapter.js

@@ -0,0 +1,212 @@
+import Parser from '../chapter/Parser';
+import CommonWords from './Words';
+export default class Chapter {
+    // Inputs
+    ref;
+    id;
+    title;
+    authors;
+    image;
+    numbered;
+    forthcoming;
+    section;
+    text;
+    uids;
+    // Derived values
+    _ast = undefined;
+    _index = undefined;
+    _wordCount = undefined;
+    // 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(ref, id, title, authors, image, numbered, forthcoming, section, text, uids) {
+        this.ref = ref;
+        this.id = id;
+        this.title = title;
+        this.authors = authors.slice();
+        this.image = image;
+        this.numbered = numbered;
+        this.forthcoming = forthcoming;
+        this.section = section;
+        this.text = text;
+        this.uids = uids;
+    }
+    /**
+     * Convert a chapter spec and it's text into a chapter object.
+     * The spec may contain the text itself, but it may not, so we require it to be
+     * repeated here to guarantee its provided.
+     */
+    static fromJSON(spec, text) {
+        // Copy the spec, filling in defaults as necessary.
+        return new Chapter(spec.ref, spec.id, spec.title, spec.authors ?? [], spec.image ?? null, spec.numbered === true || spec.numbered === undefined, spec.forthcoming === true, spec.section, spec.text ?? text, spec.uids);
+    }
+    toJSON() {
+        // 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.
+        const json = {
+            id: this.id,
+            title: this.title,
+            authors: this.authors.slice(),
+            image: this.image,
+            numbered: this.numbered,
+            forthcoming: this.forthcoming,
+            uids: this.uids,
+        };
+        if (this.ref)
+            json.ref = this.ref;
+        if (this.section)
+            json.section = this.section;
+        return json;
+    }
+    getRef() {
+        return this.ref;
+    }
+    withEditors(uids) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, uids);
+    }
+    withRef(ref) {
+        return new Chapter(ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    withoutRef() {
+        return new Chapter(undefined, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getID() {
+        return this.id;
+    }
+    withChapterID(id) {
+        return new Chapter(this.ref, id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getSection() {
+        return this.section;
+    }
+    withSection(section) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, section, this.text, this.uids);
+    }
+    isForthcoming() {
+        return this.forthcoming;
+    }
+    asForthcoming(forthcoming) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, forthcoming, this.section, this.text, this.uids);
+    }
+    isNumbered() {
+        return this.numbered;
+    }
+    asNumbered(numbered) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    isEditor(uid) {
+        return this.uids.includes(uid);
+    }
+    getText() {
+        return this.text;
+    }
+    withText(text) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, text, this.uids);
+    }
+    withAST(ast) {
+        const newChapter = new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, ast.toBookdown(), this.uids);
+        newChapter._ast = ast;
+        return newChapter;
+    }
+    getAuthors() {
+        return this.authors;
+    }
+    withAuthor(name) {
+        return new Chapter(this.ref, this.id, this.title, [...this.authors, name], this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    withRenamedAuthor(index, name) {
+        if (index < 0 || index >= this.authors.length)
+            return this;
+        return new Chapter(this.ref, this.id, this.title, [
+            ...this.authors.slice(0, index),
+            name,
+            ...this.authors.slice(index + 1),
+        ], this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    withoutAuthor(index) {
+        if (index < 0 || index >= this.authors.length)
+            return this;
+        return new Chapter(this.ref, this.id, this.title, [...this.authors.slice(0, index), ...this.authors.slice(index + 1)], this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getTitle() {
+        return this.title;
+    }
+    withTitle(title) {
+        return new Chapter(this.ref, this.id, title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getImage() {
+        return this.image;
+    }
+    withImage(image) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getAST(edition) {
+        // Compute the cache if necessary
+        if (this._ast === undefined)
+            this._ast = Parser.parseChapter(edition, this.text);
+        return this._ast;
+    }
+    getWordCount(edition) {
+        if (this._wordCount === undefined)
+            this._wordCount = this.getAST(edition).toText().split(/\s+/).length;
+        return this._wordCount;
+    }
+    // Utility function
+    getReadingTime(edition) {
+        return this.isForthcoming()
+            ? undefined
+            : Math.max(1, Math.round(this.getWordCount(edition) / 150));
+    }
+    getIndex(edition) {
+        if (this._index === undefined) {
+            const ast = this.getAST(edition);
+            // Build a list of common words
+            let commonWords = new Set();
+            CommonWords.forEach((word) => commonWords.add(word));
+            // Get all the text in the chapter.
+            let text = 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);
+                }
+            });
+            this._index = index;
+        }
+        return this._index;
+    }
+    toString() {
+        return `${this.title} by ${this.authors.join(', ')}: ${this.text.substring(0, 32)}}`;
+    }
+}

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/{src/lib/models/book/ChapterID.ts → models/book/ChapterID.js}

@@ -7,5 +7,4 @@ const ChapterIDs = {
     GlossaryID: 'glossary',
     UnknownID: 'unknown',
 };
-
 export default ChapterIDs;

package/models/book/Definition.d.ts

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

package/models/book/Definition.js

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