bookish-press 0.4.0

package/components/page/margins.js

@@ -0,0 +1,132 @@
+// Hides the outline if there's a left inset marginal that might overlap it.
+// This operates on the DOM directly, as scroll position isn't easily managed in React.
+export function hideOutlineIfObscured() {
+    // Get the outline's bounds.
+    let outline = document.getElementsByClassName("bookish-outline")[0];
+    // If there's no outline, don't bother.
+    if (!outline)
+        return;
+    // Set a threshold for hiding
+    let threshold = 100;
+    // If the outline isn't affixed to the footer
+    if (window.getComputedStyle(outline).getPropertyValue("left") !== "0px") {
+        let outlineRect = outline.getBoundingClientRect();
+        let overlapRect = undefined;
+        // Find the bottom-most left inset marginal within threshold of the outline.
+        Array.from(document.getElementsByClassName("bookish-marginal-left-inset")).forEach(el => {
+            let insetRect = el.getBoundingClientRect();
+            if (!(outlineRect.bottom < insetRect.top - threshold ||
+                outlineRect.top > insetRect.bottom + threshold))
+                overlapRect = insetRect;
+        });
+        // If it overlaps, reduce opacity by the proportion of the vertical distance between two rectangles and the height of the marginal.
+        if (overlapRect) {
+            let overlap = overlapRect;
+            let distance = outlineRect.bottom < overlap.top ? threshold :
+                outlineRect.bottom < overlap.top + threshold ? threshold - (outlineRect.bottom - overlap.top) :
+                    outlineRect.top > overlap.bottom - threshold ? threshold - (overlap.bottom - outlineRect.top) :
+                        outlineRect.top > overlap.bottom ? threshold :
+                            0;
+            let proportion = distance / threshold;
+            outline.style.opacity = "" + (proportion * proportion);
+        }
+        // Otherwise, remove the dimming.
+        else
+            outline.style.removeProperty("opacity");
+    }
+    // If it is, it's always visible.
+    else
+        outline.style.removeProperty("opacity");
+}
+// After each render of the chapter, we need to adjust the layout of marginals, which by default are floating from
+// their little spans within the body of the text. 
+//
+// We have to do two things:
+//
+// 1) Lay them out vertically so that they don't overlap.
+// 2) Lay them out horizontally, so they're all left aligned with each other on the right margin of the text.
+//
+// We only want to do this if the marginals are floating; we exclude any marginals that are
+// fixed in a fixed position.
+export function layoutMarginals() {
+    // Get the chapter DOM node, so we can calculate margins.
+    let chapter = document.getElementsByClassName("bookish-chapter-body")[0];
+    // If there's no chapter rendered yet, stop.
+    if (chapter === undefined)
+        return;
+    let book = document.getElementsByClassName("bookish")[0];
+    // This is the grid line we'll aline all marginals too horizontally.
+    let margin = chapter.getBoundingClientRect().width;
+    // This will track the current leading bottom edge for laying out marginals.
+    let currentBottom = null;
+    // Are there any marginal right inset images that might overlap?
+    let rightInsets = document.getElementsByClassName("bookish-marginal-right-inset");
+    const marginals = document.getElementsByClassName("bookish-marginal");
+    // Layout all of the marginals vertically to prevent overlaps.
+    Array.from(marginals).forEach((element) => {
+        const el = element;
+        if (el === null)
+            return;
+        if (window.getComputedStyle(el).getPropertyValue("position") !== "fixed") {
+            if (el.parentElement) {
+                let containingMarginal = el.parentElement.closest(".bookish-marginal");
+                // Get the bounds of this marginal so we know it's size.
+                let elementBounds = el.getBoundingClientRect();
+                // Get the bounds of this marginal's parent so we know it's vertical position.
+                let parentBounds = el.parentElement.getBoundingClientRect();
+                let parentTop = parentBounds.top + window.scrollY - (book.getBoundingClientRect().top + window.scrollY);
+                // If it's inside a marginal, position it below the marginal.
+                if (containingMarginal !== null && currentBottom) {
+                    el.style.left = "0";
+                    el.style.top = "" + (currentBottom - (containingMarginal.getBoundingClientRect().top + window.scrollY)) + "px";
+                    currentBottom = currentBottom + elementBounds.height;
+                }
+                else {
+                    // If we don't have a bottom yet, or the current above is above the parent's top,
+                    // then set the current bottom to the bottom of the parent.
+                    if (currentBottom === null || currentBottom < parentTop) {
+                        el.style.top = parentTop + "px";
+                        currentBottom = parentTop + elementBounds.height;
+                    }
+                    // Otherwise, put the marginal below the last marginal's bottom.
+                    else {
+                        el.style.top = currentBottom + "px";
+                        currentBottom = currentBottom + elementBounds.height;
+                    }
+                    // If there are any right insets, do any intersect with this marginal?
+                    // If so, move the marginal below them.
+                    if (rightInsets.length > 0) {
+                        Array.from(rightInsets).forEach(inset => {
+                            // Compute the global positions of the marginal and the potential inset.
+                            let insetBounds = inset.getBoundingClientRect();
+                            let insetTop = insetBounds.top + window.scrollY;
+                            let insetBottom = insetTop + insetBounds.height;
+                            let elementTop = el.getBoundingClientRect().top + window.scrollY;
+                            let elementBottom = elementTop + elementBounds.height;
+                            // If they overlap...
+                            if (currentBottom !== null) {
+                                if ((elementTop <= insetTop && elementBottom >= insetTop) ||
+                                    (elementTop <= insetBottom && elementBottom >= insetBottom) ||
+                                    (elementTop >= insetTop && elementBottom <= insetBottom)) {
+                                    // Calculate the new position based on the preferred position, minus the element's height (which was added above), plus the overlap between the inset and the marginal.
+                                    let newTop = currentBottom - elementBounds.height + (insetBottom - elementTop);
+                                    // Reposition the marginal.
+                                    el.style.top = newTop + "px";
+                                    // Update the new bottom.
+                                    currentBottom = newTop + elementBounds.height;
+                                }
+                            }
+                        });
+                    }
+                    // Reposition the marginal horizontally.
+                    el.style.left = "calc(2rem + " + margin + "px)";
+                }
+            }
+        }
+        // If it's fixed, remove any explicitly set inline values.
+        else {
+            el.style.removeProperty("top");
+            el.style.removeProperty("left");
+        }
+    });
+}

package/models/BookLoader.d.ts

@@ -0,0 +1,2 @@
+import Edition from './book/Edition';
+export default function loadBookFromURL(url: string): Promise<Edition>;

package/models/BookLoader.js

@@ -0,0 +1,67 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import Edition from './book/Edition';
+import schema from "../../schemas/book.json";
+// Returns a Promise that, given a URL to 
+//   1) a to a valid "book.json" (see /src/schemas/book.json for a validity spec),
+//   2) a "chapters" folder with .md files corresponding to the chapter IDs in the spec,
+// resolves to a Book object with all of the book data.
+// If any errors are encountered, throws an Error.
+export default async function loadBookFromURL(url) {
+    let specification = undefined;
+    // Fetch the JSON from the given URL
+    return fetch(url + "book.json")
+        // If there's a valid response, get the JSON
+        .then(response => {
+        // If it's a valid status, parse the text as JSON.
+        if (response.status >= 200 && response.status <= 299)
+            return response.json();
+        // Otherwise, throw an error with the request failure.
+        else
+            throw Error(response.statusText);
+    })
+        // If the JSON doesn't parse...
+        .catch(() => {
+        throw Error("The book.json file that we received doesn't appear to be a JSON-formatted document.");
+    })
+        // Validate the specification and then load its chapters...
+        .then((book) => {
+        // Validate the book schema before we get started.
+        const ajv = new Ajv({
+            strictTuples: false
+        });
+        addFormats(ajv);
+        // Did the specification have schema errors?
+        // Initialize the book as null and set the errors.
+        if (!ajv.validate(schema, book)) {
+            throw Error("The book specification has validation errors" +
+                (ajv.errors ?
+                    ": " + ajv.errors.map(error => url + error.instancePath + " " + error.message).join("\n") :
+                    "."));
+        }
+        // Remember the book spec
+        specification = book;
+        // Map all non-forthcoming chapters to a list of fetch promises
+        return Promise.all(specification.chapters.filter((chapter) => !chapter.forthcoming).map((chapter) => fetch(url + "chapters/" + chapter.id + ".md")
+            .then((response) => {
+            // If we got a reasonable response, process the chapter.
+            if (response.ok)
+                return response.text();
+            else
+                throw Error("Unable to load chapter named '" + chapter.id + "'. Make sure the chapter ID and chapter file name match.");
+        })
+            // Set the text field of the chapter object in the specification
+            .then((text) => {
+            chapter.text = text;
+        })
+            // If there's an error, set chapter text to null.
+            .catch(() => {
+            chapter.text = undefined;
+        })));
+    })
+        // After all the chapter loading promises are done, make the book.
+        .then(() => {
+        // Construct a Book object given the spec and chapter text
+        return new Edition(undefined, undefined, specification);
+    });
+}

package/models/Firebase.d.ts

@@ -0,0 +1,4 @@
+export declare const app: import("@firebase/app").FirebaseApp | undefined;
+export declare const auth: import("@firebase/auth").Auth | undefined;
+export declare const db: import("@firebase/firestore").Firestore | undefined;
+export declare const storage: import("@firebase/storage").FirebaseStorage | undefined;

package/models/Firebase.js

@@ -0,0 +1,26 @@
+import { initializeApp } from "firebase/app";
+import { connectAuthEmulator, getAuth } from "firebase/auth";
+import { connectFirestoreEmulator, getFirestore } from "firebase/firestore";
+import { connectStorageEmulator, getStorage } from "firebase/storage";
+const isReader = import.meta.env.VITE_READER === "true";
+// Initialize Firebase using the environment variables provided at build time.
+// Only do this if we have environment variables defined. (We won't in the standalone Reader).
+export const app = isReader ? undefined : initializeApp({
+    apiKey: import.meta.env.VITE_BOOKISH_FIREBASE_API_KEY,
+    authDomain: import.meta.env.VITE_BOOKISH_AUTH_DOMAIN,
+    projectId: import.meta.env.VITE_BOOKISH_PROJECT_ID,
+    storageBucket: import.meta.env.VITE_BOOKISH_STORAGE_BUCKET,
+    messagingSenderId: import.meta.env.VITE_BOOKISH_MESSAGING_SENDER_ID,
+    appId: import.meta.env.VITE_BOOKISH_APP_ID
+});
+export const auth = isReader ? undefined : getAuth();
+export const db = isReader ? undefined : getFirestore();
+export const storage = isReader ? undefined : getStorage();
+if (!isReader && import.meta.env.DEV) {
+    if (db)
+        connectFirestoreEmulator(db, 'localhost', 8080);
+    if (auth)
+        connectAuthEmulator(auth, "http://localhost:9099");
+    if (storage)
+        connectStorageEmulator(storage, "localhost", 9199);
+}

package/models/Firestore.d.ts

@@ -0,0 +1,22 @@
+import { DocumentReference } from "firebase/firestore";
+import Edition from "./book/Edition";
+import Book from "./book/Book";
+import type Chapter from "./book/Chapter";
+import type { ChapterContent } from "./book/Chapter";
+export declare const loadPublishedBooksFromFirestore: () => Promise<Book[]>;
+export declare const loadUsersBooksFromFirestore: (userID: string) => Promise<Book[] | null>;
+export declare const getBookFromIDOrName: (bookIDOrName: string) => Promise<Book | null>;
+export declare const loadBookFromFirestore: (bookID: string) => Promise<Book | null>;
+export declare const loadEditionFromFirestore: (book: Book, editionID: string) => Promise<Edition>;
+export declare const createBookInFirestore: (userID: string) => Promise<string>;
+export declare const addDraftInFirestore: (book: Book) => Promise<void>;
+export declare const publishDraftInFirestore: (book: Book, index: number, published: boolean) => Promise<void>;
+export declare const updateEditionInFirestore: (edition: Edition) => Promise<void>;
+export declare const deleteEditionInFirestore: (book: Book, index: number) => Promise<void>;
+export declare const updateBookInFirestore: (book: Book) => Promise<void>;
+export declare const addChapterInFirestore: (edition: DocumentReference, chapter: ChapterContent) => Promise<DocumentReference>;
+export declare const removeChapterFromEditionInFirestore: (chapter: Chapter) => Promise<void>;
+export declare const loadChapterTextFromFirestore: (chapter: DocumentReference) => Promise<ChapterContent>;
+export declare const updateChapterTextInFirestore: (edition: DocumentReference, chapter: DocumentReference, text: string) => Promise<void>;
+export declare const subdomainIsAvailable: (subdomain: string, book: Book) => Promise<boolean>;
+export declare const getBookIDFromBookName: (subdomain: string) => Promise<string>;

package/models/Firestore.js

@@ -0,0 +1,194 @@
+import { db } from "./Firebase";
+import { collection, getDocs, getDoc, setDoc, doc, addDoc, query, where, deleteDoc, DocumentReference } from "firebase/firestore";
+import Edition from "./book/Edition";
+import Book from "./book/Book";
+export const loadPublishedBooksFromFirestore = async () => {
+    if (!db)
+        throw Error("Can't retrieve books, not connected to the database.");
+    try {
+        const data = await getDocs(collection(db, "books"));
+        return data.docs.map(doc => new Book(doc.ref, doc.data())).filter(book => book.hasPublishedEdition());
+    }
+    catch {
+        throw Error("Couldn't load books, problem reading from the database.");
+    }
+};
+export const loadUsersBooksFromFirestore = async (userID) => {
+    if (!db)
+        throw Error("Can't retrieve user's books, not connected to Firebase.");
+    try {
+        const books = await getDocs(query(collection(db, "books"), where("uids", "array-contains", userID)));
+        return books.docs.map(doc => new Book(doc.ref, doc.data()));
+    }
+    catch (err) {
+        console.error(err);
+        return null;
+    }
+};
+export const getBookFromIDOrName = async (bookIDOrName) => {
+    const book = await loadBookFromFirestore(bookIDOrName);
+    if (book)
+        return book;
+    const bookID = await getBookIDFromBookName(bookIDOrName);
+    return loadBookFromFirestore(bookID);
+};
+export const loadBookFromFirestore = async (bookID) => {
+    if (!db)
+        return null;
+    const bookRef = doc(db, "books", bookID);
+    const book = await getDoc(bookRef);
+    return !book.exists() ? null : new Book(bookRef, book.data());
+};
+export const loadEditionFromFirestore = async (book, editionID) => {
+    if (!db)
+        throw Error("Can't retrieve edition, not connected to Firebase.");
+    const edition = await getDoc(doc(db, "editions", editionID));
+    if (edition.exists())
+        return new Edition(book, edition.ref, edition.data());
+    else
+        throw Error("" + editionID + " doesn't exist");
+};
+export const createBookInFirestore = async (userID) => {
+    if (!db)
+        throw Error("Can't create book, not connected to Firebase.");
+    // Make a new empty edition with a single chapter.
+    const newEdition = new Edition();
+    // Add the current user to the book
+    newEdition.addUserID(userID);
+    // Add the book to the editions collection
+    const editionRef = await addDoc(collection(db, "editions"), newEdition.toObject());
+    newEdition.setRef(editionRef);
+    // Add a new chapter to the edition and update it in the database.
+    await newEdition.addChapter();
+    await updateEditionInFirestore(newEdition);
+    // Note that we don't create a sub-collection of chapters here.
+    // Firestore creates sub-collections automatically when documents are added.
+    // Create a new book with the draft first edition and the user ID.
+    const newBook = {
+        title: "",
+        authors: [],
+        description: "",
+        cover: null,
+        revisions: [
+            {
+                ref: editionRef,
+                time: Date.now(),
+                summary: "",
+                published: false
+            }
+        ],
+        uids: [userID]
+    };
+    // Create the book
+    const bookRef = await addDoc(collection(db, "books"), newBook);
+    // Return the book id
+    return bookRef.id;
+};
+export const addDraftInFirestore = async (book) => {
+    if (!db)
+        throw Error("Can't publish draft, no Firebase connection.");
+    // Get the latest draft.
+    const latestDraft = await book.getDraftEdition();
+    if (latestDraft === undefined)
+        return;
+    // Create a copy of the existing draft as a new edition
+    const newDraft = await addDoc(collection(db, "editions"), latestDraft.toObject());
+    // Put the new edition in the book.
+    const revisions = book.getRevisions();
+    revisions.unshift({
+        ref: newDraft,
+        time: Date.now(),
+        summary: "",
+        published: false
+    });
+    book.setRevisions(revisions);
+    // Return the revised Book for viewing
+    updateBookInFirestore(book);
+};
+export const publishDraftInFirestore = async (book, index, published) => {
+    if (!db)
+        throw Error("Can't publish draft, no Firebase connection.");
+    // Update the edition's published status.
+    book.setPublished(published, index);
+    // Update the book with the latest published edition's metadata.
+    const draft = await book.getLatestPublishedEdition();
+    if (draft)
+        book.updateMetadataFromEdition(draft);
+    // Return the revised Book for viewing
+    updateBookInFirestore(book);
+};
+export const updateEditionInFirestore = async (edition) => {
+    if (!db)
+        throw Error("Can't update edition, not connected to Firebase.");
+    // Get the object for the edition so we can store it.
+    const spec = edition.toObject();
+    const editionRef = edition.getRef();
+    // Make sure the given edition has a database reference ID
+    if (!editionRef)
+        throw Error("Book given has no ID");
+    // Update the edition's document.
+    await setDoc(doc(db, "editions", editionRef.id), spec);
+    // Get the book of the editiion, and if the edition updated is the latest edition,
+    // update the book's cache of title, cover, authors, and description.
+    if (edition.book !== undefined && edition.isLatestPublishedEdition())
+        edition.book.updateMetadataFromEdition(edition);
+};
+export const deleteEditionInFirestore = async (book, index) => {
+    if (!db)
+        throw Error("Can't update edition, not connected to Firebase.");
+    const revisions = book.getRevisions();
+    if (index < 0 || index >= revisions.length)
+        return;
+    await deleteDoc(revisions[index].ref);
+    revisions.splice(index, 1);
+    book.setRevisions(revisions);
+    await updateBookInFirestore(book);
+};
+export const updateBookInFirestore = async (book) => {
+    if (!db)
+        throw Error("Can't update boo, not connected to Firebase.");
+    await setDoc(doc(db, "books", book.getRefID()), book.toObject());
+};
+export const addChapterInFirestore = async (edition, chapter) => {
+    if (!db)
+        throw Error("Can't add chapter, not connected to Firebase.");
+    return await addDoc(collection(db, `editions/${edition.id}/chapters`), chapter);
+};
+export const removeChapterFromEditionInFirestore = async (chapter) => {
+    if (!db)
+        throw Error("Can't add chapter, not connected to Firebase.");
+    const ref = chapter.getRef();
+    if (!ref)
+        throw Error("Can't delete chapter, it doesn't have a document ID.");
+    await deleteDoc(ref);
+};
+export const loadChapterTextFromFirestore = async (chapter) => {
+    if (!db)
+        throw Error("Not connected to Firebase.");
+    const text = await getDoc(chapter);
+    if (!text.exists())
+        throw Error("Chapter text does not exist.");
+    return text.data();
+};
+export const updateChapterTextInFirestore = async (edition, chapter, text) => {
+    if (!db)
+        throw Error("Can't update chapter, not connected to Firebase.");
+    // Get the object for the book so we can store it.
+    const spec = { text: text };
+    // Update the book's preview
+    await setDoc(doc(db, `editions/${edition.id}/chapters`, chapter.id), spec);
+};
+export const subdomainIsAvailable = async (subdomain, book) => {
+    if (!db)
+        throw Error("Not connected to Firebase.");
+    const matches = await getDocs(query(collection(db, "books"), where("domain", "==", subdomain)));
+    return matches.empty || matches.docs[0].id === book.getRefID();
+};
+export const getBookIDFromBookName = async (subdomain) => {
+    if (!db)
+        throw Error("Can't find book ID from URL, not connected to Firebase.");
+    const matches = await getDocs(query(collection(db, "books"), where("domain", "==", subdomain)));
+    if (!matches.empty)
+        return matches.docs[0].id;
+    throw Error("No book by this name.");
+};

package/models/book/Book.d.ts

@@ -0,0 +1,60 @@
+import type { DocumentReference } from "firebase/firestore";
+import BookMedia from "./BookMedia";
+import Edition, { BookSaveStatus } from "./Edition";
+export declare type Revision = {
+    ref: DocumentReference;
+    time: number;
+    summary: string;
+    published: boolean;
+};
+export declare type BookSpecification = {
+    title: string;
+    authors: string[];
+    description: string;
+    cover: string | null;
+    revisions: Revision[];
+    domain?: string;
+    uids: string[];
+};
+export default class Book {
+    readonly ref: DocumentReference;
+    readonly spec: BookSpecification;
+    edits: {
+        resolve: Function;
+        reject: Function;
+    }[];
+    lastEdit: number;
+    listeners: Set<Function>;
+    media: BookMedia;
+    constructor(ref: DocumentReference, spec: BookSpecification);
+    saveEdits(): void;
+    getMedia(): BookMedia;
+    requestSave(): Promise<void>;
+    addListener(listener: (status: BookSaveStatus) => void): void;
+    removeListener(listener: Function): void;
+    notifyListeners(status: BookSaveStatus): void;
+    toObject(): BookSpecification;
+    getSubdomain(): string | undefined;
+    setSubdomain(domain: string): Promise<void>;
+    getTitle(): string;
+    setTitle(title: string): Promise<void>;
+    getDescription(): string;
+    setDescription(description: string): Promise<void>;
+    getCover(): string | null;
+    setCover(cover: string | null): Promise<void>;
+    getAuthors(): string[];
+    setAuthors(authors: string[]): Promise<void>;
+    getRef(): DocumentReference<import("@firebase/firestore").DocumentData>;
+    getRefID(): string;
+    getDraftEdition(): undefined | Promise<Edition>;
+    isValidEditionNumber(edition: number): boolean;
+    getEditionNumber(number: number): Promise<Edition> | undefined;
+    getLatestPublishedEdition(): undefined | Promise<Edition>;
+    getLatestPublishedEditionID(): string | undefined;
+    getRevisions(): Revision[];
+    setRevisions(revisions: Revision[]): Promise<void>;
+    setEditionChangeSummary(summary: string, index: number): Promise<void> | undefined;
+    setPublished(published: boolean, revisionNumber: number): Promise<void> | undefined;
+    hasPublishedEdition(): boolean;
+    updateMetadataFromEdition(edition: Edition): void;
+}

package/models/book/Book.js

@@ -0,0 +1,135 @@
+import { loadEditionFromFirestore, updateBookInFirestore } from "../Firestore";
+import BookMedia from "./BookMedia";
+import Edition, { BookSaveStatus } from "./Edition";
+export default class Book {
+    ref;
+    spec;
+    // A list of requested edits, stored as promises, resolved
+    // when the book is ready to save.
+    edits = [];
+    lastEdit = 0;
+    listeners = new Set();
+    media;
+    constructor(ref, spec) {
+        this.ref = ref;
+        this.spec = spec;
+        this.media = new BookMedia(this);
+    }
+    saveEdits() {
+        // 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.notifyListeners(BookSaveStatus.Saving);
+            updateBookInFirestore(this)
+                .then(() => {
+                // Approve the edits.
+                this.edits.forEach(edit => edit.resolve());
+                this.notifyListeners(BookSaveStatus.Saved);
+            })
+                .catch(() => {
+                // Reject the edits.
+                this.edits.forEach(edit => edit.reject());
+                this.notifyListeners(BookSaveStatus.Error);
+            })
+                .finally(() => {
+                // Reset the edit queue.
+                this.edits = [];
+            });
+        }
+    }
+    getMedia() { return this.media; }
+    // 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 book model changed.
+        this.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;
+    }
+    addListener(listener) { this.listeners.add(listener); }
+    removeListener(listener) { this.listeners.delete(listener); }
+    notifyListeners(status) { this.listeners.forEach(listener => listener.call(undefined, status)); }
+    toObject() { return this.spec; }
+    getSubdomain() { return this.spec.domain; }
+    setSubdomain(domain) {
+        if (domain.length === 0)
+            delete this.spec.domain;
+        else
+            this.spec.domain = domain;
+        return this.requestSave();
+    }
+    getTitle() { return this.spec.title; }
+    setTitle(title) {
+        this.spec.title = title;
+        return this.requestSave();
+    }
+    getDescription() { return this.spec.description; }
+    setDescription(description) {
+        this.spec.description = description;
+        return this.requestSave();
+    }
+    getCover() { return this.spec.cover; }
+    setCover(cover) {
+        this.spec.cover = cover;
+        return this.requestSave();
+    }
+    getAuthors() { return this.spec.authors; }
+    setAuthors(authors) {
+        this.spec.authors = authors;
+        return this.requestSave();
+    }
+    getRef() { return this.ref; }
+    getRefID() { return this.ref.id; }
+    getDraftEdition() {
+        return this.spec.revisions.length === 0 ? undefined : loadEditionFromFirestore(this, this.spec.revisions[0].ref.id);
+    }
+    isValidEditionNumber(edition) {
+        return this.getEditionNumber(edition) !== undefined;
+    }
+    /* Note: editions are numbered 1-n, but stored in reverse chronological order. */
+    getEditionNumber(number) {
+        return number < 1 || number > this.spec.revisions.length ?
+            undefined :
+            loadEditionFromFirestore(this, this.spec.revisions[this.spec.revisions.length - number].ref.id);
+    }
+    getLatestPublishedEdition() {
+        const latest = this.getLatestPublishedEditionID();
+        return latest === undefined ? undefined : loadEditionFromFirestore(this, latest);
+    }
+    getLatestPublishedEditionID() {
+        return this.spec.revisions.find(e => e.published)?.ref.id;
+    }
+    getRevisions() { return this.spec.revisions.slice(); }
+    setRevisions(revisions) {
+        this.spec.revisions = revisions.slice();
+        return this.requestSave();
+    }
+    setEditionChangeSummary(summary, index) {
+        if (index >= 0 && index < this.spec.revisions.length) {
+            this.spec.revisions[index].summary = summary;
+            return this.requestSave();
+        }
+    }
+    setPublished(published, revisionNumber) {
+        if (revisionNumber >= 0 && revisionNumber < this.spec.revisions.length) {
+            this.spec.revisions[revisionNumber].published = published;
+            return this.requestSave();
+        }
+    }
+    hasPublishedEdition() {
+        return this.spec.revisions.find(revision => revision.published) !== undefined;
+    }
+    updateMetadataFromEdition(edition) {
+        this.setTitle(edition.getTitle());
+        this.setCover(edition.getImage("cover") ?? null);
+        this.setAuthors(edition.getAuthors());
+        this.setDescription(edition.getDescription());
+    }
+}