bookish-press 0.4.47 → 0.4.49

package/models/book/Edition.js

@@ -0,0 +1,620 @@
+import Chapter from './Chapter';
+import Parser from '../chapter/Parser';
+import EmbedNode from '../chapter/EmbedNode';
+import Reference from './Reference';
+import ChapterIDs from './ChapterID.js';
+export default class Edition {
+    bookRef;
+    editionRef;
+    uids;
+    title;
+    authors;
+    number;
+    summary;
+    published;
+    images;
+    description;
+    chapters;
+    license;
+    acknowledgements;
+    tags;
+    sources;
+    references;
+    symbols;
+    glossary;
+    theme;
+    base;
+    active;
+    // Given an object with a valid specification and an object mapping chapter IDs to chapter text,
+    // construct an object representing a book.
+    constructor(bookRef, editionRef, uids, title, authors, number, summary, published, images, description, chapters, license, acknowledgements, tags, sources, references, symbols, glossary, theme, base, active) {
+        this.bookRef = bookRef;
+        this.editionRef = editionRef;
+        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.base = base;
+        this.active = active;
+    }
+    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.base ?? '', 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);
+        }
+    }
+    // Convert the book to an object for storage.
+    toObject() {
+        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,
+            base: this.base,
+            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.base, 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.base, 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.base, 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.base, 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.base, 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.base, 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.base, 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].getID() === chapterID)
+                return position;
+        return undefined;
+    }
+    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.base, 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.base, this.active);
+    }
+    withNewChapter() {
+        // Synthesize a chapter ID placeholder that doesn't overlap with existing chapter names
+        let number = 1;
+        while (this.hasChapter('chapter' + number))
+            number++;
+        // Create a default chapter on this model. Remember the document reference so we can modify it later.
+        const newChapter = new Chapter(undefined, `chapter${number}`, 'Untitled Chapter', [], null, true, false, undefined, '', []);
+        return this.withChapters([...this.chapters, newChapter]);
+    }
+    withoutChapter(chapterID) {
+        let index = this.chapters.findIndex((chapter) => chapter.getID() === chapterID);
+        if (index < 0)
+            return this;
+        return this.withChapters([
+            ...this.chapters.slice(0, index),
+            ...this.chapters.slice(index + 1),
+        ]);
+    }
+    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.base, 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.base, 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;
+        const newReferences = Object.assign({}, this.references);
+        delete newReferences[ref.citationID];
+        newReferences[newCitationID] = ref.withCitationID(newCitationID);
+        return this.withReferences(newReferences);
+    }
+    withoutReference(citationID) {
+        if (!(citationID in this.references))
+            return this;
+        const newReferences = Object.assign({}, this.references);
+        delete newReferences[citationID];
+        return this.withReferences(newReferences);
+    }
+    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.base, this.active);
+    }
+    withDefinition(id, phrase, definition, synonyms) {
+        const newGlossary = Object.assign({}, this.glossary);
+        newGlossary[id] = {
+            phrase: phrase,
+            definition: definition,
+            synonyms: synonyms,
+        };
+        return this.withGlossary(newGlossary);
+    }
+    withoutDefinition(id) {
+        const newGlossary = Object.assign({}, this.glossary);
+        delete newGlossary[id];
+        return this.withGlossary(newGlossary);
+    }
+    withEditedDefinition(id, definition) {
+        const newGlossary = Object.assign({}, this.glossary);
+        newGlossary[id] = definition;
+        return this.withGlossary(newGlossary);
+    }
+    withEditedDefinitionID(id, newID) {
+        if (!(id in this.glossary))
+            return;
+        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.base, 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.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.base, 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.base, 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.base, 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, this.base, newActive);
+    }
+    getBookReadingTime() {
+        return this.chapters
+            .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) => {
+            // If we found a match...
+            if (chapter.getID() === chapterID) {
+                match = chapterNumber;
+                // And it's an unnumbered chapter, set to null.
+                if (!chapter.isNumbered())
+                    match = null;
+            }
+            // Otherwise, increment if it's numbered.
+            else if (chapter.isNumbered())
+                chapterNumber++;
+        });
+        // Remember the number if we found it.
+        if (match !== null)
+            return match;
+        else
+            return undefined;
+    }
+    getSource(sourceID) {
+        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.getChapter(chapterID);
+        return chapter?.getSection();
+    }
+    getFootnoteSymbol(number) {
+        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);
+    }
+    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);
+            if (index)
+                Object.keys(index).forEach((word) => {
+                    if (word !== '' && word.length > 2) {
+                        if (!(word in bookIndex))
+                            bookIndex[word] = new Set();
+                        bookIndex[word].add(chapter.getID());
+                    }
+                });
+        });
+        return bookIndex;
+    }
+    // Given the current chapter, find the available chapter after it.
+    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].getID()
+                    : null;
+            default:
+                let after = false;
+                for (let i = 0; i < this.chapters.length; i++) {
+                    let chapter = this.chapters[i];
+                    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.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;
+                // Otherwise, it wasn't a valid ID
+                else
+                    return null;
+        }
+    }
+    // Given a chapter id, find the available chapter before it.
+    getPreviousChapterID(chapterID) {
+        switch (chapterID) {
+            // Handle back matter chapters.
+            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.getID() === chapterID)
+                        before = true;
+                    // If we're before the given chapter and it's not forthcoming.
+                    else if (before && !chapter.isForthcoming())
+                        return chapter.getID();
+                }
+                // If the given ID was the last chapter, go to the next back matter chapter.
+                if (before)
+                    return ChapterIDs.TableOfContentsID;
+                // Otherwise, it wasn't a valid ID
+                else
+                    return null;
+        }
+    }
+    // Get all of the embeds in the book
+    getEmbeds() {
+        let embeds = [];
+        // Add the book 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) => {
+            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(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) => {
+            const img = this.getImage(id);
+            if (img) {
+                let image = Parser.parseEmbed(this, img);
+                if (image instanceof EmbedNode)
+                    embeds.push(image);
+            }
+        });
+        return embeds;
+    }
+    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);
+    }
+    getEditionNumber() {
+        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())),
+            };
+    }
+}

package/models/book/Reference.d.ts

@@ -0,0 +1,24 @@
+export default class Reference {
+    readonly citationID: string;
+    readonly authors: string;
+    readonly year: string;
+    readonly title: string;
+    readonly source: string;
+    readonly url: string;
+    readonly summary: string;
+    readonly short: boolean;
+    constructor(citationID: string, authors?: string, year?: string, title?: string, source?: string, url?: string, summary?: string, short?: boolean);
+    toText(): string;
+    toList(): string[];
+    copy(): this;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+    withCitationID(id: string): Reference;
+    withAuthors(authors: string): Reference;
+    withYear(year: string): Reference;
+    withTitle(title: string): Reference;
+    withSource(source: string): Reference;
+    withURL(url: string): Reference;
+    withSummary(summary: string): Reference;
+    equals(ref: Reference): boolean;
+}