bookish-press 0.4.1 → 0.4.3

package/models/book/Chapter.js

@@ -1,221 +1,212 @@
-import Parser from "../chapter/Parser";
-import { BookSaveStatus } from "./Edition";
-import { loadChapterTextFromFirestore, updateChapterTextInFirestore } from "../Firestore";
+import Parser from '../chapter/Parser';
+import CommonWords from './Words';
 export default class Chapter {
-    // The metadata from the database.
-    spec;
-    edition;
-    // Caches
-    ast;
-    index;
-    wordCount;
+    // Inputs
+    ref;
+    id;
+    title;
+    authors;
+    image;
+    numbered;
+    forthcoming;
+    section;
+    text;
+    uids;
+    // Derived values
+    _ast = undefined;
+    _index = undefined;
+    _wordCount = undefined;
     // A list of requested edits, stored as promises, resolved
     // when the book is ready to save.
     edits = [];
     lastEdit = 0;
     // A set of listeners that are notified when the chapter text changes.
     listeners = new Set();
-    constructor(edition, spec) {
-        this.edition = edition;
+    constructor(ref, id, title, authors, image, numbered, forthcoming, section, text, uids) {
+        this.ref = ref;
+        this.id = id;
+        this.title = title;
+        this.authors = authors.slice();
+        this.image = image;
+        this.numbered = numbered;
+        this.forthcoming = forthcoming;
+        this.section = section;
+        this.text = text;
+        this.uids = uids;
+    }
+    /**
+     * 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, text) {
         // Copy the spec, filling in defaults as necessary.
-        this.spec = {
-            ref: spec.ref,
-            id: spec.id,
-            title: spec.title,
-            authors: spec.authors ?? [],
-            image: spec.image ?? null,
-            numbered: spec.numbered === true || spec.numbered === undefined,
-            forthcoming: spec.forthcoming === true,
-            text: spec.text
-        };
-        // If the chapter has text, then parse it, count searchable words, and compute an index.
-        if (this.spec.text !== undefined)
-            this.setText(this.spec.text);
-        else if (this.spec.ref) {
-            loadChapterTextFromFirestore(this.spec.ref).then(text => this.setText(text.text));
-        }
-        // Otherwise, set them all to undefined.
-        else {
-            this.ast = undefined;
-            this.wordCount = 0;
-            this.index = undefined;
-        }
-    }
-    saveEdits() {
-        if (this.edition.editionRef && this.spec.ref && this.spec.text !== undefined) {
-            // 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.edition.notifyListeners(BookSaveStatus.Saving);
-                updateChapterTextInFirestore(this.edition.editionRef, this.spec.ref, this.spec.text)
-                    .then(() => {
-                    // Approve the edits.
-                    this.edits.forEach(edit => edit.resolve());
-                    this.edition.notifyListeners(BookSaveStatus.Saved);
-                })
-                    .catch(() => {
-                    // Reject the edits.
-                    this.edits.forEach(edit => edit.reject());
-                    this.edition.notifyListeners(BookSaveStatus.Error);
-                })
-                    .finally(() => {
-                    // Reset the edit queue.
-                    this.edits = [];
-                });
-            }
-        }
+        return new Chapter(spec.ref, spec.id, spec.title, spec.authors ?? [], spec.image ?? null, spec.numbered === true || spec.numbered === undefined, spec.forthcoming === true, spec.section, spec.text ?? text, spec.uids);
     }
-    addListener(listener) { this.listeners.add(listener); }
-    removeListener(listener) { this.listeners.delete(listener); }
-    notifyListeners() {
-        this.listeners.forEach(listener => this.spec.text !== undefined ? listener.call(undefined, this.spec.text) : undefined);
-    }
-    // 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 chapter model changed.
-        this.edition.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;
-    }
-    toObject() {
-        // Deep copy to prevent external mutations.
-        const payload = JSON.parse(JSON.stringify(this.spec));
-        // Reassign a copy of the Firebase ref, since the deep copy doesn't work for it.
-        payload.ref = this.spec.ref;
+    toJSON() {
         // Note that we don't include the chapter text in the payload; that's stored in the chapters subcollection.
         // We just return the chapter metadata here, which is stored in the book collection.
-        delete payload.text;
-        return payload;
-    }
-    getBook() { return this.edition; }
-    getRef() { return this.spec.ref; }
-    getChapterID() { return this.spec.id; }
-    setChapterID(id) {
-        if (this.spec.id !== id) {
-            this.spec.id = id;
-            return this.edition.requestSave();
-        }
+        const json = {
+            id: this.id,
+            title: this.title,
+            authors: this.authors.slice(),
+            image: this.image,
+            numbered: this.numbered,
+            forthcoming: this.forthcoming,
+            uids: this.uids,
+        };
+        if (this.ref)
+            json.ref = this.ref;
+        if (this.section)
+            json.section = this.section;
+        return json;
     }
-    getSection() { return this.spec.section; }
-    setSection(section) {
-        if (this.spec.section !== section) {
-            this.spec.section = section;
-            return this.edition.requestSave();
-        }
+    getRef() {
+        return this.ref;
     }
-    isForthcoming() { return this.spec.forthcoming; }
-    setForthcoming(forthcoming) {
-        if (this.spec.forthcoming !== forthcoming) {
-            this.spec.forthcoming = forthcoming;
-            return this.edition.requestSave();
-        }
+    withEditors(uids) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, uids);
     }
-    isNumbered() { return this.spec.numbered; }
-    setNumbered(numbered) {
-        if (numbered !== this.spec.numbered) {
-            this.spec.numbered = numbered;
-            return this.edition.requestSave();
-        }
+    withRef(ref) {
+        return new Chapter(ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
     }
-    getText() { return this.spec.text; }
-    setText(text) {
-        this.setAST(Parser.parseChapter(this.edition, text));
-    }
-    setAST(node) {
-        this.ast = node;
-        const newText = this.ast.toBookdown();
-        const changed = this.spec.text !== newText;
-        this.spec.text = newText;
-        this.wordCount = this.ast.toText().split(/\s+/).length;
-        this.index = this.computeIndex();
-        // Don't save if its the same. This is just an optimization.
-        if (changed) {
-            this.notifyListeners();
-            if (this.edition.editionRef && this.spec.ref)
-                return this.requestSave();
-        }
+    withoutRef() {
+        return new Chapter(undefined, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
     }
-    addAuthor(name) {
-        this.spec.authors.push(name);
-        return this.edition.requestSave();
+    getID() {
+        return this.id;
     }
-    getAuthors() { return this.spec.authors; }
-    setAuthor(index, name) {
-        if (index >= 0 && index < this.spec.authors.length) {
-            this.spec.authors[index] = name;
-            return this.edition.requestSave();
-        }
+    withChapterID(id) {
+        return new Chapter(this.ref, id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
     }
-    removeAuthor(index) {
-        if (index >= 0 && index < this.spec.authors.length) {
-            this.spec.authors.splice(index, 1);
-            return this.edition.requestSave();
-        }
+    getSection() {
+        return this.section;
     }
-    getTitle() { return this.spec.title; }
-    setTitle(title) {
-        if (title !== this.spec.title) {
-            this.spec.title = title;
-            return this.edition.requestSave();
-        }
+    withSection(section) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, section, this.text, this.uids);
+    }
+    isForthcoming() {
+        return this.forthcoming;
+    }
+    asForthcoming(forthcoming) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, forthcoming, this.section, this.text, this.uids);
+    }
+    isNumbered() {
+        return this.numbered;
+    }
+    asNumbered(numbered) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    isEditor(uid) {
+        return this.uids.includes(uid);
+    }
+    getText() {
+        return this.text;
+    }
+    withText(text) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, text, this.uids);
+    }
+    withAST(ast) {
+        const newChapter = new Chapter(this.ref, this.id, this.title, this.authors, this.image, this.numbered, this.forthcoming, this.section, ast.toBookdown(), this.uids);
+        newChapter._ast = ast;
+        return newChapter;
+    }
+    getAuthors() {
+        return this.authors;
+    }
+    withAuthor(name) {
+        return new Chapter(this.ref, this.id, this.title, [...this.authors, name], this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    withRenamedAuthor(index, name) {
+        if (index < 0 || index >= this.authors.length)
+            return this;
+        return new Chapter(this.ref, this.id, this.title, [
+            ...this.authors.slice(0, index),
+            name,
+            ...this.authors.slice(index + 1),
+        ], this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    withoutAuthor(index) {
+        if (index < 0 || index >= this.authors.length)
+            return this;
+        return new Chapter(this.ref, this.id, this.title, [...this.authors.slice(0, index), ...this.authors.slice(index + 1)], this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getTitle() {
+        return this.title;
+    }
+    withTitle(title) {
+        return new Chapter(this.ref, this.id, title, this.authors, this.image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getImage() {
+        return this.image;
+    }
+    withImage(image) {
+        return new Chapter(this.ref, this.id, this.title, this.authors, image, this.numbered, this.forthcoming, this.section, this.text, this.uids);
+    }
+    getAST(edition) {
+        // Compute the cache if necessary
+        if (this._ast === undefined)
+            this._ast = Parser.parseChapter(edition, this.text);
+        return this._ast;
+    }
+    getWordCount(edition) {
+        if (this._wordCount === undefined)
+            this._wordCount = this.getAST(edition).toText().split(/\s+/).length;
+        return this._wordCount;
     }
-    getPosition() { return this.edition.getChapterPosition(this.getChapterID()); }
-    move(increment) { return this.edition.moveChapter(this.getChapterID(), increment); }
-    delete() { return this.edition.deleteChapter(this.getChapterID()); }
-    getImage() { return this.spec.image; }
-    setImage(embed) {
-        if (this.spec.image === embed)
-            return;
-        this.spec.image = embed;
-        return this.edition.requestSave();
-    }
-    getIndex() { return this.index; }
-    getAST() { return this.ast; }
     // Utility function
-    getReadingTime() { return this.isForthcoming() || !this.wordCount ? undefined : Math.max(1, Math.round(this.wordCount / 150)); }
-    computeIndex() {
-        if (!this.ast)
-            return;
-        // Build a list of common words
-        let commonWords = new Set();
-        ["a", "about", "all", "also", "and", "are", "as", "at", "be", "because", "but", "by", "can", "come", "could", "day", "do", "does", "even", "find", "first", "for", "from", "get", "give", "go", "has", "have", "he", "her", "here", "him", "his", "how", "I", "if", "in", "into", "is", "it", "its", "just", "know", "like", "look", "make", "man", "many", "me", "more", "my", "new", "no", "not", "now", "of", "on", "one", "only", "or", "other", "our", "out", "people", "say", "see", "she", "so", "some", "take", "tell", "than", "that", "the", "their", "them", "then", "there", "these", "they", "thing", "think", "this", "those", "time", "to", "two", "up", "use", "very", "want", "was", "way", "we", "well", "went", "what", "when", "which", "who", "will", "with", "would", "year", "yes", "you", "your"].forEach(word => commonWords.add(word));
-        // Get all the text in the chapter.
-        let text = this.ast.toText();
-        // Split by word boundaries.
-        const words = text.split(/\b/);
-        // Index the words
-        const index = {};
-        words.forEach((word, wordNumber) => {
-            // Skip non words. We keep them for search results.
-            if (!/[a-zA-Z\u2019]+/.test(word))
-                return;
-            word = word.toLowerCase();
-            // Should we include?
-            // • It shouldn't be a common word
-            // • It shouldn't have an apostrophe
-            // • It should be longer than two letters
-            // • It shouldn't end in 'ly'
-            if (!(commonWords.has(word)) && word.indexOf('\u2019') < 0 && (word.length > 2 && word.substring(word.length - 2, word.length) !== "ly")) {
-                // If we haven't started a list of occurrences, start one.
-                if (!(word in index))
-                    index[word] = [];
-                let match = {
-                    left: words.slice(Math.max(0, wordNumber - 10), Math.max(0, wordNumber - 1) + 1).join(""),
-                    match: words[wordNumber],
-                    right: words.slice(Math.min(words.length - 1, wordNumber + 1), Math.min(words.length - 1, wordNumber + 10) + 1).join("")
-                };
-                // Add the occurrence, but a lower case canonical version.
-                index[word.toLowerCase()].push(match);
-            }
-        });
-        return index;
+    getReadingTime(edition) {
+        return this.isForthcoming()
+            ? undefined
+            : Math.max(1, Math.round(this.getWordCount(edition) / 150));
+    }
+    getIndex(edition) {
+        if (this._index === undefined) {
+            const ast = this.getAST(edition);
+            // Build a list of common words
+            let commonWords = new Set();
+            CommonWords.forEach((word) => commonWords.add(word));
+            // Get all the text in the chapter.
+            let text = ast.toText();
+            // Split by word boundaries.
+            const words = text.split(/\b/);
+            // Index the words
+            const index = {};
+            words.forEach((word, wordNumber) => {
+                // Skip non words. We keep them for search results.
+                if (!/[a-zA-Z\u2019]+/.test(word))
+                    return;
+                word = word.toLowerCase();
+                // Should we include?
+                // • It shouldn't be a common word
+                // • It shouldn't have an apostrophe
+                // • It should be longer than two letters
+                // • It shouldn't end in 'ly'
+                if (!commonWords.has(word) &&
+                    word.indexOf('\u2019') < 0 &&
+                    word.length > 2 &&
+                    word.substring(word.length - 2, word.length) !== 'ly') {
+                    // If we haven't started a list of occurrences, start one.
+                    if (!(word in index))
+                        index[word] = [];
+                    let match = {
+                        left: words
+                            .slice(Math.max(0, wordNumber - 10), Math.max(0, wordNumber - 1) + 1)
+                            .join(''),
+                        match: words[wordNumber],
+                        right: words
+                            .slice(Math.min(words.length - 1, wordNumber + 1), Math.min(words.length - 1, wordNumber + 10) + 1)
+                            .join(''),
+                    };
+                    // Add the occurrence, but a lower case canonical version.
+                    index[word.toLowerCase()].push(match);
+                }
+            });
+            this._index = index;
+        }
+        return this._index;
+    }
+    toString() {
+        return `${this.title} by ${this.authors.join(', ')}: ${this.text.substring(0, 32)}}`;
     }
 }

package/models/book/ChapterID.js

@@ -1,10 +1,10 @@
 const ChapterIDs = {
-    TableOfContentsID: "",
-    ReferencesID: "references",
-    SearchID: "search",
-    MediaID: "media",
-    IndexID: "index",
-    GlossaryID: "glossary",
-    UnknownID: "unknown"
+    TableOfContentsID: '',
+    ReferencesID: 'references',
+    SearchID: 'search',
+    MediaID: 'media',
+    IndexID: 'index',
+    GlossaryID: 'glossary',
+    UnknownID: 'unknown',
 };
 export default ChapterIDs;

package/models/book/Definition.d.ts

@@ -1,4 +1,4 @@
-declare type Definition = {
+type Definition = {
     phrase: string;
     definition: string;
     synonyms?: string[];

package/models/book/Edition.d.ts

@@ -1,13 +1,19 @@
 import Chapter from './Chapter';
 import type { ChapterSpecification } from './Chapter';
-import EmbedNode from "../chapter/EmbedNode";
-import type ReferenceNode from "../chapter/ReferenceNode";
+import EmbedNode from '../chapter/EmbedNode';
+import Reference from './Reference';
 import type Theme from './Theme';
 import type Definition from './Definition.js';
-import type Book from './Book.js';
 import type { DocumentReference } from 'firebase/firestore';
-export declare type EditionSpecification = {
+import type Book from './Book';
+import type FormatNode from '../chapter/FormatNode';
+import type { EditionInfo } from './Book';
+export type EditionSpecification = {
+    bookRef: DocumentReference;
     title: string;
+    number: number;
+    summary: string;
+    published: number | null;
     authors: string[];
     images: Record<string, string | null>;
     description: string;
@@ -15,87 +21,104 @@ export declare type EditionSpecification = {
     license: string;
     acknowledgements: string;
     tags: string[];
-    revisions: [string, string][];
     sources: Record<string, string>;
     references: Record<string, string | string[]>;
     symbols: Record<string, string>;
     glossary: Record<string, Definition>;
     theme: Theme | null;
-    uids: Array<string>;
-    bookRef?: DocumentReference;
+    uids: string[];
+    chapteruids: string[];
+    active: Record<string, string>;
 };
-export declare enum BookSaveStatus {
-    Changed = 0,
-    Saving = 1,
-    Saved = 2,
-    Error = 3
-}
 export default class Edition {
-    readonly specification: EditionSpecification;
-    readonly book: Book | undefined;
-    editionRef: DocumentReference | undefined;
-    chapters: Chapter[];
-    chaptersByID: Record<string, Chapter | undefined>;
-    listeners: Set<Function>;
-    edits: {
-        resolve: Function;
-        reject: Function;
-    }[];
-    lastEdit: number;
-    constructor(book?: Book, editionRef?: DocumentReference, specification?: EditionSpecification);
-    setRef(ref: DocumentReference): void;
-    saveEdits(): Promise<void>;
-    getBook(): Book | undefined;
-    addListener(listener: (status: BookSaveStatus) => void): void;
-    removeListener(listener: Function): void;
-    notifyListeners(status: BookSaveStatus): void;
-    requestSave(): Promise<void>;
-    toObject(): any;
-    getRef(): DocumentReference<import("@firebase/firestore").DocumentData> | undefined;
-    addUserID(uid: string): void;
+    readonly bookRef: DocumentReference;
+    readonly editionRef: DocumentReference | undefined;
+    readonly uids: string[];
+    readonly title: string;
+    readonly authors: string[];
+    readonly number: number;
+    readonly summary: string;
+    readonly published: number | null;
+    readonly images: Record<string, string | null>;
+    readonly description: string;
+    readonly chapters: Chapter[];
+    readonly license: string;
+    readonly acknowledgements: string;
+    readonly tags: string[];
+    readonly sources: Record<string, string>;
+    readonly references: Record<string, Reference | FormatNode>;
+    readonly symbols: Record<string, string>;
+    readonly glossary: Record<string, Definition>;
+    readonly theme: Theme | null;
+    readonly active: Record<string, string>;
+    constructor(bookRef: DocumentReference, editionRef: DocumentReference | undefined, uids: string[], title: string, authors: string[], number: number, summary: string, published: number | null, images: Record<string, string | null>, description: string, chapters: Chapter[], license: string, acknowledgements: string, tags: string[], sources: Record<string, string>, references: Record<string, string | string[]> | Record<string, FormatNode | Reference>, symbols: Record<string, string>, glossary: Record<string, Definition>, theme: Theme | null, active: Record<string, string>);
+    static fromJSON(editionRef: DocumentReference | undefined, spec: EditionSpecification): Edition;
+    static parseReference(citationID: string, ref: string | string[], edition: Edition, short?: boolean): FormatNode | Reference;
+    toObject(): EditionSpecification;
+    getBookRef(): DocumentReference<import("@firebase/firestore").DocumentData>;
+    getEditionRef(): DocumentReference<import("@firebase/firestore").DocumentData> | undefined;
+    getChapterUIDS(): string[];
+    withRef(editionRef: DocumentReference | undefined): Edition;
     getTitle(): string;
-    setTitle(title: string): Promise<void>;
+    withTitle(title: string): Edition;
     getDescription(): string;
-    setDescription(text: string): Promise<void>;
+    setDescription(description: string): Edition;
     getAcknowledgements(): string;
-    setAcknowledgements(text: string): Promise<void>;
+    withAcknowledgements(acks: string): Edition;
+    withSummary(summary: string): Edition;
+    asPublished(published: boolean): Edition;
     getLicense(): string;
-    setLicense(text: string): Promise<void>;
+    setLicense(license: string): Edition;
     getChapters(): Chapter[];
     hasChapter(chapterID: string): boolean;
     getChapter(chapterID: string): Chapter | undefined;
+    getChapterByRef(ref: DocumentReference): Chapter | undefined;
     getChapterPosition(chapterID: string): number | undefined;
     getChapterCount(): number;
-    addChapter(): Promise<void>;
-    moveChapter(chapterID: string, increment: number): Promise<void>;
-    deleteChapter(chapterID: string): Promise<void>;
+    withChapters(chapters: Chapter[]): Edition;
+    withChapterText(text: [DocumentReference, string][]): Edition;
+    withRevisedChapter(previous: Chapter, edited: Chapter): Edition;
+    withoutRefs(): Edition;
+    withIncrementedEditionNumber(): Edition;
+    withNewChapter(): Edition;
+    withoutChapter(chapterID: string): Edition;
+    withMovedChapter(chapterID: string, increment: number): Edition;
     getSymbols(): Record<string, string>;
     hasReferences(): boolean;
-    getReferences(): Record<string, string | string[]>;
-    getReference(citationID: string): string | string[] | undefined;
-    addReferences(references: ReferenceNode[]): Promise<void>;
-    editReference(ref: ReferenceNode): Promise<void> | undefined;
-    editReferenceID(newCitationID: string, ref: ReferenceNode): Promise<void> | undefined;
-    removeReference(citationID: string): Promise<void> | undefined;
+    getReferences(): Record<string, FormatNode | Reference>;
+    getReference(citationID: string): FormatNode | Reference | undefined;
+    withReferences(newReferences: Record<string, FormatNode | Reference>): Edition;
+    withNewReferences(references: Reference[]): Edition;
+    withEditedReference(ref: Reference): Edition;
+    withEditedReferenceID(newCitationID: string, ref: Reference): Edition | undefined;
+    withoutReference(citationID: string): Edition;
     hasGlossary(): boolean;
     getGlossary(): Record<string, Definition>;
     hasDefinition(id: string): boolean;
-    addDefinition(id: string, phrase: string, definition: string, synonyms: string[]): Promise<void>;
-    removeDefinition(id: string): Promise<void>;
-    editDefinition(id: string, definition: Definition): Promise<void>;
-    editDefinitionID(id: string, newID: string): Promise<void> | undefined;
+    withGlossary(glossary: Record<string, Definition>): Edition;
+    withDefinition(id: string, phrase: string, definition: string, synonyms: string[]): Edition;
+    withoutDefinition(id: string): Edition;
+    withEditedDefinition(id: string, definition: Definition): Edition;
+    withEditedDefinitionID(id: string, newID: string): Edition | undefined;
     getTags(): string[];
     getTheme(): Theme | null;
-    setTheme(theme: Theme | null): Promise<void>;
-    setThemeValue(group: string, name: string, value: string): Promise<void> | undefined;
+    withTheme(theme: Theme | null): Edition;
+    withThemeValue(group: string, name: string, value: string): Edition;
     getAuthors(): string[];
-    addAuthor(name: string): Promise<void>;
-    setAuthor(index: number, name: string): Promise<void>;
-    removeAuthor(index: number): Promise<void>;
-    getRevisions(): [string, string][];
+    withAuthors(authors: string[]): Edition;
+    withAuthor(name: string): Edition;
+    withAuthorName(index: number, name: string): Edition;
+    withoutAuthor(index: number): Edition;
+    withEditors(uids: string[]): Edition;
     hasImage(id: string): boolean;
     getImage(id: string): string | null;
-    setImage(id: string, embed: string | null): Promise<void> | undefined;
+    withImage(id: string, embed: string | null): Edition;
+    isEditor(uid: string): boolean;
+    isChapterEditor(uid: string): boolean;
+    getLeasee(content: string): string | undefined;
+    hasLease(uid: string, content: string): boolean;
+    isLeased(contentID: string): boolean;
+    withLock(uid: string, content: string, lock: boolean): Edition;
     getBookReadingTime(): number | undefined;
     getChapterNumber(chapterID: string): undefined;
     getSource(sourceID: string): string | null;
@@ -106,6 +129,9 @@ export default class Edition {
     getNextChapterID(chapterID: string): string | null;
     getPreviousChapterID(chapterID: string): string | null;
     getEmbeds(): EmbedNode[];
-    isLatestPublishedEdition(): boolean;
-    getEditionNumber(): number | undefined;
+    isLatestEdition(book: Book): boolean;
+    isLatestPublishedEdition(book: Book): boolean;
+    getEditionNumber(): number;
+    getEditionLabel(): string;
+    getInfo(): EditionInfo | undefined;
 }