bookish-press 0.4.47 → 0.4.49

package/{src/lib/components/page/margins.ts → components/page/margins.js}

@@ -2,56 +2,46 @@
 // 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('outline')[0] as HTMLElement;
-
+    let outline = document.getElementsByClassName('outline')[0];
     // If there's no outline, don't bother.
-    if (!outline) return;
-
+    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: DOMRect | undefined = undefined;
-
+        let overlapRect = undefined;
         // Find the bottom-most left inset marginal within threshold of the outline.
-        Array.from(document.getElementsByClassName('inset-left')).forEach(
-            (el) => {
-                let insetRect: DOMRect = el.getBoundingClientRect();
-                if (
-                    !(
-                        outlineRect.bottom < insetRect.top - threshold ||
-                        outlineRect.top > insetRect.bottom + threshold
-                    )
-                )
-                    overlapRect = insetRect;
-            }
-        );
-
+        Array.from(document.getElementsByClassName('inset-left')).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: DOMRect = overlapRect;
-            let distance =
-                outlineRect.bottom < overlap.top
-                    ? threshold
-                    : outlineRect.bottom < overlap.top + threshold
+            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;
+                        ? 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');
+        else
+            outline.style.removeProperty('opacity');
     }
     // If it is, it's always visible.
-    else outline.style.removeProperty('opacity');
+    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.
 //
@@ -64,60 +54,45 @@ 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] as HTMLElement;
-
+    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] as HTMLElement;
-
+    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: number | null = null;
-
+    let currentBottom = null;
     // Are there any marginal right inset images that might overlap?
     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: Element) => {
-        const el = element as HTMLElement;
-
-        if (el === null) return;
-
-        if (
-            window.getComputedStyle(el).getPropertyValue('position') !== 'fixed'
-        ) {
+    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');
-
+                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 +
+                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 -
+                                (containingMarginal.getBoundingClientRect().top +
+                                    window.scrollY)) +
+                            'px';
                     currentBottom = currentBottom + elementBounds.height;
-                } else {
+                }
+                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) {
@@ -129,7 +104,6 @@ export function layoutMarginals() {
                         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) {
@@ -138,24 +112,18 @@ export function layoutMarginals() {
                             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;
-
+                            let elementTop = el.getBoundingClientRect().top + window.scrollY;
+                            let elementBottom = elementTop + elementBounds.height;
                             // If they overlap...
                             if (currentBottom !== null) {
-                                if (
-                                    (elementTop <= insetTop &&
-                                        elementBottom >= insetTop) ||
+                                if ((elementTop <= insetTop &&
+                                    elementBottom >= insetTop) ||
                                     (elementTop <= insetBottom &&
                                         elementBottom >= insetBottom) ||
                                     (elementTop >= insetTop &&
-                                        elementBottom <= insetBottom)
-                                ) {
+                                        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 -
+                                    let newTop = currentBottom -
                                         elementBounds.height +
                                         (insetBottom - elementTop);
                                     // Reposition the marginal.
@@ -167,7 +135,6 @@ export function layoutMarginals() {
                             }
                         });
                     }
-
                     // Reposition the marginal horizontally.
                     el.style.left = 'calc(2rem + ' + margin + 'px)';
                 }

package/index.d.ts

@@ -0,0 +1,15 @@
+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 Unknown } from "./components/page/Unknown.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 { default as 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, 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

@@ -0,0 +1,5 @@
+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;

package/{src/lib/models/Firebase.ts → models/Firebase.js}

@@ -3,44 +3,34 @@ import { connectAuthEmulator, getAuth } from 'firebase/auth';
 import { connectFirestoreEmulator, getFirestore } from 'firebase/firestore';
 import { connectFunctionsEmulator, getFunctions } from 'firebase/functions';
 import { connectStorageEmulator, getStorage } from 'firebase/storage';
-import {
-    PUBLIC_READER,
-    PUBLIC_CONTEXT,
-    PUBLIC_FIREBASE_API_KEY,
-    PUBLIC_FIREBASE_AUTH_DOMAIN,
-    PUBLIC_FIREBASE_PROJECT_ID,
-    PUBLIC_FIREBASE_STORAGE_BUCKET,
-    PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
-    PUBLIC_FIREBASE_APP_ID,
-} from '$env/static/public';
-
+import { PUBLIC_READER, PUBLIC_CONTEXT, PUBLIC_FIREBASE_API_KEY, PUBLIC_FIREBASE_AUTH_DOMAIN, PUBLIC_FIREBASE_PROJECT_ID, PUBLIC_FIREBASE_STORAGE_BUCKET, PUBLIC_FIREBASE_MESSAGING_SENDER_ID, PUBLIC_FIREBASE_APP_ID, } from '$env/static/public';
 const isReader = PUBLIC_READER === 'true';
-
 // Some feedback about context
 if (!isReader && PUBLIC_CONTEXT !== 'prod')
     console.log(`*** ${PUBLIC_CONTEXT.toLocaleUpperCase()} ***`);
-
 // 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: PUBLIC_FIREBASE_API_KEY,
-          authDomain: PUBLIC_FIREBASE_AUTH_DOMAIN,
-          projectId: PUBLIC_FIREBASE_PROJECT_ID,
-          storageBucket: PUBLIC_FIREBASE_STORAGE_BUCKET,
-          messagingSenderId: PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
-          appId: PUBLIC_FIREBASE_APP_ID,
-      });
-
+        apiKey: PUBLIC_FIREBASE_API_KEY,
+        authDomain: PUBLIC_FIREBASE_AUTH_DOMAIN,
+        projectId: PUBLIC_FIREBASE_PROJECT_ID,
+        storageBucket: PUBLIC_FIREBASE_STORAGE_BUCKET,
+        messagingSenderId: PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+        appId: PUBLIC_FIREBASE_APP_ID,
+    });
 export const auth = isReader ? undefined : getAuth();
 export const db = isReader ? undefined : getFirestore();
 export const storage = isReader ? undefined : getStorage();
 export const functions = isReader ? undefined : getFunctions();
-
 if (!isReader && PUBLIC_CONTEXT === 'local') {
-    if (db) connectFirestoreEmulator(db, 'localhost', 8080);
-    if (auth) connectAuthEmulator(auth, 'http://localhost:9099');
-    if (storage) connectStorageEmulator(storage, 'localhost', 9199);
-    if (functions) connectFunctionsEmulator(functions, 'localhost', 5001);
+    if (db)
+        connectFirestoreEmulator(db, 'localhost', 8080);
+    if (auth)
+        connectAuthEmulator(auth, 'http://localhost:9099');
+    if (storage)
+        connectStorageEmulator(storage, 'localhost', 9199);
+    if (functions)
+        connectFunctionsEmulator(functions, 'localhost', 5001);
 }

package/models/book/Book.d.ts

@@ -0,0 +1,61 @@
+import type { DocumentReference } from 'firebase/firestore';
+import BookMedia from './BookMedia';
+import type Edition from './Edition';
+/** A replication of edition info */
+export type EditionInfo = {
+    ref: DocumentReference;
+    summary: string;
+    number: number;
+    published: number | null;
+    editionuids: string[];
+    chapteruids: string[];
+};
+export type BookSpecification = {
+    title: string;
+    authors: string[];
+    description: string;
+    cover: string | null;
+    published: boolean;
+    editions: EditionInfo[];
+    domain: string | null;
+    uids: string[];
+    readuids: string[];
+};
+export default class Book {
+    readonly ref: DocumentReference;
+    readonly title: string;
+    readonly authors: string[];
+    readonly description: string;
+    readonly cover: string | null;
+    readonly published: boolean;
+    readonly editions: EditionInfo[];
+    readonly domain: string | null;
+    readonly uids: string[];
+    media: BookMedia;
+    constructor(ref: DocumentReference, title: string, authors: string[], description: string, cover: string | null, editions: EditionInfo[], domain: string | null, uids: string[]);
+    getMedia(): BookMedia;
+    static fromJSON(ref: DocumentReference, book: BookSpecification): Book;
+    toJSON(): BookSpecification;
+    getSubdomain(): string | null;
+    withSubdomain(domain: string): Book;
+    getTitle(): string;
+    withTitle(title: string): Book;
+    getDescription(): string;
+    withDescription(description: string): Book;
+    getCover(): string | null;
+    withCover(cover: string | null): Book;
+    getAuthors(): string[];
+    withAuthors(authors: string[]): Book;
+    getRef(): DocumentReference<import("@firebase/firestore").DocumentData>;
+    getRefID(): string;
+    getEditionNumberID(number: number): string | undefined;
+    getLatestPublishedEditionID(): string;
+    getLatestEditionID(): string | undefined;
+    getEditions(): EditionInfo[];
+    getPublishedEditionCount(): number;
+    isEditor(uid: string): boolean;
+    withEditors(uids: string[]): Book;
+    withEditions(revisions: EditionInfo[]): Book;
+    withRevisedEdition(previous: Edition, revised: Edition): Book;
+    hasPublishedEdition(): boolean;
+}