bookish-press 0.4.0 → 0.4.3

package/models/Firebase.js

@@ -1,26 +1,36 @@
-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";
+import { initializeApp } from 'firebase/app';
+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';
+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: 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 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,
+    });
 export const auth = isReader ? undefined : getAuth();
 export const db = isReader ? undefined : getFirestore();
 export const storage = isReader ? undefined : getStorage();
-if (!isReader && import.meta.env.DEV) {
+export const functions = isReader ? undefined : getFunctions();
+if (!isReader && PUBLIC_CONTEXT === 'local') {
     if (db)
         connectFirestoreEmulator(db, 'localhost', 8080);
     if (auth)
-        connectAuthEmulator(auth, "http://localhost:9099");
+        connectAuthEmulator(auth, 'http://localhost:9099');
     if (storage)
-        connectStorageEmulator(storage, "localhost", 9199);
+        connectStorageEmulator(storage, 'localhost', 9199);
+    if (functions)
+        connectFunctionsEmulator(functions, 'localhost', 5001);
 }

package/models/book/Book.d.ts

@@ -1,60 +1,61 @@
-import type { DocumentReference } from "firebase/firestore";
-import BookMedia from "./BookMedia";
-import Edition, { BookSaveStatus } from "./Edition";
-export declare type Revision = {
+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 declare type BookSpecification = {
+export type BookSpecification = {
     title: string;
     authors: string[];
     description: string;
     cover: string | null;
-    revisions: Revision[];
-    domain?: string;
+    published: boolean;
+    editions: EditionInfo[];
+    domain: string | null;
     uids: string[];
+    readuids: string[];
 };
 export default class Book {
     readonly ref: DocumentReference;
-    readonly spec: BookSpecification;
-    edits: {
-        resolve: Function;
-        reject: Function;
-    }[];
-    lastEdit: number;
-    listeners: Set<Function>;
+    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, spec: BookSpecification);
-    saveEdits(): void;
+    constructor(ref: DocumentReference, title: string, authors: string[], description: string, cover: string | null, editions: EditionInfo[], domain: string | null, uids: string[]);
     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>;
+    static fromJSON(ref: DocumentReference, book: BookSpecification): Book;
+    toJSON(): BookSpecification;
+    getSubdomain(): string | null;
+    withSubdomain(domain: string): Book;
     getTitle(): string;
-    setTitle(title: string): Promise<void>;
+    withTitle(title: string): Book;
     getDescription(): string;
-    setDescription(description: string): Promise<void>;
+    withDescription(description: string): Book;
     getCover(): string | null;
-    setCover(cover: string | null): Promise<void>;
+    withCover(cover: string | null): Book;
     getAuthors(): string[];
-    setAuthors(authors: string[]): Promise<void>;
+    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;
-    getRevisions(): Revision[];
-    setRevisions(revisions: Revision[]): Promise<void>;
-    setEditionChangeSummary(summary: string, index: number): Promise<void> | undefined;
-    setPublished(published: boolean, revisionNumber: number): Promise<void> | undefined;
+    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;
-    updateMetadataFromEdition(edition: Edition): void;
 }

package/models/book/Book.js

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

package/models/book/BookMedia.d.ts

@@ -1,6 +1,6 @@
-import type { StorageReference } from "firebase/storage";
-import type Book from "./Book";
-export declare type Image = {
+import type { StorageReference } from 'firebase/storage';
+import type Book from './Book';
+export type Image = {
     url: string;
     ref: StorageReference;
 };

package/models/book/BookMedia.js

@@ -1,6 +1,6 @@
-import { deleteObject, getDownloadURL, listAll, ref, uploadBytes } from "firebase/storage";
+import { deleteObject, getDownloadURL, listAll, ref, uploadBytes, } from 'firebase/storage';
 import { v4 as uuidv4 } from 'uuid';
-import { storage } from "../Firebase";
+import { storage } from '../Firebase';
 export default class BookMedia {
     book;
     _images;
@@ -12,7 +12,7 @@ export default class BookMedia {
     notify(observer) {
         this.observers.add(observer);
         // Notify it right away!
-        this.getImages().then(images => observer(images));
+        this.getImages().then((images) => observer(images));
     }
     stopNotifying(observer) {
         this.observers.delete(observer);
@@ -21,13 +21,15 @@ export default class BookMedia {
     async getImages() {
         return this._images === undefined ? this.cacheImages() : this._images;
     }
-    getImagePath() { return `images/${this.book.getRefID()}/`; }
+    getImagePath() {
+        return `images/${this.book.getRefID()}/`;
+    }
     /** Get a listing of all of the images for the book. */
     async cacheImages() {
         if (storage === undefined)
             return [];
         // Find all the prefixes and items.
-        this._images = (await this.retrieveImages()).filter(image => image !== undefined);
+        this._images = (await this.retrieveImages()).filter((image) => image !== undefined);
         // Notify observers
         for (const observer of this.observers)
             observer(this._images.slice());
@@ -39,10 +41,12 @@ export default class BookMedia {
         // Create a reference under which you want to list
         const listRef = ref(storage, this.getImagePath());
         // Find all the prefixes and items.
-        return listAll(listRef)
-            .then((res) => Promise.all(res.items.map(itemRef => getDownloadURL(itemRef)
-            .then((url) => {
-            const image = { url: url, description: "", ref: itemRef };
+        return listAll(listRef).then((res) => Promise.all(res.items.map((itemRef) => getDownloadURL(itemRef).then((url) => {
+            const image = {
+                url: url,
+                description: '',
+                ref: itemRef,
+            };
             if (this._images !== undefined) {
                 this._images.push(image);
             }
@@ -51,9 +55,11 @@ export default class BookMedia {
     }
     getThumbnailURL(url, thumbnailRef, error, finished, attempt = 0) {
         getDownloadURL(thumbnailRef)
-            .then(thumbnail => finished(url, thumbnail))
+            .then((thumbnail) => finished(url, thumbnail))
             // Try again in a bit.
-            .catch(() => attempt > 10 ? error("Couldn't upload image") : setTimeout(() => this.getThumbnailURL(url, thumbnailRef, error, finished, attempt + 1), 250));
+            .catch(() => attempt > 25
+            ? error("Couldn't get the image URL. Connection issues?")
+            : setTimeout(() => this.getThumbnailURL(url, thumbnailRef, error, finished, attempt + 1), 250));
     }
     upload(file, progressHandler, errorHandler, finishedHandler) {
         progressHandler;
@@ -67,11 +73,11 @@ export default class BookMedia {
         uploadBytes(imageRef, file)
             .then((snapshot) => {
             getDownloadURL(snapshot.ref)
-                .then(url => {
+                .then((url) => {
                 // Give some time for the cloud function to create a thumbnail, then try to get it's URL.
                 setTimeout(() => this.getThumbnailURL(url, thumbnailRef, errorHandler, finishedHandler), 250);
             })
-                .catch(() => errorHandler("Unable to get image URL."));
+                .catch(() => errorHandler('Unable to get image URL.'));
         })
             .then(() => this.cacheImages());
         // This seems to be broken in Firebase right now. Switched above to a no-feedback approach.
@@ -83,14 +89,14 @@ export default class BookMedia {
         //     // https://firebase.google.com/docs/storage/web/handle-errors
         //     (error) => {
         //         console.error(error);
-        //         errorHandler( 
+        //         errorHandler(
         //             error.code === "storage/unauthorized" ? "Wrong permissions to upload" :
-        //             error.code === "storage/canceled" ? "Upload canceled" :                    
+        //             error.code === "storage/canceled" ? "Upload canceled" :
         //             error.code === "storage/quota-exceeded" ? "Storage limit reached" :
         //             error.code === "storage/unauthenticated" ? "Log in again to upload" :
         //             "Unknown upload error"
         //         )
-        //     }, 
+        //     },
     }
     async remove(image) {
         if (storage === undefined)

package/models/book/BookSaveStatus.d.ts

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

package/models/book/BookSaveStatus.js

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

package/models/book/Chapter.d.ts

@@ -1,7 +1,7 @@
-import type ChapterNode from "../chapter/ChapterNode";
-import type Edition from "./Edition";
-import type { DocumentReference } from "firebase/firestore";
-export declare type ChapterSpecification = {
+import type ChapterNode from '../chapter/ChapterNode';
+import type Edition from './Edition';
+import type { DocumentReference } from 'firebase/firestore';
+export type ChapterSpecification = {
     ref?: DocumentReference;
     id: string;
     title: string;
@@ -11,60 +11,71 @@ export declare type ChapterSpecification = {
     forthcoming: boolean;
     section?: string;
     text?: string;
+    uids: string[];
 };
-export declare type ChapterContent = {
+export type ChapterContent = {
     text: string;
 };
-export declare type Match = {
+export type Match = {
     left: string;
     match: string;
     right: string;
 };
 export default class Chapter {
-    readonly spec: ChapterSpecification;
-    edition: Edition;
-    ast: ChapterNode | undefined;
-    index: Record<string, Array<Match>> | undefined;
-    wordCount: number | undefined;
+    readonly ref: DocumentReference | undefined;
+    readonly id: string;
+    readonly title: string;
+    readonly authors: string[];
+    readonly image: string | null;
+    readonly numbered: boolean;
+    readonly forthcoming: boolean;
+    readonly section: string | undefined;
+    readonly text: string;
+    readonly uids: string[];
+    _ast: ChapterNode | undefined;
+    _index: Record<string, Array<Match>> | undefined;
+    _wordCount: number | undefined;
     edits: {
         resolve: Function;
         reject: Function;
     }[];
     lastEdit: number;
     listeners: Set<(text: string) => void>;
-    constructor(edition: Edition, spec: ChapterSpecification);
-    saveEdits(): void;
-    addListener(listener: (text: string) => void): void;
-    removeListener(listener: (text: string) => void): void;
-    notifyListeners(): void;
-    requestSave(): Promise<void>;
-    toObject(): any;
-    getBook(): Edition;
+    constructor(ref: DocumentReference | undefined, id: string, title: string, authors: string[], image: string | null, numbered: boolean, forthcoming: boolean, section: string | undefined, text: string, uids: string[]);
+    /**
+     * Convert a chapter spec and it's text into a chapter object.
+     * The spec may contain the text itself, but it may not, so we require it to be
+     * repeated here to guarantee its provided.
+     */
+    static fromJSON(spec: ChapterSpecification, text: string): Chapter;
+    toJSON(): ChapterSpecification;
     getRef(): DocumentReference<import("@firebase/firestore").DocumentData> | undefined;
-    getChapterID(): string;
-    setChapterID(id: string): Promise<void> | undefined;
+    withEditors(uids: string[]): Chapter;
+    withRef(ref: DocumentReference): Chapter;
+    withoutRef(): Chapter;
+    getID(): string;
+    withChapterID(id: string): Chapter;
     getSection(): string | undefined;
-    setSection(section: string): Promise<void> | undefined;
+    withSection(section: string): Chapter;
     isForthcoming(): boolean;
-    setForthcoming(forthcoming: boolean): Promise<void> | undefined;
+    asForthcoming(forthcoming: boolean): Chapter;
     isNumbered(): boolean;
-    setNumbered(numbered: boolean): Promise<void> | undefined;
-    getText(): string | undefined;
-    setText(text: string): void;
-    setAST(node: ChapterNode): Promise<void> | undefined;
-    addAuthor(name: string): Promise<void>;
+    asNumbered(numbered: boolean): Chapter;
+    isEditor(uid: string): boolean;
+    getText(): string;
+    withText(text: string): Chapter;
+    withAST(ast: ChapterNode): Chapter;
     getAuthors(): string[];
-    setAuthor(index: number, name: string): Promise<void> | undefined;
-    removeAuthor(index: number): Promise<void> | undefined;
+    withAuthor(name: string): Chapter;
+    withRenamedAuthor(index: number, name: string): Chapter;
+    withoutAuthor(index: number): Chapter;
     getTitle(): string;
-    setTitle(title: string): Promise<void> | undefined;
-    getPosition(): number | undefined;
-    move(increment: number): Promise<void>;
-    delete(): Promise<void>;
+    withTitle(title: string): Chapter;
     getImage(): string | null;
-    setImage(embed: string | null): Promise<void> | undefined;
-    getIndex(): Record<string, Match[]> | undefined;
-    getAST(): ChapterNode | undefined;
-    getReadingTime(): number | undefined;
-    computeIndex(): Record<string, Match[]> | undefined;
+    withImage(image: string | null): Chapter;
+    getAST(edition: Edition): ChapterNode;
+    getWordCount(edition: Edition): number;
+    getReadingTime(edition: Edition): number | undefined;
+    getIndex(edition: Edition): Record<string, Match[]>;
+    toString(): string;
 }