@fiduswriter/books-document 0.1.1

package/src/exporter/native/index.ts

@@ -0,0 +1,187 @@
+/**
+ * Native `.fidusbook` exporter.
+ */
+
+import type {Schema} from "prosemirror-model"
+import {ShrinkFidus} from "@fiduswriter/document/exporter/native/shrink"
+import {createSlug} from "@fiduswriter/document/exporter/tools/file"
+import {ZipFileCreator} from "@fiduswriter/document/exporter/tools/zip"
+import {addAlert} from "fwtoolkit"
+
+import {FIDUSBOOK_VERSION} from "../../schema/index.js"
+import type {Book, DocumentListEntry, User} from "../../types.js"
+import {getMissingChapterData} from "../tools.js"
+
+interface FileInclude {
+    url: string
+    filename: string
+}
+
+interface TextFile {
+    filename: string
+    contents: string
+}
+
+export {FIDUSBOOK_VERSION}
+
+export class NativeBookExporter {
+    schema: Schema
+    book: Book
+    user: User
+    documentList: DocumentListEntry[]
+    updated: any
+
+    constructor(
+        schema: Schema,
+        book: Book,
+        user: User,
+        documentList: DocumentListEntry[],
+        updated: any
+    ) {
+        this.schema = schema
+        this.book = book
+        this.user = user
+        this.documentList = documentList
+        this.updated = updated
+    }
+
+    init(): Promise<Blob> {
+        if (this.book.chapters.length === 0) {
+            addAlert(
+                "error",
+                gettext("Book cannot be exported due to lack of chapters.")
+            )
+            return Promise.resolve(new Blob([]))
+        }
+
+        addAlert(
+            "info",
+            `${this.book.title}: ${gettext("Fidusbook export has been initiated.")}`
+        )
+
+        return getMissingChapterData(this.book, this.documentList, this.schema)
+            .then(() => this.exportContents())
+            .catch(error => {
+                addAlert(
+                    "error",
+                    `${this.book.title}: ${gettext("Fidusbook export failed.")}`
+                )
+                throw error
+            })
+    }
+
+    exportContents(): Promise<Blob> {
+        const textFiles: TextFile[] = []
+        const httpFiles: FileInclude[] = []
+
+        const sortedChapters = [...this.book.chapters].sort(
+            (a, b) => a.number - b.number
+        )
+
+        const bookData: Record<string, unknown> = {
+            title: this.book.title,
+            path: this.book.path || "/",
+            metadata: this.book.metadata || {},
+            settings: this.book.settings || {},
+            chapters: sortedChapters.map((chapter, index) => ({
+                number: chapter.number,
+                part: chapter.part || "",
+                chapter_index: index
+            }))
+        }
+
+        if (this.book.cover_image_data) {
+            const coverImage = this.book.cover_image_data
+            const imageUrl = (coverImage.image || "").split("?")[0]
+            const filename = imageUrl.split("/").pop() || "cover"
+            bookData.cover_image = {
+                title: coverImage.title || "",
+                checksum: coverImage.checksum || "",
+                file_type: coverImage.file_type,
+                image: `cover/${filename}`
+            }
+            httpFiles.push({url: imageUrl, filename: `cover/${filename}`})
+        }
+
+        const processChapter = (index: number): Promise<void> => {
+            if (index >= sortedChapters.length) {
+                return Promise.resolve()
+            }
+            const chapter = sortedChapters[index]
+            const doc = this.documentList.find(d => d.id === chapter.text)
+            if (!doc) {
+                return processChapter(index + 1)
+            }
+
+            const shrinker = new ShrinkFidus(
+                doc as any,
+                {db: doc.images || {}},
+                {db: doc.bibliography || {}},
+                true
+            )
+
+            return shrinker
+                .init()
+                .then(
+                    ({
+                        doc: shrunkDoc,
+                        shrunkImageDB,
+                        shrunkBibDB,
+                        httpIncludes
+                    }: {
+                        doc: Record<string, unknown>
+                        shrunkImageDB: Record<string, unknown>
+                        shrunkBibDB: Record<string, unknown>
+                        httpIncludes: FileInclude[]
+                    }) => {
+                        httpIncludes.forEach(include => {
+                            include.filename = `chapters/${index}/${include.filename}`
+                        })
+
+                        textFiles.push(
+                            {
+                                filename: `chapters/${index}/document.json`,
+                                contents: JSON.stringify(shrunkDoc)
+                            },
+                            {
+                                filename: `chapters/${index}/images.json`,
+                                contents: JSON.stringify(shrunkImageDB)
+                            },
+                            {
+                                filename: `chapters/${index}/bibliography.json`,
+                                contents: JSON.stringify(shrunkBibDB)
+                            }
+                        )
+                        httpFiles.push(...httpIncludes)
+                    }
+                )
+                .then(() => processChapter(index + 1))
+        }
+
+        return processChapter(0).then(() => {
+            textFiles.push(
+                {filename: "book.json", contents: JSON.stringify(bookData)},
+                {filename: "filetype-version", contents: FIDUSBOOK_VERSION}
+            )
+
+            const zipper = new ZipFileCreator(
+                textFiles,
+                httpFiles,
+                [],
+                "application/fidusbook+zip",
+                this.updated
+            )
+            return zipper.init().then(blob => this.download(blob))
+        })
+    }
+
+    download(blob: Blob): Blob {
+        // Base implementation returns the Blob.  Browser/CLI subclasses can
+        // override this method to trigger a real download.
+        return blob
+    }
+
+    get defaultFilename(): string {
+        return `${createSlug(this.book.title)}.fidusbook`
+    }
+}

package/src/exporter/odt/index.ts

@@ -0,0 +1,211 @@
+/**
+ * ODT book exporter.
+ */
+
+import type {Schema} from "prosemirror-model"
+import type {CSL, User} from "@fiduswriter/document"
+import {
+    fixTables,
+    removeHidden
+} from "@fiduswriter/document/exporter/tools/doc_content"
+import {createSlug} from "@fiduswriter/document/exporter/tools/file"
+import {XmlZip} from "@fiduswriter/document/exporter/tools/xml_zip"
+import {addAlert} from "fwtoolkit"
+
+import {ODTExporterCitations} from "@fiduswriter/document/exporter/odt/citations"
+import {ODTExporterImages} from "@fiduswriter/document/exporter/odt/images"
+import {ODTExporterFootnotes} from "@fiduswriter/document/exporter/odt/footnotes"
+import {ODTExporterMath} from "@fiduswriter/document/exporter/odt/math"
+import {ODTExporterMetadata} from "@fiduswriter/document/exporter/odt/metadata"
+import {ODTExporterRichtext} from "@fiduswriter/document/exporter/odt/richtext"
+import {ODTExporterStyles} from "@fiduswriter/document/exporter/odt/styles"
+import {ODTExporterTracks} from "@fiduswriter/document/exporter/odt/track"
+
+import type {Book, DocumentListEntry} from "../../types.js"
+import {getMissingChapterData} from "../tools.js"
+import {ODTBookExporterRender} from "./render.js"
+
+export class ODTBookExporter {
+    schema: Schema
+    csl: CSL
+    book: Book
+    user: User
+    docList: DocumentListEntry[]
+    templateUrl: string
+    updated: any
+    textFiles: Array<Record<string, unknown>>
+    httpFiles: Array<Record<string, unknown>>
+    mimeType: string
+
+    constructor(
+        schema: Schema,
+        csl: CSL,
+        book: Book,
+        user: User,
+        docList: DocumentListEntry[],
+        updated: any
+    ) {
+        this.schema = schema
+        this.csl = csl
+        this.book = book
+        this.user = user
+        this.docList = docList
+        this.templateUrl = book.odt_template || ""
+        this.updated = updated
+        this.textFiles = []
+        this.httpFiles = []
+
+        this.mimeType = "application/vnd.oasis.opendocument.text"
+    }
+
+    init(): Promise<Blob> | false {
+        if (this.book.chapters.length === 0) {
+            addAlert(
+                "error",
+                gettext("Book cannot be exported due to lack of chapters.")
+            )
+            return false
+        }
+        return getMissingChapterData(
+            this.book,
+            this.docList,
+            this.schema,
+            {rawContent: true}
+        ).then(() => this.export())
+    }
+
+    export(): Promise<Blob> {
+        this.book.chapters.sort((a, b) => (a.number > b.number ? 1 : -1))
+        const xml = new XmlZip(this.templateUrl, this.mimeType)
+        const styles = new ODTExporterStyles(xml as any)
+        const math = new ODTExporterMath(xml as any)
+        const tracks = new ODTExporterTracks(xml as any)
+        const render = new ODTBookExporterRender(xml as any, styles)
+        const metadata = new ODTExporterMetadata(
+            xml as any,
+            styles,
+            this.getBaseMetadata() as any
+        )
+
+        return xml
+            .init()
+            .then(() => styles.init())
+            .then(() => tracks.init())
+            .then(() => render.init())
+            .then(() => metadata.init())
+            .then(() => math.init())
+            .then(() => this.exportChapters(xml as any, render, styles, math, tracks))
+            .then(() => xml.prepareBlob())
+            .then(blob => this.download(blob))
+    }
+
+    exportChapters(
+        xml: any,
+        render: ODTBookExporterRender,
+        styles: any,
+        math: any,
+        tracks: any
+    ): Promise<void> {
+        return this.book.chapters
+            .map((chapter, chapterIndex) => {
+                return (): Promise<void> => {
+                    const doc = this.docList.find(d => d.id === chapter.text)
+                    if (!doc) {
+                        return Promise.resolve()
+                    }
+                    const docContent = fixTables(
+                        removeHidden(doc.rawContent as any) as any
+                    ) as any
+                    const citations = new ODTExporterCitations(
+                        docContent as any,
+                        doc.settings,
+                        styles,
+                        {db: doc.bibliography || {}},
+                        this.csl
+                    )
+                    const footnotes = new ODTExporterFootnotes(
+                        docContent,
+                        doc.settings,
+                        xml,
+                        citations,
+                        styles,
+                        {db: doc.bibliography || {}},
+                        {db: doc.images || {}},
+                        this.csl
+                    )
+
+                    const images = new ODTExporterImages(docContent, xml, {
+                        db: doc.images || {}
+                    })
+                    const richtext = new ODTExporterRichtext(
+                        doc.comments || {},
+                        doc.settings,
+                        styles,
+                        tracks,
+                        footnotes,
+                        citations,
+                        math,
+                        images
+                    )
+                    return citations
+                        .init()
+                        .then(() => images.init())
+                        .then(() => footnotes.init())
+                        .then(() => {
+                            const pmBib = footnotes.pmBib || citations.pmBib
+                            render.render(
+                                docContent as any,
+                                pmBib,
+                                doc.settings,
+                                richtext,
+                                citations,
+                                chapterIndex
+                            )
+                            return Promise.resolve()
+                        })
+                }
+            })
+            .reduce(
+                (promiseChain, currentChapter) =>
+                    promiseChain.then(() => currentChapter()),
+                Promise.resolve()
+            )
+            .then(() =>
+                render.renderAmbles(
+                    Object.assign(
+                        {
+                            title: this.book.title,
+                            language: this.book.settings.language
+                        },
+                        this.book.metadata
+                    )
+                )
+            )
+            .then(() => render.assemble())
+    }
+
+    getBaseMetadata(): Record<string, unknown> {
+        const authors = this.book.metadata.author?.length
+            ? [{institution: this.book.metadata.author}]
+            : []
+        const keywords = this.book.metadata.keywords?.length
+            ? this.book.metadata.keywords
+                  .split(",")
+                  .map(keyword => keyword.trim())
+            : []
+        return {
+            authors,
+            keywords,
+            title: this.book.title,
+            language: this.book.settings.language
+        }
+    }
+
+    download(blob: Blob): Blob {
+        return blob
+    }
+
+    get defaultFilename(): string {
+        return `${createSlug(this.book.title)}.odt`
+    }
+}

package/src/exporter/odt/render.ts

@@ -0,0 +1,146 @@
+import {ODTExporterRender} from "@fiduswriter/document/exporter/odt/render"
+
+export class ODTBookExporterRender extends ODTExporterRender {
+    styles: any
+    preamble: any
+    bodyTemplate: any
+    postamble: any
+    bodyParts: any[]
+    fileXml: any
+
+    constructor(xml: any, styles: any) {
+        super(xml)
+
+        this.styles = styles
+
+        this.preamble = null
+        this.bodyTemplate = null
+        this.postamble = null
+
+        this.bodyParts = []
+        this.fileXml = null
+    }
+
+    init(): Promise<void> {
+        return this.xml.getXml(this.filePath).then((xml: any) => {
+            this.fileXml = xml
+            const text = xml.query("office:text")
+            this.preamble = text.cloneNode(false)
+            this.bodyTemplate = text.cloneNode(false)
+            this.postamble = text.cloneNode(false)
+            let currentSection: any
+            const textChildren = Array.from(text.children)
+            textChildren.forEach((node: any) => {
+                if (["text:p", "text:h"].includes(node.tagName)) {
+                    const bookmark = node.query("text:bookmark")
+                    if (bookmark) {
+                        const sectionName = String(
+                            bookmark.getAttribute("text:name")
+                        ).toLowerCase()
+                        if (sectionName === "preamble") {
+                            currentSection = this.preamble
+                        } else if (sectionName === "postamble") {
+                            currentSection = this.postamble
+                        } else if (sectionName === "body") {
+                            currentSection = this.bodyTemplate
+                        } else {
+                            currentSection = currentSection || this.bodyTemplate
+                        }
+                    } else {
+                        currentSection = currentSection || this.bodyTemplate
+                    }
+                }
+                if (currentSection) {
+                    currentSection.appendChild(node)
+                }
+            })
+            return Promise.resolve()
+        })
+    }
+
+    render(...args: any[]): void {
+        const [docContent, pmBib, settings, richtext, citations, chapterIndex] = args
+        this.text = this.bodyTemplate.cloneNode(true)
+        const bodyBookmark = (this.text as any).query("text:bookmark", {
+            "text:name": "body"
+        })
+        if (bodyBookmark) {
+            bodyBookmark.setAttribute(
+                "text:name",
+                `chapter ${chapterIndex + 1}`
+            )
+        }
+        super.render(docContent, pmBib, settings, richtext, citations)
+        this.bodyParts.push(this.text)
+    }
+
+    renderAmbles({
+        title,
+        subtitle,
+        version,
+        publisher,
+        copyright,
+        author,
+        keywords,
+        language,
+        description,
+        isbn,
+        publication_date,
+        series_title,
+        series_position
+    }: Record<string, unknown>): void {
+        const tags = [
+            {title: "book.title", content: title},
+            {title: "book.subtitle", content: subtitle},
+            {title: "book.version", content: version},
+            {title: "book.publisher", content: publisher},
+            {title: "book.copyright", content: copyright},
+            {title: "book.author", content: author},
+            {title: "book.keywords", content: keywords},
+            {title: "book.language", content: language},
+            {title: "book.description", content: description},
+            {title: "book.isbn", content: isbn},
+            {title: "book.publication_date", content: publication_date},
+            {title: "book.series_title", content: series_title},
+            {title: "book.series_position", content: series_position}
+        ]
+        const usedTags: any[] = []
+        const ambles = [this.preamble, this.postamble]
+        ambles.forEach(amble => {
+            const blocks = amble.queryAll(["text:p", "text:h"])
+            blocks.forEach((block: any) => {
+                if (block.parentElement.nodeName === "text:deletion") {
+                    return
+                }
+                const text = block.textContent
+                tags.forEach(tag => {
+                    const tagString = tag.title
+                    if (text.includes(`{${tagString}}`)) {
+                        usedTags.push(Object.assign({block}, tag))
+                    }
+                })
+            })
+        })
+        usedTags.forEach(tag => this.inlineRender(tag))
+    }
+
+    assemble(): void {
+        this.styles.addPageBreakStyle()
+        const text = this.fileXml.query("office:text")
+        Array.from(this.preamble.children).forEach((node: any) =>
+            text.appendChild(node)
+        )
+        this.bodyParts.forEach((bodyPart: any, index: number) => {
+            const children = bodyPart.children.slice()
+            children.forEach((node: any) => {
+                text.appendChild(node)
+            })
+            if (index < this.bodyParts.length - 1) {
+                text.appendXML('<text:p text:style-name="PageBreak"/>')
+            }
+        })
+        Array.from(this.postamble.children).forEach((node: any) =>
+            text.appendChild(node)
+        )
+    }
+}

package/src/exporter/print/index.ts

@@ -0,0 +1,92 @@
+/**
+ * Print book exporter.
+ *
+ * Uses @vivliostyle/print to render the book in the browser.
+ */
+
+import type {Schema} from "prosemirror-model"
+import type {CSL, User} from "@fiduswriter/document"
+import {printHTML} from "@vivliostyle/print"
+
+import type {Book, BookStyles, DocumentListEntry} from "../../types.js"
+import {HTMLBookExporter} from "../html/index.js"
+import {chapterTemplate} from "./templates.js"
+
+export class PrintBookExporter extends HTMLBookExporter {
+    constructor(
+        schema: Schema,
+        csl: CSL,
+        documentStyles: BookStyles,
+        book: Book,
+        user: User,
+        docList: DocumentListEntry[]
+    ) {
+        super(schema, csl, documentStyles, book, user, docList, 0, false, {
+            relativeUrls: false
+        })
+        this.chapterTemplate = chapterTemplate
+    }
+
+    addBookStyle(): boolean {
+        const bookStyle = this.bookStyles.find(
+            style => style.slug === this.book.settings.book_style
+        )
+        if (!bookStyle) {
+            return false
+        }
+        let contents = bookStyle.contents
+        bookStyle.bookstylefile_set.forEach(
+            ([url, filename]: [string, string]) =>
+                (contents = contents.replace(
+                    new RegExp(filename, "g"),
+                    url
+                ))
+        )
+
+        this.styleSheets.push({contents})
+        return true
+    }
+
+    async createZip(): Promise<void> {
+        const htmlDoc = this.textFiles.find(
+            file => file.filename === "index.html"
+        )?.contents
+        if (!htmlDoc) {
+            return
+        }
+        const config: any = {title: this.book.title}
+
+        if (navigator.userAgent.includes("Gecko/")) {
+            config.printCallback = (iframeWin: Window) => {
+                const oldBody = document.body
+                document.body.parentElement!.dataset.vivliostylePaginated =
+                    "true"
+                document.body = iframeWin.document.body
+                iframeWin.document
+                    .querySelectorAll("style")
+                    .forEach(el => document.body.appendChild(el))
+                const backgroundStyle = document.createElement("style")
+                backgroundStyle.innerHTML = "body {background-color: white;}"
+                document.body.appendChild(backgroundStyle)
+                window.print()
+                document.body = oldBody
+                delete document.body.parentElement!.dataset
+                    .vivliostylePaginated
+            }
+        }
+
+        printHTML(htmlDoc, config)
+    }
+
+    async loadStyle(sheet: {
+        url?: string
+        filename?: string
+        contents?: string
+    }): Promise<{url?: string; filename?: string; contents?: string}> {
+        if (sheet.url) {
+            sheet.filename = sheet.url
+            delete sheet.url
+        }
+        return sheet
+    }
+}

package/src/exporter/print/templates.ts

@@ -0,0 +1,8 @@
+import {escapeText} from "fwtoolkit"
+
+export const chapterTemplate = ({
+    part,
+    contents
+}: Record<string, unknown>) => `
+    ${part && (part as string).length ? `<h1 class="part">${escapeText(part as string)}</h1>` : ""}
+    ${contents}`