bookish-press 0.4.1 → 0.4.3

package/components/page/Title.svelte.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {typeof __propDef.props}  TitleProps */
+/** @typedef {typeof __propDef.events}  TitleEvents */
+/** @typedef {typeof __propDef.slots}  TitleSlots */
+export default class Title extends SvelteComponentTyped<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}> {
+}
+export type TitleProps = typeof __propDef.props;
+export type TitleEvents = typeof __propDef.events;
+export type TitleSlots = typeof __propDef.slots;
+import { SvelteComponentTyped } from "svelte";
+declare const __propDef: {
+    props: {
+        [x: string]: never;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export {};

package/components/page/Unknown.svelte

@@ -1,29 +1,36 @@
-<script>import Header from "./Header.svelte";
+<script>import Header from './Header.svelte';
 import Outline from './Outline.svelte';
 import Page from './Page.svelte';
 import Instructions from './Instructions.svelte';
 import ChapterIDs from '../../models/book/ChapterID';
-import { getEdition } from "./Contexts";
+import { getEdition, isEditionEditable } from './Contexts';
+let editable = isEditionEditable();
 let edition = getEdition();
 </script>
-<Page title={`${$edition.getTitle()} - Unknown Page`}>
-    <Header 
-        label="Unknown page title"
-        getImage={() => $edition.getImage(ChapterIDs.UnknownID)}
-        setImage={embed => $edition.setImage(ChapterIDs.UnknownID, embed)}
-        header="Oops."
-    >    
-        <Outline
-            slot="outline"
-            previous={null}
-            next={null}
-        />
-    </Header>
 
-    <Instructions>
-        This page will be shown if the reader somehow ends up on a page that doesn't exist.
-        You can customize the image shown.
-    </Instructions>
+{#if $edition}
+    <Page title={`${$edition.getTitle()} - Unknown Page`}>
+        <Header
+            editable={isEditionEditable()}
+            label="Unknown page title"
+            id="unknown"
+            getImage={() => $edition?.getImage(ChapterIDs.UnknownID) ?? null}
+            setImage={(embed) =>
+                $edition
+                    ? edition.set(
+                          $edition.withImage(ChapterIDs.UnknownID, embed)
+                      )
+                    : undefined}
+            header="Oops."
+        >
+            <Outline slot="outline" previous={null} next={null} />
+        </Header>
 
-    <slot></slot>
-</Page>
+        <Instructions {editable}>
+            This page will be shown if the reader somehow ends up on a page that
+            doesn't exist. You can customize the image shown.
+        </Instructions>
+
+        <slot />
+    </Page>
+{/if}

package/components/page/Unknown.svelte.d.ts

@@ -1,6 +1,6 @@
 import { SvelteComponentTyped } from "svelte";
 declare const __propDef: {
-    props: {};
+    props: Record<string, never>;
     events: {
         [evt: string]: CustomEvent<any>;
     };
@@ -8,9 +8,9 @@ declare const __propDef: {
         default: {};
     };
 };
-export declare type UnknownProps = typeof __propDef.props;
-export declare type UnknownEvents = typeof __propDef.events;
-export declare type UnknownSlots = typeof __propDef.slots;
+export type UnknownProps = typeof __propDef.props;
+export type UnknownEvents = typeof __propDef.events;
+export type UnknownSlots = typeof __propDef.slots;
 export default class Unknown extends SvelteComponentTyped<UnknownProps, UnknownEvents, UnknownSlots> {
 }
 export {};

package/components/page/margins.js

@@ -2,18 +2,18 @@
 // 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];
+    let outline = document.getElementsByClassName('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") {
+    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 => {
+        Array.from(document.getElementsByClassName('inset-left')).forEach((el) => {
             let insetRect = el.getBoundingClientRect();
             if (!(outlineRect.bottom < insetRect.top - threshold ||
                 outlineRect.top > insetRect.bottom + threshold))
@@ -22,24 +22,28 @@ export function hideOutlineIfObscured() {
         // 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 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);
+            outline.style.opacity = '' + proportion * proportion;
         }
         // Otherwise, remove the dimming.
         else
-            outline.style.removeProperty("opacity");
+            outline.style.removeProperty('opacity');
     }
     // If it is, it's always visible.
     else
-        outline.style.removeProperty("opacity");
+        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. 
+// their little spans within the body of the text.
 //
 // We have to do two things:
 //
@@ -50,53 +54,60 @@ export function hideOutlineIfObscured() {
 // 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];
+    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];
+    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");
+    let rightInsets = document.getElementsByClassName('inset-right');
+    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 (window.getComputedStyle(el).getPropertyValue('position') !== 'fixed') {
             if (el.parentElement) {
-                let containingMarginal = el.parentElement.closest(".bookish-marginal");
+                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);
+                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";
+                    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";
+                        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";
+                        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 => {
+                        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;
@@ -105,28 +116,34 @@ export function layoutMarginals() {
                             let elementBottom = elementTop + elementBounds.height;
                             // If they overlap...
                             if (currentBottom !== null) {
-                                if ((elementTop <= insetTop && elementBottom >= insetTop) ||
-                                    (elementTop <= insetBottom && elementBottom >= insetBottom) ||
-                                    (elementTop >= insetTop && elementBottom <= insetBottom)) {
+                                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);
+                                    let newTop = currentBottom -
+                                        elementBounds.height +
+                                        (insetBottom - elementTop);
                                     // Reposition the marginal.
-                                    el.style.top = newTop + "px";
+                                    el.style.top = newTop + 'px';
                                     // Update the new bottom.
-                                    currentBottom = newTop + elementBounds.height;
+                                    currentBottom =
+                                        newTop + elementBounds.height;
                                 }
                             }
                         });
                     }
                     // Reposition the marginal horizontally.
-                    el.style.left = "calc(2rem + " + margin + "px)";
+                    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");
+            el.style.removeProperty('top');
+            el.style.removeProperty('left');
         }
     });
 }

package/index.d.ts

@@ -0,0 +1,13 @@
+export { default as TableOfContents } from "./components/page/TableOfContents.svelte";
+export { default as Search } from "./components/page/Search.svelte";
+export { default as Index } from "./components/page/Index.svelte";
+export { default as References } from "./components/page/References.svelte";
+export { default as PossibleChapter } from "./components/page/PossibleChapter.svelte";
+export { default as Media } from "./components/page/Media.svelte";
+export { default as Print } from "./components/page/Print.svelte";
+export { default as Glossary } from "./components/page/Glossary.svelte";
+export { default as Edition } from "./components/page/Edition.svelte";
+export { default as Feedback } from "./components/app/Feedback.svelte";
+export { default as Loading } from "./components/page/Loading.svelte";
+export { default as EditionModel } from "./models/book/Edition";
+export { EDITION } from "./components/page/Contexts";

package/index.js

@@ -0,0 +1,14 @@
+export { default as TableOfContents } from './components/page/TableOfContents.svelte';
+export { default as Search } from './components/page/Search.svelte';
+export { default as Index } from './components/page/Index.svelte';
+export { default as References } from './components/page/References.svelte';
+export { default as PossibleChapter } from './components/page/PossibleChapter.svelte';
+export { default as Media } from './components/page/Media.svelte';
+export { default as Print } from './components/page/Print.svelte';
+export { default as Glossary } from './components/page/Glossary.svelte';
+export { default as Edition } from './components/page/Edition.svelte';
+export { default as Feedback } from './components/app/Feedback.svelte';
+export { default as Loading } from './components/page/Loading.svelte';
+export { default as EditionModel } from './models/book/Edition';
+export { EDITION } from './components/page/Contexts';
+export { Schema } from './models/book/Schema';

package/models/CRUD.d.ts

@@ -0,0 +1,27 @@
+import { DocumentReference } from 'firebase/firestore';
+import Edition from './book/Edition';
+import Book from './book/Book';
+import type { Unsubscribe } from 'firebase/auth';
+export declare function listenToPublishedBooks(react: (books: Book[]) => void): Unsubscribe;
+export declare function listenToEditableBooks(userID: string, react: (books: Book[]) => void): Unsubscribe;
+export declare function listenToPartiallyEditableBooks(userID: string, react: (books: Book[]) => void): Unsubscribe;
+export declare function listenToBooksByName(name: string, react: (book: Book[]) => void): Unsubscribe;
+export declare function listenToBookWithID(id: string, react: (book: Book | null) => void): Unsubscribe;
+export declare function listenToEdition(bookID: string, editionID: string, react: (edition: Edition | null) => void): Unsubscribe;
+export declare function listenToChapters(bookID: string, editionID: string, react: (chapters: [DocumentReference, string][]) => void): Unsubscribe;
+/** Hit the authentication database to get user emails. */
+export declare function getUserEmails(uids: string[]): Promise<Map<string, string> | null>;
+export declare function createUser(email: string): Promise<string | null>;
+export declare function createBook(userID: string): Promise<string>;
+export declare function createNewEdition(book: Book): Promise<Book>;
+export declare function updateLock(edition: Edition, uid: string, content: string, lock: boolean): Promise<boolean>;
+/**
+ * Persists the edition in the database, creating and deleting chapters as necessary.
+ * returns a map of DocumentReferences for new chapters so they can be persisted client side.
+ */
+export declare function updateEdition(previousEdition: Edition | undefined, newEdition: Edition): Promise<Map<string, DocumentReference>>;
+export declare function updateBook(book: Book): Promise<void>;
+export declare function isSubdomainAvailable(subdomain: string, book: Book): Promise<boolean>;
+export declare function publish(edition: Edition): Promise<string | {
+    url: string;
+}>;

package/models/CRUD.js

@@ -0,0 +1,262 @@
+import { db, functions } from './Firebase';
+import { collection, getDocs, getDoc, setDoc, doc, addDoc, query, where, deleteDoc, DocumentReference, onSnapshot, QueryFieldFilterConstraint, } from 'firebase/firestore';
+import { httpsCallable } from 'firebase/functions';
+import Edition from './book/Edition';
+import Book, {} from './book/Book';
+function editionPath(bookID, editionID) {
+    return `books/${bookID}/editions/${editionID}`;
+}
+const NO_DATABASE_CONNECTION = 'Not connected to database';
+///////////////
+//// READ BOOKS
+///////////////
+function listenToBooks(constraint, react) {
+    if (!db)
+        throw NO_DATABASE_CONNECTION;
+    try {
+        return onSnapshot(query(collection(db, 'books'), constraint), (snapshot) => react(snapshot.empty
+            ? []
+            : snapshot.docs.map((doc) => Book.fromJSON(doc.ref, doc.data()))));
+    }
+    catch (err) {
+        throw 'Issue querying database';
+    }
+}
+export function listenToPublishedBooks(react) {
+    return listenToBooks(where('published', '==', true), react);
+}
+export function listenToEditableBooks(userID, react) {
+    return listenToBooks(where('uids', 'array-contains', userID), react);
+}
+export function listenToPartiallyEditableBooks(userID, react) {
+    return listenToBooks(where('readuids', 'array-contains', userID), react);
+}
+export function listenToBooksByName(name, react) {
+    return listenToBooks(where('domain', '==', name), react);
+}
+export function listenToBookWithID(id, react) {
+    if (!db)
+        throw NO_DATABASE_CONNECTION;
+    const ref = doc(db, 'books', id);
+    return onSnapshot(doc(db, 'books', id), (doc) => {
+        if (!doc.metadata.hasPendingWrites)
+            react(doc.exists()
+                ? Book.fromJSON(ref, doc.data())
+                : null);
+    });
+}
+export function listenToEdition(bookID, editionID, react) {
+    if (!db)
+        throw NO_DATABASE_CONNECTION;
+    return onSnapshot(doc(db, 'books', bookID, 'editions', editionID), (doc) => {
+        if (!doc.metadata.hasPendingWrites)
+            react(doc.exists()
+                ? Edition.fromJSON(doc.ref, doc.data())
+                : null);
+    });
+}
+export function listenToChapters(bookID, editionID, react) {
+    if (!db)
+        throw NO_DATABASE_CONNECTION;
+    return onSnapshot(collection(db, 'books', bookID, 'editions', editionID, 'chapters'), (docs) => {
+        const chapters = [];
+        docs.forEach((doc) => {
+            chapters.push([doc.ref, doc.data().text]);
+        });
+        react(chapters);
+    });
+}
+/////////////////
+//// MANAGE USERS
+/////////////////
+/** Hit the authentication database to get user emails. */
+export async function getUserEmails(uids) {
+    if (!functions)
+        throw Error("Can't publish, no connection to Firebase functions.");
+    const getUserEmails = httpsCallable(functions, 'getUserEmails');
+    const result = await getUserEmails({
+        uids,
+    });
+    return new Map(Object.entries(result.data));
+}
+export async function createUser(email) {
+    if (!functions)
+        throw Error("Can't publish, no connection to Firebase functions.");
+    const createUserWithEmail = httpsCallable(functions, 'createUserWithEmail');
+    const result = await createUserWithEmail({
+        email,
+    });
+    return result.data;
+}
+export async function createBook(userID) {
+    if (!db)
+        throw Error("Can't create book, not connected to Firebase.");
+    // Create a new book
+    const newBookData = {
+        title: 'Untitled',
+        authors: [],
+        description: '',
+        cover: null,
+        published: false,
+        domain: null,
+        editions: [],
+        uids: [userID],
+        readuids: [],
+    };
+    // Create the book
+    const bookRef = await addDoc(collection(db, 'books'), newBookData);
+    // Create a model to store it.
+    let book = Book.fromJSON(bookRef, newBookData);
+    // Make a new default edition with a single chapter with this user id.
+    let newEdition = new Edition(bookRef, undefined, [], 'Untitled', [], 1, '', null, {}, '', [], 'All rights reserved.', '', [], {}, {}, {}, {}, null, {}).withNewChapter();
+    // Add the edition to the editions collection in the database so we can get an edition ref.
+    const editionRef = await addDoc(collection(db, 'books', bookRef.id, 'editions'), newEdition.toObject());
+    // Remember the ref.
+    newEdition = newEdition.withRef(editionRef);
+    // Now replicate the edition info in the book. We dodge type checking here because we know with certainty
+    // that the ref was just added the line before.
+    const info = newEdition.getInfo();
+    if (info)
+        book = book.withEditions([info]);
+    // Update the book with the edition info.
+    await updateBook(book);
+    // Update all of the changes to the edition in Firestore, persisting the refs and chapter text.
+    await updateEdition(undefined, newEdition);
+    // Return the book id
+    return bookRef.id;
+}
+export async function createNewEdition(book) {
+    if (!db)
+        throw Error("Can't publish draft, no Firebase connection.");
+    // Get the latest draft.
+    const latestEditionID = book.getLatestEditionID();
+    if (latestEditionID === undefined)
+        throw 'No editions on this book';
+    const latestDraftDoc = await getDoc(doc(db, 'books', book.ref.id, 'editions', latestEditionID));
+    const latestDraft = latestDraftDoc.exists()
+        ? latestDraftDoc.data()
+        : undefined;
+    if (latestDraft === undefined)
+        return book;
+    // Make a copy without chapter and edition refs, because we want to create new ones,
+    // and with an incremented edition number.
+    const newEdition = latestDraft.withoutRefs();
+    // Create a copy of the existing draft as a new edition.
+    const newEditionRef = await addDoc(collection(db, 'editions'), newEdition.toObject());
+    // Create the edition, creating chapter text as necessary, using the edition sync function.
+    updateEdition(undefined, newEdition.withRef(newEditionRef));
+    // Put the new edition in the book.
+    book = book.withEditions([
+        newEdition.getInfo(),
+        ...book.getEditions(),
+    ]);
+    // Update the book.
+    updateBook(book);
+    return book;
+}
+export async function updateLock(edition, uid, content, lock) {
+    if (!db)
+        throw NO_DATABASE_CONNECTION;
+    if (edition.editionRef === undefined)
+        return false;
+    if (lock && edition.hasLease(uid, content))
+        return true;
+    if (!lock && !edition.hasLease(uid, content))
+        return true;
+    await setDoc(doc(db, editionPath(edition.bookRef.id, edition.editionRef.id)), edition.withLock(uid, content, lock).toObject());
+    return lock;
+}
+/**
+ * Persists the edition in the database, creating and deleting chapters as necessary.
+ * returns a map of DocumentReferences for new chapters so they can be persisted client side.
+ */
+export async function updateEdition(previousEdition, newEdition) {
+    if (!db)
+        throw Error("Can't update edition, not connected to Firebase.");
+    // Get the reference to the edition, fail if we don't have one.
+    const editionRef = newEdition.getEditionRef();
+    if (!editionRef)
+        throw Error('Book given has no ID');
+    const newChapterRefs = new Map();
+    // Create any new chapters that aren't in the current edition, and update text if it changed.
+    for (const newChapter of newEdition.chapters) {
+        if (newChapter.ref === undefined) {
+            // Make the new chapter's text.
+            const newChapterRef = await addDoc(collection(db, editionPath(newEdition.bookRef.id, editionRef.id), 'chapters'), { text: newChapter.text });
+            // Add the ref of the new chapter to the revised chapter.
+            newEdition = newEdition.withRevisedChapter(newChapter, newChapter.withRef(newChapterRef));
+            // Map the chapter ref to it's id.
+            newChapterRefs.set(newChapter.id, newChapterRef);
+        }
+        // If we have a previous version, did the text change? If so, update it.
+        else {
+            const previousChapter = previousEdition === undefined
+                ? undefined
+                : previousEdition.getChapterByRef(newChapter.ref);
+            if (previousChapter === undefined ||
+                newChapter.text !== previousChapter.text) {
+                await setDoc(doc(db, editionPath(newEdition.bookRef.id, editionRef.id), 'chapters', newChapter.ref.id), { text: newChapter.text });
+            }
+        }
+    }
+    // Remove any chapters from Firebase that are removed.
+    if (previousEdition) {
+        for (const previousChapter of previousEdition.chapters) {
+            if (previousChapter.ref &&
+                newEdition.getChapterByRef(previousChapter.ref) === undefined) {
+                await deleteDoc(previousChapter.ref);
+            }
+        }
+    }
+    // If the edition's summary info changed, update it.
+    if (previousEdition !== undefined) {
+        const previousInfo = previousEdition.getInfo();
+        const newInfo = newEdition.getInfo();
+        if (previousInfo && newInfo) {
+            const previousKeys = Object.keys(previousInfo);
+            const newKeys = Object.keys(newInfo);
+            if (previousKeys.length !== newKeys.length ||
+                !previousKeys.every((key) => previousInfo[key] === newInfo[key])) {
+                const bookDoc = await getDoc(doc(db, 'books', newEdition.bookRef.id));
+                if (!bookDoc.exists())
+                    throw Error('Book does not exist');
+                const book = Book.fromJSON(newEdition.bookRef, bookDoc.data());
+                updateBook(book.withRevisedEdition(previousEdition, newEdition));
+            }
+        }
+    }
+    // Finally, update the edition's document.
+    await setDoc(doc(db, editionPath(newEdition.bookRef.id, editionRef.id)), newEdition.toObject());
+    return newChapterRefs;
+}
+export async function updateBook(book) {
+    if (!db)
+        throw Error("Can't update book, not connected to Firebase.");
+    await setDoc(doc(db, 'books', book.getRefID()), book.toJSON());
+}
+export async function isSubdomainAvailable(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 async function publish(edition) {
+    if (!db)
+        throw Error('Cannot publish, no database connection');
+    if (!functions)
+        throw Error('Cannot publish, no cloud connection');
+    const editionRef = edition.getEditionRef();
+    const bookRef = edition.getBookRef();
+    if (editionRef === undefined)
+        return `Cannot publish, no edition ID`;
+    // Get a reference to the publishing function
+    const publishEdition = httpsCallable(functions, 'publishEdition');
+    // Call the function, passing
+    const result = await publishEdition({
+        bookID: bookRef.id,
+        editionID: editionRef.id,
+    });
+    return result.data;
+    // Update the edition's published status in the book.
+    // await updateBook(book.withEditionAsPublished(true, index));
+}

package/models/Firebase.d.ts

@@ -2,3 +2,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;
+export declare const functions: import("@firebase/functions").Functions | undefined;