@fiduswriter/document 0.1.0-alpha.3 → 0.1.0-alpha.5

package/src/exporter/jats/index.js

@@ -1,92 +0,0 @@
-import download from "downloadjs"
-import pretty from "pretty"
-
-import {shortFileTitle} from "fwtoolkit"
-import {createSlug} from "../tools/file.js"
-import {ZipFileCreator} from "../tools/zip.js"
-import {JATSExporterConverter} from "./convert.js"
-import {
-    articleTemplate,
-    bookPartWrapperTemplate,
-    darManifest
-} from "./templates.js"
-/*
- Exporter to JATS
-*/
-
-export class JATSExporter {
-    constructor(doc, bibDB, imageDB, csl, updated, type) {
-        this.doc = doc
-        this.docTitle = shortFileTitle(this.doc.title, this.doc.path)
-        this.bibDB = bibDB
-        this.imageDB = imageDB
-        this.csl = csl
-        this.updated = updated
-        this.type = type // "article", "book-part-wrapper" (for documents) or "book" (for document collections)
-
-        this.zipFileName = false
-        this.textFiles = []
-        this.httpFiles = []
-    }
-
-    init() {
-        const fileFormat = this.type === "article" ? "jats" : "bits"
-        this.zipFileName = `${createSlug(this.docTitle)}.${fileFormat}.zip`
-        this.converter = new JATSExporterConverter(
-            this.type,
-            this.doc,
-            this.csl,
-            this.imageDB,
-            this.bibDB
-        )
-        return this.converter.init().then(({front, body, back, imageIds}) => {
-            const jats =
-                this.type === "article"
-                    ? articleTemplate({front, body, back})
-                    : bookPartWrapperTemplate({front, body, back})
-            this.textFiles.push({
-                filename: "manuscript.xml",
-                contents: pretty(jats, {ocd: true})
-            })
-            const images = imageIds.map(id => {
-                const imageEntry = this.imageDB.db[id]
-                return {
-                    title: imageEntry.title,
-                    filename: imageEntry.image.split("/").pop(),
-                    url: imageEntry.image
-                }
-            })
-            this.textFiles.push({
-                filename: "manifest.xml",
-                contents: pretty(
-                    darManifest({
-                        title: this.docTitle,
-                        type: this.type,
-                        images
-                    }),
-                    {ocd: true}
-                )
-            })
-            images.forEach(image => {
-                this.httpFiles.push({filename: image.filename, url: image.url})
-            })
-
-            return this.createZip()
-        })
-    }
-
-    createZip() {
-        const zipper = new ZipFileCreator(
-            this.textFiles,
-            this.httpFiles,
-            undefined,
-            undefined,
-            this.updated
-        )
-        return zipper.init().then(blob => this.download(blob))
-    }
-
-    download(blob) {
-        return download(blob, this.zipFileName, "application/zip")
-    }
-}

package/src/exporter/odt/images.js

@@ -1,115 +0,0 @@
-import {get} from "fwtoolkit"
-import {descendantNodes} from "../tools/doc_content.js"
-import {svg2png} from "../tools/svg.js"
-
-export class ODTExporterImages {
-    constructor(docContent, xml, imageDB) {
-        this.docContent = docContent
-        this.xml = xml
-        this.imageDB = imageDB
-        this.images = {}
-        this.manifestXml = false
-    }
-
-    init() {
-        return this.xml.getXml("META-INF/manifest.xml").then(manifestXml => {
-            this.manifestXml = manifestXml
-            return this.exportImages()
-        })
-    }
-
-    // add an image to the list of files
-    addImage(imgFileName, image) {
-        imgFileName = this.addFileToManifest(imgFileName)
-        this.xml.addExtraFile(`Pictures/${imgFileName}`, image)
-        return imgFileName
-    }
-
-    // add a an image file to the manifest
-    addFileToManifest(imgFileName) {
-        const fileNameParts = imgFileName.split(".")
-        const fileNameEnding = fileNameParts.pop()
-        const fileNameStart = fileNameParts.join(".")
-        const manifestEl = this.manifestXml.query("manifest:manifest")
-        let imgManifest = manifestEl.query("manifest:file-entry", {
-            "manifest:full-path": `Pictures/${imgFileName}`
-        })
-        let counter = 0
-        while (imgManifest) {
-            // Name exists already, we change the name until we get a file name not yet included in manifest.
-            imgFileName = `${fileNameStart}_${counter++}.${fileNameEnding}`
-            imgManifest = manifestEl.query("manifest:file-entry", {
-                "manifest:full-path": `Pictures/${imgFileName}`
-            })
-        }
-        const string = `  <manifest:file-entry manifest:full-path="Pictures/${imgFileName}" manifest:media-type="image/${fileNameEnding}"/>`
-        manifestEl.appendXML(string)
-        return imgFileName
-    }
-
-    // Find all images used in file and add these to the export zip.
-    // TODO: This will likely fail on image types odt doesn't support such as
-    // SVG. Try out and fix.
-    exportImages() {
-        const usedImgs = []
-
-        descendantNodes(this.docContent).forEach(node => {
-            if (node.type === "image" && node.attrs.image !== false) {
-                if (!usedImgs.includes(node.attrs.image)) {
-                    usedImgs.push(node.attrs.image)
-                }
-            }
-        })
-
-        return new Promise(resolveExportImages => {
-            const p = []
-
-            usedImgs.forEach(image => {
-                const imgDBEntry = this.imageDB.db[image]
-                p.push(
-                    get(imgDBEntry.image)
-                        .then(response => response.blob())
-                        .then(blob => {
-                            const wImgId = this.addImage(
-                                imgDBEntry.image.split("/").pop(),
-                                blob
-                            )
-                            if (blob.type === "image/svg+xml") {
-                                // Add PNG version in addition to SVG
-                                return svg2png(blob).then(
-                                    ({blob: pngBlob, width, height}) => {
-                                        const pngWImgId = this.addImage(
-                                            imgDBEntry.image
-                                                .split("/")
-                                                .pop()
-                                                .replace(/.svg$/g, ".png"),
-                                            pngBlob
-                                        )
-                                        this.images[image] = {
-                                            id: pngWImgId,
-                                            width,
-                                            height,
-                                            title: imgDBEntry.title,
-                                            type: blob.type,
-                                            svg: wImgId
-                                        }
-                                    }
-                                )
-                            } else {
-                                this.images[image] = {
-                                    id: wImgId,
-                                    width: imgDBEntry.width,
-                                    height: imgDBEntry.height,
-                                    title: imgDBEntry.title,
-                                    type: blob.type,
-                                    svg: false
-                                }
-                            }
-                        })
-                )
-            })
-
-            Promise.all(p).then(() => resolveExportImages())
-        })
-    }
-}

package/src/importer/citations.js

@@ -1,129 +0,0 @@
-/**
- * Shared citation utilities for DOCX and ODT importers.
- *
- * Converts a CitationResult (from DocxCitationsParser or OdtCitationsParser
- * static methods) plus a BibDB (entries) into a Fidus Writer citation node,
- * and merges the new BibDB entries into the document bibliography.
- *
- * The `bibliography` object passed in is mutated in place: new entries are
- * appended with sequential numeric string keys ("1", "2", …).
- */
-
-/**
- * Given a BibDB returned by a static Citations parser call and the current
- * document bibliography, add every entry that is not yet present (matched by
- * entry_key) and return a mapping from entry_key → bibliography key string.
- *
- * @param {Object} entries  BibDB (Record<number, EntryObject>) from parser
- * @param {Object} bibliography  Fidus Writer bibliography (mutated in place)
- * @returns {Object}  Map of entry_key → bibKey string
- */
-function mergeBibEntries(entries, bibliography, bibDB) {
-    const keyMap = {}
-
-    for (const entry of Object.values(entries)) {
-        if (!entry || !entry.entry_key) {
-            continue
-        }
-        const entryKey = entry.entry_key
-
-        // Check whether this entry_key is already in the bibliography.
-        const existing = Object.entries(bibliography).find(
-            ([, bibEntry]) => bibEntry && bibEntry.entry_key === entryKey
-        )
-
-        if (existing) {
-            keyMap[entryKey] = existing[0]
-        } else {
-            if (bibDB && Object.keys(entry.fields).length === 0) {
-                // Jabref citations don't contain any fields. Look up values in bibDB instead
-                const bibEntry = Object.values(bibDB.db).find(
-                    bibEntry => bibEntry && bibEntry.entry_key === entryKey
-                )
-                if (bibEntry) {
-                    entry.fields = JSON.parse(JSON.stringify(bibEntry.fields))
-                    entry.bib_type = bibEntry.bib_type
-                }
-            }
-            // TODO: add for jabref citations - according to entry_key import from user
-            // library if useExternalDB is true
-            const bibKey = String(Object.keys(bibliography).length + 1)
-            bibliography[bibKey] = entry
-            keyMap[entryKey] = bibKey
-        }
-    }
-
-    return keyMap
-}
-
-/**
- * Convert a CitationResult from a static DocxCitationsParser or
- * OdtCitationsParser call into a Fidus Writer citation node.
- *
- * The `bibliography` object is mutated in place to include any new entries.
- *
- * Each item in `metadata` (when `retrieveMetadata` was true) may carry:
- *   - id         : entry_key string identifying which entry this item refers to
- *   - prefix     : citation prefix text
- *   - suffix     : citation suffix / locator text (used as `locator`)
- *   - locator    : explicit locator string (preferred over suffix when present)
- *   - authorOnly : boolean – render author name only (maps to "textcite")
- *   - suppressAuthor : boolean – suppress author name (ignored, maps to default)
- *   - authorYear : boolean – render author name and year (maps to "textcite")
- *
- * `format` on the returned citation node matches the Fidus Writer citation schema:
- *   - "textcite"  when authorOnly or authorYear is set on the (single) item (biblatex \textcite)
- *   - "autocite"  otherwise, including when suppressAuthor is set (biblatex \autocite)
- *
- * @param {Object} result       CitationResult from a static parser method
- * @param {Object} bibliography Fidus Writer bibliography (mutated in place)
- * @returns {Object|null}  ProseMirror citation node or null
- */
-export function citationResultToNode(result, bibliography, bibDB = false) {
-    if (!result || !result.isCitation || !result.entries) {
-        return null
-    }
-    const entries = result.entries
-    const metadata = result.metadata || []
-
-    if (Object.keys(entries).length === 0) {
-        return null
-    }
-    const keyMap = mergeBibEntries(entries, bibliography, bibDB)
-    // Build the references array from entries.
-    //
-    const references = Object.entries(entries).map(([_entryId, entry]) => {
-        const entryKey = entry.entry_key
-        const entryMetadata = metadata.find(meta => meta.entry_key === entryKey)
-        return {
-            id: keyMap[entryKey],
-            prefix: entryMetadata?.prefix || "",
-            locator: entryMetadata?.locator || entryMetadata?.suffix || ""
-        }
-    })
-
-    if (references.length === 0) {
-        return null
-    }
-
-    // Determine citation format from the first item's metadata flags.
-    // "textcite" corresponds to biblatex's \textcite (author-in-text / authorYear).
-    // Even authorOnly comes through as "textcite" since it's a similar concept.
-    // Everything else, including suppressAuthor, falls back to "autocite".
-    // TODO: When an authorOnly citation is followed directly by a suppressAuthor
-    // citation, this would display the same as a single authorYear citation and
-    // should be treated as such.
-    const format =
-        metadata.length === 1 &&
-        (metadata[0].authorOnly || metadata[0].authorYear)
-            ? "textcite"
-            : "autocite"
-
-    return {
-        type: "citation",
-        attrs: {
-            format,
-            references
-        }
-    }
-}

package/src/importer/native/get_images.js

@@ -1,76 +0,0 @@
-import {get} from "fwtoolkit"
-
-export class GetImages {
-    constructor(images, entries) {
-        this.images = images
-        this.imageEntries = Object.values(this.images)
-        this.entries = entries
-        this.counter = 0
-    }
-
-    init() {
-        if (this.entries.length > 0) {
-            if (this.entries[0].hasOwnProperty("url")) {
-                return this.getImageUrlEntry()
-            } else {
-                return this.getImageZipEntry()
-            }
-        } else {
-            return Promise.resolve()
-        }
-    }
-
-    getImageZipEntry() {
-        if (this.counter < this.imageEntries.length) {
-            return new Promise(resolve => {
-                const f = this.entries.find(
-                    entry =>
-                        entry.filename === this.imageEntries[this.counter].image
-                )
-                if (!f) {
-                    console.warn(
-                        `Image ${this.imageEntries[this.counter].image} not found`,
-                        this.imageEntries,
-                        this.entries
-                    )
-                    this.counter++
-                    return this.getImageZipEntry().then(() => {
-                        resolve()
-                    })
-                }
-                const fc = f.content
-                this.imageEntries[this.counter]["file"] = new window.Blob(
-                    [fc],
-                    {
-                        type: this.imageEntries[this.counter].file_type
-                    }
-                )
-                this.counter++
-                this.getImageZipEntry().then(() => {
-                    resolve()
-                })
-            })
-        } else {
-            return Promise.resolve()
-        }
-    }
-
-    getImageUrlEntry() {
-        if (this.counter < this.imageEntries.length) {
-            const getUrl = this.entries.find(
-                entry =>
-                    entry.filename ===
-                    `images/${this.imageEntries[this.counter].image.split("/").pop()}`
-            ).url
-            return get(getUrl)
-                .then(response => response.blob())
-                .then(blob => {
-                    this.imageEntries[this.counter]["file"] = blob
-                    this.counter++
-                    return this.getImageUrlEntry()
-                })
-        } else {
-            return Promise.resolve()
-        }
-    }
-}