@fiduswriter/books-document 0.1.1

package/src/exporter/docx/render.ts

@@ -0,0 +1,142 @@
+import {DOCXExporterRender} from "@fiduswriter/document/exporter/docx/render"
+
+export class DOCXBookExporterRender extends DOCXExporterRender {
+    preamble: any
+    bodyTemplate: any
+    postamble: any
+    fileXML: any
+    bodyParts: any[]
+
+    constructor(xml: any) {
+        super(xml)
+
+        this.preamble = null
+        this.bodyTemplate = null
+        this.postamble = null
+        this.fileXML = null
+        this.bodyParts = []
+    }
+
+    init(): Promise<void> {
+        return super.init().then(() => {
+            this.fileXML = this.text
+            const text = this.fileXML.query("w:body")
+            this.preamble = text.cloneNode(false)
+            this.bodyTemplate = text.cloneNode(false)
+            this.postamble = text.cloneNode(false)
+            let currentSection = this.bodyTemplate
+            const textChildren = Array.from(text.children)
+            textChildren.forEach((node: any) => {
+                const bookmarkStart = node.query("w:bookmarkStart")
+                if (bookmarkStart) {
+                    const bookmarkName = String(
+                        bookmarkStart.getAttribute("w:name")
+                    ).toLowerCase()
+                    if (bookmarkName === "preamble") {
+                        currentSection = this.preamble
+                    } else if (bookmarkName === "body") {
+                        currentSection = this.bodyTemplate
+                    } else if (bookmarkName === "postamble") {
+                        currentSection = this.postamble
+                    }
+                }
+                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("w:bookmarkStart", {
+            "w:name": "body"
+        })
+        if (bodyBookmark) {
+            bodyBookmark.setAttribute("w: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(["w:p", "w:sectPr"])
+            blocks.forEach((block: any) => {
+                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 {
+        const text = this.fileXML.query("w:body")
+        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(
+                    `<w:p>
+                  <w:pPr>
+                    <w:pStyle w:val="Normal"/>
+                    <w:bidi w:val="0"/>
+                    <w:jc w:val="start"/>
+                    <w:rPr/>
+                  </w:pPr>
+                  <w:r>
+                    <w:rPr/>
+                  </w:r>
+                  <w:r>
+                    <w:br w:type="page"/>
+                  </w:r>
+                </w:p>`
+                )
+            }
+        })
+        Array.from(this.postamble.children).forEach((node: any) =>
+            text.appendChild(node)
+        )
+    }
+}

package/src/exporter/epub/index.ts

@@ -0,0 +1,426 @@
+/**
+ * EPUB book exporter.
+ */
+
+import type {Schema} from "prosemirror-model"
+import {HTMLExporterConvert} from "@fiduswriter/document/exporter/html/convert"
+import {htmlExportTemplate} from "@fiduswriter/document/exporter/html/templates"
+import {removeHidden} from "@fiduswriter/document/exporter/tools/doc_content"
+import {createSlug} from "@fiduswriter/document/exporter/tools/file"
+import {ZipFileCreator} from "@fiduswriter/document/exporter/tools/zip"
+import {addAlert, get, staticUrl} from "fwtoolkit"
+import pretty from "pretty"
+
+import type {Book, BookStyles, CSL, DocumentListEntry, User} from "../../types.js"
+import {getMissingChapterData} from "../tools.js"
+import {
+    containerTemplate,
+    epubBookCopyrightTemplate,
+    epubBookCoverTemplate,
+    epubBookOpfTemplate,
+    epubBookTitlepageTemplate,
+    navTemplate,
+    ncxTemplate
+} from "./templates.js"
+import {
+    buildHierarchy,
+    getFontMimeType,
+    getImageMimeType,
+    getTimestamp
+} from "./tools.js"
+
+interface StyleSheet {
+    url?: string
+    filename?: string
+    contents?: string
+}
+
+interface ImageFile {
+    url: string
+    filename: string
+    coverImage?: boolean
+    mimeType?: string
+}
+
+interface FontFile {
+    url: string
+    filename: string
+    mimeType?: string
+}
+
+interface TextFile {
+    filename: string
+    contents: string
+}
+
+interface IncludeZip {
+    directory: string
+    url: string
+}
+
+interface ChapterOutput {
+    number: number
+    part: string
+    title: string
+    docNum: number
+    metaData: Record<string, unknown>
+}
+
+export class EpubBookExporter {
+    schema: Schema
+    csl: CSL
+    bookStyles: BookStyles
+    book: Book
+    user: User
+    docList: DocumentListEntry[]
+    updated: number
+    textFiles: TextFile[]
+    images: ImageFile[]
+    fontFiles: FontFile[]
+    httpFiles: (ImageFile | FontFile)[]
+    styleSheets: StyleSheet[]
+    chapters: ChapterOutput[]
+    contentItems: Array<Record<string, unknown>>
+    includeZips: IncludeZip[]
+    math: boolean
+
+    constructor(
+        schema: Schema,
+        csl: CSL,
+        bookStyles: BookStyles,
+        book: Book,
+        user: User,
+        docList: DocumentListEntry[],
+        updated: number
+    ) {
+        this.schema = schema
+        this.csl = csl
+        this.bookStyles = bookStyles
+        this.book = book
+        this.user = user
+        this.docList = docList
+        this.updated = updated
+        this.textFiles = []
+        this.images = []
+        this.fontFiles = []
+        this.httpFiles = []
+        this.styleSheets = [{url: staticUrl("css/book.css")}]
+        this.chapters = []
+        this.contentItems = []
+        this.includeZips = []
+        this.math = false
+    }
+
+    async init(): Promise<Blob | false> {
+        if (this.book.chapters.length === 0) {
+            addAlert(
+                "error",
+                gettext("Book cannot be exported due to lack of chapters.")
+            )
+            return false
+        }
+
+        await getMissingChapterData(this.book, this.docList, this.schema)
+
+        this.addBookStyle()
+        return this.exportContents()
+    }
+
+    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]) => {
+            contents = contents.replace(
+                new RegExp(filename, "g"),
+                `media/${filename}`
+            )
+        })
+
+        this.styleSheets.push({contents, filename: `css/${bookStyle.slug}.css`})
+        this.fontFiles = this.fontFiles.concat(
+            bookStyle.bookstylefile_set.map(([url, filename]) => ({
+                filename: `css/media/${filename}`,
+                url
+            }))
+        )
+        return true
+    }
+
+    async exportContents(): Promise<Blob> {
+        await Promise.all(
+            this.styleSheets.map(async sheet => this.loadStyle(sheet))
+        )
+
+        if (this.book.cover_image) {
+            const coverImage = this.book.cover_image_data
+            if (coverImage?.image) {
+                this.images.push({
+                    url: coverImage.image.split("?")[0],
+                    filename: coverImage.image.split("/").pop()?.split("?")[0] || "cover",
+                    coverImage: true
+                })
+
+                this.textFiles.push({
+                    filename: "cover.xhtml",
+                    contents: pretty(
+                        epubBookCoverTemplate({
+                            book: this.book,
+                            coverImage: coverImage as any,
+                            shortLang: this.book.settings.language.split("-")[0]
+                        })
+                    )
+                })
+            }
+        }
+
+        this.textFiles.push({
+            filename: "titlepage.xhtml",
+            contents: pretty(
+                epubBookTitlepageTemplate({
+                    book: this.book,
+                    shortLang: this.book.settings.language.split("-")[0]
+                })
+            )
+        })
+
+        this.chapters = (
+            await Promise.all(
+                this.book.chapters
+                    .sort((a, b) => a.number - b.number)
+                    .map(async chapter => {
+                        const doc = this.docList.find(
+                            d => d.id === chapter.text
+                        )
+                        if (!doc) {
+                            return false
+                        }
+
+                        const docContent = removeHidden(doc.content as any) as any
+
+                        const converter = new HTMLExporterConvert(
+                            doc.title,
+                            doc.settings,
+                            docContent,
+                            htmlExportTemplate,
+                            {db: doc.images || {}},
+                            {db: doc.bibliography || {}},
+                            this.csl,
+                            this.styleSheets,
+                            {
+                                xhtml: true,
+                                epub: true,
+                                footnoteNumbering: "decimal",
+                                affiliationNumbering: "alpha",
+                                idPrefix: `c-${chapter.number}-`
+                            }
+                        )
+                        const {html, imageIds, metaData, extraStyleSheets} =
+                            await converter.init()
+
+                        if (!html) {
+                            return false
+                        }
+
+                        imageIds.forEach((id: string | number) => {
+                            const image = doc.images?.[id]
+                            if (image?.image && typeof image.image === "string") {
+                                this.images.push({
+                                    filename: `images/${image.image.split("/").pop()}`,
+                                    url: image.image
+                                })
+                            }
+                        })
+
+                        await Promise.all(
+                            extraStyleSheets.map(
+                                async (sheet: StyleSheet) => this.loadStyle(sheet)
+                            )
+                        )
+
+                        if (converter.features.math) {
+                            this.math = true
+                        }
+
+                        this.textFiles.push({
+                            filename: `document-${chapter.number}.xhtml`,
+                            contents: pretty(html)
+                        })
+
+                        return {
+                            number: chapter.number,
+                            part: chapter.part || "",
+                            title: doc.title,
+                            docNum: chapter.number,
+                            metaData
+                        }
+                    })
+            )
+        ).filter((chapter): chapter is ChapterOutput => chapter !== false)
+
+        this.textFiles.push({
+            filename: "copyright.xhtml",
+            contents: pretty(
+                epubBookCopyrightTemplate({
+                    book: this.book,
+                    creator: this.user.name || "",
+                    language: this.book.settings.language,
+                    shortLang: this.book.settings.language.split("-")[0]
+                })
+            )
+        })
+
+        const contentItems = this.chapters.reduce(
+            (items: Array<Record<string, unknown>>, chapter) => {
+                if (chapter.part) {
+                    items.push({
+                        title: chapter.part,
+                        docNum: chapter.number,
+                        link: `document-${chapter.number}.xhtml`,
+                        level: -1
+                    })
+                }
+                items = items.concat(
+                    (chapter.metaData.toc as Array<Record<string, unknown>>).map(item => ({
+                        ...item,
+                        docNum: chapter.number,
+                        link: `document-${chapter.number}.xhtml#c-${chapter.number}-${item.id}`
+                    }))
+                )
+                return items
+            },
+            []
+        )
+
+        const toc = buildHierarchy(contentItems)
+
+        this.textFiles = this.textFiles.concat([
+            {
+                filename: "META-INF/container.xml",
+                contents: pretty(containerTemplate())
+            },
+            {
+                filename: "document.opf",
+                contents: pretty(
+                    epubBookOpfTemplate({
+                        book: this.book,
+                        language: this.book.settings.language,
+                        idType: "fidus",
+                        date: getTimestamp(new Date(this.updated * 1000)).slice(
+                            0,
+                            10
+                        ),
+                        modified: getTimestamp(new Date(this.updated * 1000)),
+                        styleSheets: this.styleSheets as any,
+                        math: this.math,
+                        images: this.images.map(image => ({
+                            ...image,
+                            mimeType: getImageMimeType(image.filename)
+                        })) as any,
+                        fontFiles: this.fontFiles.map(font => ({
+                            ...font,
+                            mimeType: getFontMimeType(font.filename)
+                        })) as any,
+                        chapters: this.chapters as any,
+                        user: this.user as any
+                    } as any)
+                )
+            },
+            {
+                filename: "document.ncx",
+                contents: pretty(
+                    ncxTemplate({
+                        shortLang: this.book.settings.language.split("-")[0],
+                        title: this.book.title,
+                        idType: "fidus",
+                        id: this.book.id,
+                        toc: toc as any
+                    } as any)
+                )
+            },
+            {
+                filename: "document-nav.xhtml",
+                contents: pretty(
+                    navTemplate({
+                        shortLang: this.book.settings.language.split("-")[0],
+                        toc: toc as any,
+                        styleSheets: this.styleSheets as any
+                    } as any)
+                )
+            }
+        ])
+        if (this.math) {
+            this.includeZips.push({
+                directory: "css",
+                url: staticUrl("zip/mathlive_style.zip")
+            })
+        }
+
+        this.httpFiles = this.images.concat(this.fontFiles)
+        this.prefixFiles()
+        return this.createZip()
+    }
+
+    async loadStyle(sheet: StyleSheet): Promise<StyleSheet> {
+        const filename =
+            sheet.filename ||
+            `css/${sheet.url?.split("/").pop()?.split("?")[0]}`
+        const existing = this.textFiles.find(file => file.filename === filename)
+        if (existing) {
+            return Promise.resolve(existing as StyleSheet)
+        }
+        if (sheet.url) {
+            const response = await get(sheet.url)
+            const text = await response.text()
+            sheet.contents = text
+            sheet.filename = filename
+            delete sheet.url
+        }
+        if (sheet.filename) {
+            this.textFiles.push(sheet as TextFile)
+        }
+        return Promise.resolve(sheet)
+    }
+
+    prefixFiles(): void {
+        this.textFiles = this.textFiles.map(file => {
+            if (
+                ["META-INF/container.xml", "mimetype"].includes(file.filename)
+            ) {
+                return file
+            }
+            return Object.assign({}, file, {filename: `EPUB/${file.filename}`})
+        })
+        this.fontFiles = this.fontFiles.map(file =>
+            Object.assign({}, file, {filename: `EPUB/${file.filename}`})
+        )
+        this.includeZips = this.includeZips.map(file =>
+            Object.assign({}, file, {directory: `EPUB/${file.directory}`})
+        )
+    }
+
+    async createZip(): Promise<Blob> {
+        const zipper = new ZipFileCreator(
+            this.textFiles,
+            this.httpFiles,
+            this.includeZips,
+            "application/epub+zip",
+            new Date(this.updated * 1000)
+        )
+        const blob = await zipper.init()
+        return this.download(blob)
+    }
+
+    download(blob: Blob): Blob {
+        return blob
+    }
+
+    get defaultFilename(): string {
+        return `${createSlug(this.book.title)}.epub`
+    }
+}