bookish-press 0.4.1 → 0.4.3

package/models/book/Edition.js

@@ -1,314 +1,417 @@
 import Chapter from './Chapter';
-import Parser from "../chapter/Parser";
-import EmbedNode from "../chapter/EmbedNode";
-import { addChapterInFirestore, removeChapterFromEditionInFirestore, updateEditionInFirestore } from "../Firestore";
+import Parser from '../chapter/Parser';
+import EmbedNode from '../chapter/EmbedNode';
+import Reference from './Reference';
 import ChapterIDs from './ChapterID.js';
-export 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 class Edition {
-    specification;
-    book;
+    bookRef;
     editionRef;
+    uids;
+    title;
+    authors;
+    number;
+    summary;
+    published;
+    images;
+    description;
     chapters;
-    chaptersByID;
-    listeners;
-    // A list of requested edits, stored as promises, resolved
-    // when the book is ready to save.
-    edits = [];
-    lastEdit = 0;
+    license;
+    acknowledgements;
+    tags;
+    sources;
+    references;
+    symbols;
+    glossary;
+    theme;
+    active;
     // Given an object with a valid specification and an object mapping chapter IDs to chapter text,
     // construct an object representing a book.
-    constructor(book, editionRef, specification) {
-        if (typeof specification !== "object" && specification !== undefined)
-            throw Error("Expected a book specification object, but received " + specification);
-        this.book = book;
+    constructor(bookRef, editionRef, uids, title, authors, number, summary, published, images, description, chapters, license, acknowledgements, tags, sources, references, symbols, glossary, theme, active) {
+        this.bookRef = bookRef;
         this.editionRef = editionRef;
-        // Copy all of the specification metadata to fields.
-        // Choose suitable defaults if the spec is lacking a field.
-        this.specification = {
-            title: specification ? specification.title : "Untitled",
-            symbols: specification && specification.symbols ? specification.symbols : {},
-            tags: specification && specification.tags ? specification.tags : [],
-            license: specification ? specification.license : "All rights reserved.",
-            references: specification && specification.references ? specification.references : {},
-            glossary: specification && specification.glossary ? specification.glossary : {},
-            authors: specification && specification.authors ? specification.authors : [],
-            description: specification ? specification.description : "",
-            acknowledgements: specification && specification.acknowledgements ? specification.acknowledgements : "",
-            revisions: specification && specification.revisions ? specification.revisions : [],
-            images: specification && specification.revisions ? specification.images : {},
-            sources: specification && specification.revisions ? specification.sources : {},
-            theme: specification && specification.theme ? specification.theme : null,
-            uids: specification && specification.uids ? specification.uids : [],
-            chapters: specification && specification.chapters ? specification.chapters : []
-        };
-        // No listeners yet
-        this.listeners = new Set();
-        // Create a list and dictionary of Chapter objects.
-        this.chapters = [];
-        this.chaptersByID = {};
-        // If there's a spec and it has chapters, process them.
-        if (this.specification.chapters.length > 0) {
-            // Initialize the chapters dictionary since parsing depends this index to detect whether a chapter exists.
-            this.specification.chapters.forEach(chapterSpec => this.chaptersByID[chapterSpec.id] = undefined);
-            this.specification.chapters.forEach(chapterSpec => {
-                const chap = new Chapter(this, chapterSpec);
-                this.chaptersByID[chapterSpec.id] = chap;
-                this.chapters.push(chap);
-            });
+        this.uids = uids;
+        this.title = title;
+        this.authors = authors;
+        this.number = number;
+        this.summary = summary;
+        this.published = published;
+        this.images = images;
+        this.description = description;
+        this.chapters = chapters.slice();
+        this.license = license;
+        this.acknowledgements = acknowledgements;
+        this.tags = tags.slice();
+        this.sources = Object.assign({}, sources);
+        this.references = {};
+        for (const [citationID, ref] of Object.entries(references)) {
+            this.references[citationID] =
+                ref instanceof Reference
+                    ? ref
+                    : Edition.parseReference(citationID, ref, this);
         }
+        this.symbols = Object.assign({}, symbols);
+        this.glossary = Object.assign({}, glossary);
+        this.theme = theme;
+        this.active = active;
     }
-    setRef(ref) {
-        if (this.editionRef)
-            throw Error("Can only set a ref of an edition when not yet set.");
-        this.editionRef = ref;
-    }
-    async 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);
-            return updateEditionInFirestore(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 = [];
-            });
+    static fromJSON(editionRef, spec) {
+        // Copy all of the specification metadata to fields.
+        // Choose suitable defaults if the spec is lacking a field.
+        return new Edition(spec.bookRef, editionRef, spec.uids, spec.title, spec.authors, spec.number, spec.summary, spec.published, spec.images, spec.description, spec.chapters.map((chap) => Chapter.fromJSON(chap, '')), spec.license, spec.acknowledgements, spec.tags, spec.sources, spec.references, spec.symbols, spec.glossary, spec.theme, spec.active);
+    }
+    static parseReference(citationID, ref, edition, short = false) {
+        if (typeof ref === 'string')
+            return Parser.parseFormat(edition, ref);
+        else {
+            // APA Format. Could eventually support multiple formats.
+            let [authors, year, title, source, url, summary] = ref;
+            if (source.charAt(0) === '#') {
+                let src = edition.getSource(source);
+                if (src !== null)
+                    source = src;
+            }
+            return new Reference(citationID, authors ?? '', year ?? '', title ?? '', source ?? '', url ?? '', summary ?? '', short);
         }
     }
-    getBook() { return this.book; }
-    addListener(listener) { this.listeners.add(listener); }
-    removeListener(listener) { this.listeners.delete(listener); }
-    notifyListeners(status) { this.listeners.forEach(listener => listener.call(undefined, status)); }
-    // 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;
-    }
     // Convert the book to an object for storage.
     toObject() {
-        // Deep copy, then let the chapter models handle the chapters.
-        const spec = JSON.parse(JSON.stringify(this.specification));
-        spec.chapters = this.chapters.map(chapter => chapter.toObject());
-        return spec;
-    }
-    getRef() { return this.editionRef; }
-    addUserID(uid) {
-        this.specification.uids.push(uid);
-    }
-    getTitle() { return this.specification.title; }
-    setTitle(title) {
-        // Update locally, then update on the server.
-        this.specification.title = title;
-        return this.requestSave();
-    }
-    getDescription() { return this.specification.description; }
-    setDescription(text) {
-        // Update locally, then update on the server.
-        this.specification.description = text;
-        return this.requestSave();
-    }
-    getAcknowledgements() { return this.specification.acknowledgements; }
-    setAcknowledgements(text) {
-        // Update locally, then update on the server.
-        this.specification.acknowledgements = text;
-        return this.requestSave();
-    }
-    getLicense() { return this.specification.license; }
-    setLicense(text) {
-        // Update locally, then update on the server.
-        this.specification.license = text;
-        return this.requestSave();
-    }
-    getChapters() { return this.chapters; }
-    hasChapter(chapterID) { return chapterID in this.chaptersByID || ["references", "glossary", "index", "search", "media"].includes(chapterID); }
-    getChapter(chapterID) { return this.hasChapter(chapterID) ? this.chaptersByID[chapterID] : undefined; }
+        const references = {};
+        for (const [citationID, ref] of Object.entries(this.references))
+            references[citationID] =
+                ref instanceof Reference ? ref.toList() : ref.toBookdown();
+        const editionJSON = {
+            bookRef: this.bookRef,
+            title: this.title,
+            authors: this.authors,
+            number: this.number,
+            summary: this.summary,
+            published: this.published,
+            images: Object.assign({}, this.images),
+            description: this.description,
+            chapters: this.chapters.map((chap) => chap.toJSON()),
+            license: this.license,
+            acknowledgements: this.acknowledgements,
+            tags: this.tags.slice(),
+            sources: Object.assign({}, this.sources),
+            references: references,
+            symbols: Object.assign({}, this.symbols),
+            glossary: Object.assign({}, this.glossary),
+            theme: this.theme,
+            uids: this.uids.slice(),
+            chapteruids: this.getChapterUIDS(),
+            active: this.active,
+        };
+        return editionJSON;
+    }
+    getBookRef() {
+        return this.bookRef;
+    }
+    getEditionRef() {
+        return this.editionRef;
+    }
+    getChapterUIDS() {
+        return Array.from(new Set(this.chapters.map((chapter) => chapter.uids).flat()));
+    }
+    withRef(editionRef) {
+        return new Edition(this.bookRef, editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    getTitle() {
+        return this.title;
+    }
+    withTitle(title) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    getDescription() {
+        return this.description;
+    }
+    setDescription(description) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    getAcknowledgements() {
+        return this.acknowledgements;
+    }
+    withAcknowledgements(acks) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, acks, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    withSummary(summary) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    asPublished(published) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, published ? Date.now() : null, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    getLicense() {
+        return this.license;
+    }
+    setLicense(license) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    getChapters() {
+        return this.chapters.slice();
+    }
+    hasChapter(chapterID) {
+        return (this.getChapter(chapterID) !== undefined ||
+            ['references', 'glossary', 'index', 'search', 'media'].includes(chapterID));
+    }
+    getChapter(chapterID) {
+        return this.chapters.find((chapter) => chapter.getID() === chapterID);
+    }
+    getChapterByRef(ref) {
+        return this.chapters.find((chap) => chap.ref !== undefined && chap.ref.id === ref.id);
+    }
     getChapterPosition(chapterID) {
         var position = 0;
         for (; position < this.chapters.length; position++)
-            if (this.chapters[position].getChapterID() === chapterID)
+            if (this.chapters[position].getID() === chapterID)
                 return position;
         return undefined;
     }
-    getChapterCount() { return this.chapters.length; }
-    async addChapter() {
-        if (!this.editionRef)
-            throw Error("No edition ID, can't add chapter");
-        const editionID = this.editionRef;
+    getChapterCount() {
+        return this.chapters.length;
+    }
+    withChapters(chapters) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    withChapterText(text) {
+        return this.withChapters(this.chapters.map((chapter) => {
+            if (chapter.ref === undefined)
+                return chapter;
+            const match = text.find(([ref, text]) => chapter.ref !== undefined &&
+                chapter.ref.id === ref.id &&
+                chapter.text !== text &&
+                text !== undefined);
+            return match ? chapter.withText(match[1]) : chapter;
+        }));
+    }
+    withRevisedChapter(previous, edited) {
+        const index = this.chapters.indexOf(previous);
+        if (index < 0)
+            return this;
+        return this.withChapters([
+            ...this.chapters.slice(0, index),
+            edited,
+            ...this.chapters.slice(index + 1),
+        ]);
+    }
+    withoutRefs() {
+        return this.withRef(undefined).withChapters(this.chapters.map((chap) => chap.withoutRef()));
+    }
+    withIncrementedEditionNumber() {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number + 1, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    withNewChapter() {
         // Synthesize a chapter ID placeholder that doesn't overlap with existing chapter names
         let number = 1;
-        while (this.hasChapter("chapter" + number))
+        while (this.hasChapter('chapter' + number))
             number++;
-        const chapterRef = await addChapterInFirestore(editionID, { text: "" });
         // Create a default chapter on this model. Remember the document reference so we can modify it later.
-        const emptyChapter = {
-            ref: chapterRef,
-            id: `chapter${number}`,
-            title: "Untitled Chapter",
-            authors: [],
-            numbered: true,
-            forthcoming: true,
-            image: null
-        };
-        const chap = new Chapter(this, emptyChapter);
-        this.chapters.push(chap);
-        this.chaptersByID[emptyChapter.id] = chap;
-        // Ask the database to create the chapter, returning the promise
-        this.requestSave();
+        const newChapter = new Chapter(undefined, `chapter${number}`, 'Untitled Chapter', [], null, true, false, undefined, '', []);
+        return this.withChapters([...this.chapters, newChapter]);
     }
-    moveChapter(chapterID, increment) {
-        // Get the index of the chapter.
-        let index = this.chapters.findIndex(chapter => chapter.getChapterID() === chapterID);
-        if (index < 0)
-            throw Error(`Chapter with ID ${chapterID} doesn't exist, can't move it.`);
-        else if (index + increment < 0)
-            throw Error(`Can't move this chapter ${increment} chapters earlier.`);
-        else if (index + increment >= this.chapters.length)
-            throw Error(`Can't move this chapter ${increment} chapters later.`);
-        const temp = this.chapters[index + increment];
-        this.chapters[index + increment] = this.chapters[index];
-        this.chapters[index] = temp;
-        // Ask the database to update with this new order.
-        return this.requestSave();
-    }
-    async deleteChapter(chapterID) {
-        let index = this.chapters.findIndex(chapter => chapter.getChapterID() === chapterID);
+    withoutChapter(chapterID) {
+        let index = this.chapters.findIndex((chapter) => chapter.getID() === chapterID);
         if (index < 0)
-            throw Error(`Chapter with ID ${chapterID} doesn't exist, can't delete it.`);
-        const chapter = this.chapters[index];
-        this.chapters.splice(index, 1);
-        // Ask the database to update the new book metadata then delete the chapter.
-        return this.requestSave().then(() => removeChapterFromEditionInFirestore(chapter));
-    }
-    getSymbols() { return this.specification.symbols; }
-    hasReferences() { return this.specification.references && Object.keys(this.specification.references).length > 0; }
-    getReferences() { return this.specification.references; }
-    getReference(citationID) { return citationID in this.specification.references ? this.specification.references[citationID] : undefined; }
-    addReferences(references) {
-        // Generate a unique ID for the reference.
-        references.forEach(ref => this.specification.references[ref.citationID] = ref.toList());
-        return this.requestSave();
+            return this;
+        return this.withChapters([
+            ...this.chapters.slice(0, index),
+            ...this.chapters.slice(index + 1),
+        ]);
     }
-    editReference(ref) {
-        if (!(ref.citationID in this.specification.references))
+    withMovedChapter(chapterID, increment) {
+        // Get the index of the chapter.
+        let index = this.chapters.findIndex((chapter) => chapter.getID() === chapterID);
+        if (index + increment < 0 || index + increment >= this.chapters.length)
+            return this;
+        const newChapters = this.chapters.slice();
+        const temp = newChapters[index + increment];
+        newChapters[index + increment] = newChapters[index];
+        newChapters[index] = temp;
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, newChapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    getSymbols() {
+        return this.symbols;
+    }
+    hasReferences() {
+        return Object.keys(this.references).length > 0;
+    }
+    getReferences() {
+        return Object.assign({}, this.references);
+    }
+    getReference(citationID) {
+        return citationID in this.references
+            ? this.references[citationID]
+            : undefined;
+    }
+    withReferences(newReferences) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, newReferences, this.symbols, this.glossary, this.theme, this.active);
+    }
+    withNewReferences(references) {
+        const newReferences = Object.assign({}, this.references);
+        // Generate a unique ID for the reference.
+        for (const newRef of references)
+            newReferences[newRef.citationID] = newRef;
+        return this.withReferences(newReferences);
+    }
+    withEditedReference(ref) {
+        if (!(ref.citationID in this.references))
+            return this;
+        const newReferences = Object.assign({}, this.references);
+        newReferences[ref.citationID] = ref;
+        return this.withReferences(newReferences);
+    }
+    withEditedReferenceID(newCitationID, ref) {
+        if (!(ref.citationID in this.references))
             return;
-        this.specification.references[ref.citationID] = ref.toList();
-        return this.requestSave();
+        const newReferences = Object.assign({}, this.references);
+        delete newReferences[ref.citationID];
+        newReferences[newCitationID] = ref.withCitationID(newCitationID);
+        return this.withReferences(newReferences);
     }
-    editReferenceID(newCitationID, ref) {
-        if (!(ref.citationID in this.specification.references))
-            return;
-        delete this.specification.references[ref.citationID];
-        this.specification.references[newCitationID] = ref.withCitationID(newCitationID).toList();
-        return this.requestSave();
+    withoutReference(citationID) {
+        if (!(citationID in this.references))
+            return this;
+        const newReferences = Object.assign({}, this.references);
+        delete newReferences[citationID];
+        return this.withReferences(newReferences);
     }
-    removeReference(citationID) {
-        if (!(citationID in this.specification.references))
-            return;
-        delete this.specification.references[citationID];
-        return this.requestSave();
-    }
-    hasGlossary() { return this.specification.glossary && Object.keys(this.specification.glossary).length > 0; }
-    getGlossary() { return this.specification.glossary; }
-    hasDefinition(id) { return id in this.specification.glossary; }
-    addDefinition(id, phrase, definition, synonyms) {
-        this.specification.glossary[id] = {
+    hasGlossary() {
+        return Object.keys(this.glossary).length > 0;
+    }
+    getGlossary() {
+        return Object.assign({}, this.glossary);
+    }
+    hasDefinition(id) {
+        return id in this.glossary;
+    }
+    withGlossary(glossary) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, glossary, this.theme, this.active);
+    }
+    withDefinition(id, phrase, definition, synonyms) {
+        const newGlossary = Object.assign({}, this.glossary);
+        newGlossary[id] = {
             phrase: phrase,
             definition: definition,
-            synonyms: synonyms
+            synonyms: synonyms,
         };
-        return this.requestSave();
+        return this.withGlossary(newGlossary);
     }
-    removeDefinition(id) {
-        delete this.specification.glossary[id];
-        return this.requestSave();
+    withoutDefinition(id) {
+        const newGlossary = Object.assign({}, this.glossary);
+        delete newGlossary[id];
+        return this.withGlossary(newGlossary);
     }
-    editDefinition(id, definition) {
-        this.specification.glossary[id] = definition;
-        return this.requestSave();
+    withEditedDefinition(id, definition) {
+        const newGlossary = Object.assign({}, this.glossary);
+        newGlossary[id] = definition;
+        return this.withGlossary(newGlossary);
     }
-    editDefinitionID(id, newID) {
-        if (!(id in this.specification.glossary))
-            return;
-        const definition = this.specification.glossary[id];
-        delete this.specification.glossary[id];
-        this.specification.glossary[newID] = definition;
-        return this.requestSave();
-    }
-    getTags() { return this.specification.tags; }
-    getTheme() { return this.specification.theme; }
-    setTheme(theme) {
-        this.specification.theme = theme;
-        return this.requestSave();
-    }
-    setThemeValue(group, name, value) {
-        if (this.specification.theme[group][name] === value)
+    withEditedDefinitionID(id, newID) {
+        if (!(id in this.glossary))
             return;
-        this.specification.theme[group][name] = value;
-        return this.requestSave();
+        const newGlossary = Object.assign({}, this.glossary);
+        const definition = newGlossary[id];
+        delete newGlossary[id];
+        newGlossary[newID] = definition;
+        return this.withGlossary(newGlossary);
+    }
+    getTags() {
+        return this.tags;
+    }
+    getTheme() {
+        return this.theme;
+    }
+    withTheme(theme) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, theme, this.active);
+    }
+    withThemeValue(group, name, value) {
+        if (this.theme === null)
+            return this;
+        if (group === 'imports')
+            return this;
+        const newTheme = Object.assign({}, this.theme);
+        const newGroup = Object.assign({}, this.theme[group]);
+        newGroup[name] = value;
+        newTheme[group] = newGroup;
+        return this.withTheme(newTheme);
     }
     // Don't let callers get their sneaky hands on this mutable array...
-    getAuthors() { return [...this.specification.authors]; }
-    addAuthor(name) {
-        this.specification.authors.push(name);
-        return this.requestSave();
-    }
-    setAuthor(index, name) {
-        if (index >= 0 && index < this.specification.authors.length)
-            this.specification.authors[index] = name;
-        return this.requestSave();
-    }
-    removeAuthor(index) {
-        if (index >= 0 && index < this.specification.authors.length)
-            this.specification.authors.splice(index, 1);
-        return this.requestSave();
-    }
-    getRevisions() { return [...this.specification.revisions]; }
-    hasImage(id) { return id in this.specification.images && this.specification.images[id] !== null; }
-    getImage(id) { return this.specification.images[id] ?? null; }
-    setImage(id, embed) {
-        if (this.specification.images[id] === embed)
-            return;
-        this.specification.images[id] = embed ?? null;
-        return this.requestSave();
+    getAuthors() {
+        return [...this.authors];
+    }
+    withAuthors(authors) {
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    withAuthor(name) {
+        return this.withAuthors([...this.authors, name]);
+    }
+    withAuthorName(index, name) {
+        if (index < 0 || index >= this.authors.length)
+            return this;
+        return this.withAuthors([
+            ...this.authors.slice(0, index),
+            name,
+            ...this.authors.slice(index + 1),
+        ]);
+    }
+    withoutAuthor(index) {
+        if (index < 0 || index >= this.authors.length)
+            return this;
+        return this.withAuthors([
+            ...this.authors.slice(0, index),
+            ...this.authors.slice(index + 1),
+        ]);
+    }
+    withEditors(uids) {
+        return new Edition(this.bookRef, this.editionRef, uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    hasImage(id) {
+        return this.images[id] !== null;
+    }
+    getImage(id) {
+        return this.images[id] ?? null;
+    }
+    withImage(id, embed) {
+        const newImages = Object.assign({}, this.images);
+        newImages[id] = embed;
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, newImages, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, this.active);
+    }
+    isEditor(uid) {
+        return this.uids.includes(uid);
+    }
+    isChapterEditor(uid) {
+        return this.getChapterUIDS().includes(uid);
+    }
+    getLeasee(content) {
+        return this.active[content];
+    }
+    hasLease(uid, content) {
+        return this.active[content] === uid;
+    }
+    isLeased(contentID) {
+        return contentID in this.active;
+    }
+    withLock(uid, content, lock) {
+        const newActive = Object.assign({}, this.active);
+        if (lock)
+            newActive[content] = uid;
+        else
+            delete newActive[content];
+        return new Edition(this.bookRef, this.editionRef, this.uids, this.title, this.authors, this.number, this.summary, this.published, this.images, this.description, this.chapters, this.license, this.acknowledgements, this.tags, this.sources, this.references, this.symbols, this.glossary, this.theme, newActive);
     }
     getBookReadingTime() {
         return this.chapters
-            .map(chapter => chapter.getReadingTime())
-            .reduce((total, time) => total === undefined ? 0 :
-            time === undefined ?
-                total : total + time, 0);
+            .map((chapter) => chapter.getReadingTime(this))
+            .reduce((total, time) => total === undefined
+            ? 0
+            : time === undefined
+                ? total
+                : total + time, 0);
     }
     getChapterNumber(chapterID) {
         let chapterNumber = 1;
         let match = null;
-        this.chapters.forEach(chapter => {
+        this.chapters.forEach((chapter) => {
             // If we found a match...
-            if (chapter.getChapterID() === chapterID) {
+            if (chapter.getID() === chapterID) {
                 match = chapterNumber;
                 // And it's an unnumbered chapter, set to null.
                 if (!chapter.isNumbered())
@@ -325,37 +428,39 @@ export default class Edition {
             return undefined;
     }
     getSource(sourceID) {
-        return sourceID.charAt(0) === "#" && sourceID.substring(1) in this.specification.sources ?
-            this.specification.sources[sourceID.substring(1)] :
-            null;
+        return sourceID.charAt(0) === '#' &&
+            sourceID.substring(1) in this.sources
+            ? this.sources[sourceID.substring(1)]
+            : null;
     }
     getChapterName(chapterID) {
         const chapter = this.getChapter(chapterID);
         return chapter?.getTitle();
     }
     getChapterSection(chapterID) {
-        const chapter = this.chaptersByID[chapterID];
+        const chapter = this.getChapter(chapterID);
         return chapter?.getSection();
     }
     getFootnoteSymbol(number) {
-        let symbols = "abcdefghijklmnopqrstuvwxyz";
+        let symbols = 'abcdefghijklmnopqrstuvwxyz';
         // Let's hope there are never more than 26^2 footnotes in a single chapter...
-        return number < symbols.length ?
-            symbols.charAt(number) :
-            symbols.charAt(Math.floor(number / symbols.length) - 1) + symbols.charAt(number % symbols.length);
+        return number < symbols.length
+            ? symbols.charAt(number)
+            : symbols.charAt(Math.floor(number / symbols.length) - 1) +
+                symbols.charAt(number % symbols.length);
     }
     getBookIndex() {
         // A map from word to a map of chapters containing the word
         const bookIndex = {};
         // Construct the index by building a dictionary of chapters in which each word appears.
-        this.chapters.forEach(chapter => {
-            let index = chapter.getIndex();
+        this.chapters.forEach((chapter) => {
+            let index = chapter.getIndex(this);
             if (index)
-                Object.keys(index).forEach(word => {
-                    if (word !== "" && word.length > 2) {
+                Object.keys(index).forEach((word) => {
+                    if (word !== '' && word.length > 2) {
                         if (!(word in bookIndex))
                             bookIndex[word] = new Set();
-                        bookIndex[word].add(chapter.getChapterID());
+                        bookIndex[word].add(chapter.getID());
                     }
                 });
         });
@@ -365,25 +470,39 @@ export default class Edition {
     getNextChapterID(chapterID) {
         // Handle back matter chapters.
         switch (chapterID) {
-            case ChapterIDs.ReferencesID: return this.hasGlossary() ? ChapterIDs.GlossaryID : ChapterIDs.IndexID;
-            case ChapterIDs.GlossaryID: return ChapterIDs.IndexID;
-            case ChapterIDs.IndexID: return ChapterIDs.SearchID;
-            case ChapterIDs.SearchID: return ChapterIDs.MediaID;
-            case ChapterIDs.MediaID: return ChapterIDs.TableOfContentsID;
-            case ChapterIDs.TableOfContentsID: return this.chapters.length > 0 ? this.chapters[0].getChapterID() : null;
+            case ChapterIDs.ReferencesID:
+                return this.hasGlossary()
+                    ? ChapterIDs.GlossaryID
+                    : ChapterIDs.IndexID;
+            case ChapterIDs.GlossaryID:
+                return ChapterIDs.IndexID;
+            case ChapterIDs.IndexID:
+                return ChapterIDs.SearchID;
+            case ChapterIDs.SearchID:
+                return ChapterIDs.MediaID;
+            case ChapterIDs.MediaID:
+                return ChapterIDs.TableOfContentsID;
+            case ChapterIDs.TableOfContentsID:
+                return this.chapters.length > 0
+                    ? this.chapters[0].getID()
+                    : null;
             default:
                 let after = false;
                 for (let i = 0; i < this.chapters.length; i++) {
                     let chapter = this.chapters[i];
-                    if (chapter.getChapterID() === chapterID)
+                    if (chapter.getID() === chapterID)
                         after = true;
                     // If we're after the given chapter and it's not forthcoming.
                     else if (after && !chapter.isForthcoming())
-                        return chapter.getChapterID();
+                        return chapter.getID();
                 }
                 // If the given ID was the last chapter, go to the next back matter chapter.
                 if (after)
-                    return this.hasReferences() ? ChapterIDs.ReferencesID : this.hasGlossary() ? ChapterIDs.GlossaryID : ChapterIDs.IndexID;
+                    return this.hasReferences()
+                        ? ChapterIDs.ReferencesID
+                        : this.hasGlossary()
+                            ? ChapterIDs.GlossaryID
+                            : ChapterIDs.IndexID;
                 // Otherwise, it wasn't a valid ID
                 else
                     return null;
@@ -393,20 +512,37 @@ export default class Edition {
     getPreviousChapterID(chapterID) {
         switch (chapterID) {
             // Handle back matter chapters.
-            case ChapterIDs.ReferencesID: return this.chapters.length > 0 ? this.chapters[this.chapters.length - 1].getChapterID() : null; // Last chapter of the book
-            case ChapterIDs.GlossaryID: return this.hasReferences() ? ChapterIDs.ReferencesID : this.chapters.length > 0 ? this.chapters[this.chapters.length - 1].getChapterID() : ChapterIDs.TableOfContentsID;
-            case ChapterIDs.IndexID: return this.hasGlossary() ? ChapterIDs.GlossaryID : this.hasReferences() ? ChapterIDs.ReferencesID : this.chapters.length > 0 ? this.chapters[this.chapters.length - 1].getChapterID() : ChapterIDs.TableOfContentsID;
-            case ChapterIDs.SearchID: return ChapterIDs.IndexID;
-            case ChapterIDs.MediaID: return ChapterIDs.SearchID;
+            case ChapterIDs.ReferencesID:
+                return this.chapters.length > 0
+                    ? this.chapters[this.chapters.length - 1].getID()
+                    : null; // Last chapter of the book
+            case ChapterIDs.GlossaryID:
+                return this.hasReferences()
+                    ? ChapterIDs.ReferencesID
+                    : this.chapters.length > 0
+                        ? this.chapters[this.chapters.length - 1].getID()
+                        : ChapterIDs.TableOfContentsID;
+            case ChapterIDs.IndexID:
+                return this.hasGlossary()
+                    ? ChapterIDs.GlossaryID
+                    : this.hasReferences()
+                        ? ChapterIDs.ReferencesID
+                        : this.chapters.length > 0
+                            ? this.chapters[this.chapters.length - 1].getID()
+                            : ChapterIDs.TableOfContentsID;
+            case ChapterIDs.SearchID:
+                return ChapterIDs.IndexID;
+            case ChapterIDs.MediaID:
+                return ChapterIDs.SearchID;
             default:
                 let before = false;
                 for (let i = this.chapters.length - 1; i >= 0; i--) {
                     let chapter = this.chapters[i];
-                    if (chapter.getChapterID() === chapterID)
+                    if (chapter.getID() === chapterID)
                         before = true;
                     // If we're before the given chapter and it's not forthcoming.
                     else if (before && !chapter.isForthcoming())
-                        return chapter.getChapterID();
+                        return chapter.getID();
                 }
                 // If the given ID was the last chapter, go to the next back matter chapter.
                 if (before)
@@ -420,26 +556,26 @@ export default class Edition {
     getEmbeds() {
         let embeds = [];
         // Add the book cover
-        const cover = this.getImage("cover");
+        const cover = this.getImage('cover');
         if (cover) {
             let coverNode = Parser.parseEmbed(this, cover);
             if (coverNode instanceof EmbedNode)
                 embeds.push(coverNode);
         }
         // Add the cover and images from each chapter.
-        this.getChapters().forEach(c => {
+        this.getChapters().forEach((c) => {
             const image = c.getImage();
             let cover = image === null ? undefined : Parser.parseEmbed(this, image);
             if (cover && cover instanceof EmbedNode)
                 embeds.push(cover);
             // Get the chapter body's embeds
-            let bodyEmbeds = c?.getAST()?.getEmbeds();
+            let bodyEmbeds = c?.getAST(this)?.getEmbeds();
             if (bodyEmbeds)
                 bodyEmbeds.forEach((embed) => embeds.push(embed));
         });
         // Add the back matter covers
-        let backmatter = ["references", "glossary", "index", "search", "media"];
-        backmatter.forEach(id => {
+        let backmatter = ['references', 'glossary', 'index', 'search', 'media'];
+        backmatter.forEach((id) => {
             const img = this.getImage(id);
             if (img) {
                 let image = Parser.parseEmbed(this, img);
@@ -449,18 +585,33 @@ export default class Edition {
         });
         return embeds;
     }
-    isLatestPublishedEdition() {
-        const latestEditionID = this.book?.getLatestPublishedEditionID();
-        return latestEditionID !== undefined && latestEditionID === this.editionRef?.id;
+    isLatestEdition(book) {
+        const latestEditionID = book.getLatestEditionID();
+        return (latestEditionID !== undefined &&
+            latestEditionID === this.editionRef?.id);
+    }
+    isLatestPublishedEdition(book) {
+        const latestEditionID = book.getLatestPublishedEditionID();
+        return (latestEditionID !== undefined &&
+            latestEditionID === this.editionRef?.id);
     }
-    /* Edition numbers are 1 to N */
     getEditionNumber() {
-        const revisions = this.book?.getRevisions();
-        if (revisions === undefined)
-            return undefined;
-        for (let i = 0; i < revisions.length; i++)
-            if (revisions[i].ref.id === this.editionRef?.id)
-                return revisions.length - i;
-        return undefined;
+        return this.number;
+    }
+    getEditionLabel() {
+        const num = this.number;
+        return `${num}${num === 1 ? 'st' : num === 2 ? 'nd' : num === 3 ? 'rd' : ''}`;
+    }
+    getInfo() {
+        return this.editionRef === undefined
+            ? undefined
+            : {
+                ref: this.editionRef,
+                summary: this.summary,
+                number: this.number,
+                published: this.published,
+                editionuids: this.uids,
+                chapteruids: Array.from(new Set(this.chapters.map((chapter) => chapter.uids).flat())),
+            };
     }
 }