bookish-press 0.4.23 → 0.4.25

package/components/page/Unknown.svelte

@@ -3,14 +3,17 @@ 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>
 
 {#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
@@ -23,7 +26,7 @@ let edition = getEdition();
             <Outline slot="outline" previous={null} next={null} />
         </Header>
 
-        <Instructions>
+        <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>

package/models/CRUD.d.ts

@@ -1,17 +1,25 @@
 import { DocumentReference } from 'firebase/firestore';
 import Edition from './book/Edition';
 import Book from './book/Book';
-import type { ChapterContent } from './book/Chapter';
-export declare function getPublishedBooks(): Promise<Book[]>;
-export declare function getUserBooks(userID: string): Promise<Book[] | null>;
-export declare function getBookFromIDOrName(bookIDOrName: string): Promise<Book | null>;
-export declare function readBook(bookID: string): Promise<Book | null>;
-export declare function readEdition(editionID: string): Promise<Edition>;
-export declare const createBook: (userID: string) => Promise<string>;
+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 const updateEdition: (previousEdition: Edition | undefined, newEdition: Edition) => Promise<Edition>;
+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 readChapterText(chapterRef: DocumentReference): Promise<ChapterContent>;
 export declare function isSubdomainAvailable(subdomain: string, book: Book): Promise<boolean>;
-export declare function getBookIDFromName(subdomain: string): Promise<string | null>;
-export declare function publish(book: Book, index: number): Promise<string | undefined>;
+export declare function publish(edition: Edition): Promise<string | undefined>;

package/models/CRUD.js

@@ -1,146 +1,201 @@
 import { db, functions } from './Firebase';
-import { collection, getDocs, getDoc, setDoc, doc, addDoc, query, where, deleteDoc, DocumentReference, } from 'firebase/firestore';
-import { getFunctions, httpsCallable } from 'firebase/functions';
+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';
-export async function getPublishedBooks() {
-    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) => Book.fromJSON(doc.ref, doc.data()))
-            .filter((book) => book.hasPublishedEdition());
-    }
-    catch {
-        throw Error("Couldn't load books, problem reading from the database.");
-    }
+import Book, {} from './book/Book';
+function editionPath(bookID, editionID) {
+    return `books/${bookID}/editions/${editionID}`;
 }
-export async function getUserBooks(userID) {
+const NO_DATABASE_CONNECTION = 'Not connected to database';
+///////////////
+//// READ BOOKS
+///////////////
+function listenToBooks(constraint, react) {
     if (!db)
-        throw Error("Can't retrieve user's books, not connected to Firebase.");
+        throw NO_DATABASE_CONNECTION;
     try {
-        const books = await getDocs(query(collection(db, 'books'), where('uids', 'array-contains', userID)));
-        return books.docs.map((doc) => Book.fromJSON(doc.ref, doc.data()));
+        return onSnapshot(query(collection(db, 'books'), constraint), (snapshot) => react(snapshot.empty
+            ? []
+            : snapshot.docs.map((doc) => Book.fromJSON(doc.ref, doc.data()))));
     }
     catch (err) {
-        console.error(err);
-        return null;
+        throw 'Issue querying database';
     }
 }
-export async function getBookFromIDOrName(bookIDOrName) {
-    const book = await readBook(bookIDOrName);
-    if (book)
-        return book;
-    const bookID = await getBookIDFromName(bookIDOrName);
-    return bookID !== null ? readBook(bookID) : null;
+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 async function readBook(bookID) {
+export function listenToBooksByName(name, react) {
+    return listenToBooks(where('domain', '==', name), react);
+}
+export function listenToBookWithID(id, react) {
     if (!db)
-        return null;
-    const bookRef = doc(db, 'books', bookID);
-    const book = await getDoc(bookRef);
-    return !book.exists()
-        ? null
-        : Book.fromJSON(bookRef, book.data());
-}
-export async function readEdition(editionID) {
+        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 Error("Can't retrieve edition, not connected to Firebase.");
-    const editionDoc = await getDoc(doc(db, 'editions', editionID));
-    if (!editionDoc.exists())
-        throw Error('' + editionID + " doesn't exist");
-    // TODO We should really be doing some validation here.
-    let edition = editionDoc.data();
-    // Go through each of the edition's chapters and get its text.
-    for (const chapter of edition.chapters) {
-        if (chapter.ref) {
-            const { text } = await readChapterText(chapter.ref);
-            chapter.text = text;
-        }
-    }
-    return Edition.fromJSON(editionDoc.ref, edition);
+        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 const createBook = async (userID) => {
+export async function createBook(userID) {
     if (!db)
         throw Error("Can't create book, not connected to Firebase.");
-    // Make a new default edition with a single chapter with this user id.
-    let newEdition = new Edition(undefined, undefined, [userID], 'Untitled', [], {}, '', [], '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, 'editions'), newEdition.toObject());
-    // Remember the ref.
-    newEdition = newEdition.withRef(editionRef);
-    // 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: '',
+    // Create a new book
+    const newBookData = {
+        title: 'Untitled',
         authors: [],
         description: '',
         cover: null,
-        editions: [
-            {
-                ref: editionRef,
-                time: Date.now(),
-                summary: '',
-                published: false,
-            },
-        ],
+        published: false,
+        domain: null,
+        editions: [],
         uids: [userID],
+        readuids: [],
     };
     // Create the book
-    const bookRef = await addDoc(collection(db, 'books'), newBook);
+    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 latestDraft = await book.getDraftEdition();
+    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.
+    // 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, but without any chapter refs.
+    // Create a copy of the existing draft as a new edition.
     const newEditionRef = await addDoc(collection(db, 'editions'), newEdition.toObject());
-    // Update the edition, creating chapter text as necessary.
+    // 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.
-    const revisions = book.getEditions();
-    revisions.unshift({
-        ref: newEditionRef,
-        time: Date.now(),
-        summary: '',
-        published: false,
-    });
-    book = book.withRevisions(revisions);
-    // Return the revised Book's revision.'
+    book = book.withEditions([
+        newEdition.getInfo(),
+        ...book.getEditions(),
+    ]);
+    // Update the book.
     updateBook(book);
     return book;
 }
-export const updateEdition = async (previousEdition, newEdition) => {
+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.getRef();
+    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, `editions/${editionRef.id}/chapters`), { text: newChapter.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 if (previousEdition) {
-            const previousChapter = previousEdition.getChapterByRef(newChapter.ref);
-            if (previousChapter && newChapter.text !== previousChapter.text) {
-                await setDoc(doc(db, `editions/${editionRef.id}/chapters`, newChapter.ref.id), { text: newChapter.text });
+        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 });
             }
         }
     }
@@ -153,53 +208,53 @@ export const updateEdition = async (previousEdition, newEdition) => {
             }
         }
     }
+    // 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, 'editions', editionRef.id), newEdition.toObject());
-    return newEdition;
-};
+    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 readChapterText(chapterRef) {
-    if (!db)
-        throw Error('Not connected to Firebase.');
-    const text = await getDoc(chapterRef);
-    if (!text.exists())
-        throw Error('Chapter text does not exist.');
-    return text.data();
-}
 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 getBookIDFromName(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;
-    else
-        return null;
-}
-export async function publish(book, index) {
+export async function publish(edition) {
     if (!db)
-        throw Error("Can't publish, no Firebase connection.");
+        throw Error('Cannot publish, no database connection');
     if (!functions)
-        throw Error("Can't publish, no connection to Firebase functions.");
-    const edition = await book.getEditionNumber(index + 1);
-    if (edition === undefined)
-        return `Couldn't find edition ${index} number to publish`;
-    const editionRef = edition.getRef();
+        throw Error('Cannot publish, no cloud connection');
+    const editionRef = edition.getEditionRef();
+    const bookRef = edition.getBookRef();
     if (editionRef === undefined)
-        return `Couldn't find edition to publish`;
+        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({
-        book: book.getRef().id,
-        edition: editionRef.id,
+        bookID: bookRef.id,
+        editionID: editionRef.id,
     });
     return result.data;
     // Update the edition's published status in the book.

package/models/Firebase.js

@@ -3,24 +3,28 @@ import { connectAuthEmulator, getAuth } from 'firebase/auth';
 import { connectFirestoreEmulator, getFirestore } from 'firebase/firestore';
 import { connectFunctionsEmulator, getFunctions } from 'firebase/functions';
 import { connectStorageEmulator, getStorage } from 'firebase/storage';
-const isReader = import.meta.env.VITE_READER === 'true';
+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 (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: 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,
+        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 && import.meta.env.DEV) {
+if (!isReader && PUBLIC_CONTEXT === 'local') {
     if (db)
         connectFirestoreEmulator(db, 'localhost', 8080);
     if (auth)

package/models/book/Book.d.ts

@@ -1,20 +1,25 @@
 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;
-    time: number;
     summary: string;
-    published: boolean;
+    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;
+    domain: string | null;
     uids: string[];
+    readuids: string[];
 };
 export default class Book {
     readonly ref: DocumentReference;
@@ -22,15 +27,16 @@ export default class Book {
     readonly authors: string[];
     readonly description: string;
     readonly cover: string | null;
+    readonly published: boolean;
     readonly editions: EditionInfo[];
-    readonly domain: string | undefined;
+    readonly domain: string | null;
     readonly uids: string[];
     media: BookMedia;
-    constructor(ref: DocumentReference, title: string, authors: string[], description: string, cover: string | null, revisions: EditionInfo[], domain: string | undefined, uids: string[]);
+    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 | undefined;
+    getSubdomain(): string | null;
     withSubdomain(domain: string): Book;
     getTitle(): string;
     withTitle(title: string): Book;
@@ -42,15 +48,14 @@ export default class Book {
     withAuthors(authors: string[]): Book;
     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;
+    getEditionNumberID(number: number): string | undefined;
+    getLatestPublishedEditionID(): string;
     getLatestEditionID(): string | undefined;
     getEditions(): EditionInfo[];
-    withRevisions(revisions: EditionInfo[]): Book;
-    withEditionSummary(summary: string, index: number): Book;
-    withEditionAsPublished(published: boolean, editionNumber: number): Book;
+    getPublishedEditionCount(): number;
+    isEditor(uid: string): boolean;
+    withEditors(uids: string[]): Book;
+    withEditions(revisions: EditionInfo[]): Book;
+    withRevisedEdition(previous: Edition, revised: Edition): Book;
     hasPublishedEdition(): boolean;
 }