@fiduswriter/document 0.1.0-alpha.4 → 0.1.0-alpha.6

package/src/exporter/docx/images.js

@@ -1,101 +0,0 @@
-import {get} from "fwtoolkit"
-import {descendantNodes} from "../tools/doc_content.js"
-import {svg2png} from "../tools/svg.js"
-
-export class DOCXExporterImages {
-    constructor(docContent, imageDB, xml, rels) {
-        this.docContent = docContent
-        this.imageDB = imageDB
-        this.xml = xml
-        this.rels = rels
-
-        this.images = {}
-        this.ctXML = false
-    }
-
-    init() {
-        return this.xml.getXml("[Content_Types].xml").then(ctXML => {
-            this.ctXML = ctXML
-            return this.exportImages()
-        })
-    }
-
-    // add an image to the list of files
-    addImage(imgFileName, image) {
-        const rId = this.rels.addImageRel(imgFileName)
-        this.addContentType(imgFileName.split(".").pop())
-        this.xml.addExtraFile(`word/media/${imgFileName}`, image)
-        return rId
-    }
-
-    // add a global contenttype declaration for an image type (if needed)
-    addContentType(fileEnding) {
-        const types = this.ctXML.query("Types")
-        const contentDec = types.query("Default", {Extension: fileEnding})
-        if (!contentDec) {
-            const string = `<Default ContentType="image/${fileEnding}" Extension="${fileEnding}"/>`
-            types.appendXML(string)
-        }
-    }
-
-    // Find all images used in file and add these to the export zip.
-    // TODO: This will likely fail on image types docx 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 => {
-                            if (blob.type === "image/svg+xml") {
-                                // DOCX doesn't support SVG. Convert to PNG.
-                                return svg2png(blob).then(
-                                    ({blob: pngBlob, width, height}) => {
-                                        const wImgId = this.addImage(
-                                            imgDBEntry.image
-                                                .split("/")
-                                                .pop()
-                                                .replace(/.svg$/g, ".png"),
-                                            pngBlob
-                                        )
-                                        this.images[image] = {
-                                            id: wImgId,
-                                            width,
-                                            height,
-                                            title: imgDBEntry.title
-                                        }
-                                    }
-                                )
-                            } else {
-                                const wImgId = this.addImage(
-                                    imgDBEntry.image.split("/").pop(),
-                                    blob
-                                )
-                                this.images[image] = {
-                                    id: wImgId,
-                                    width: imgDBEntry.width,
-                                    height: imgDBEntry.height,
-                                    title: imgDBEntry.title
-                                }
-                            }
-                        })
-                )
-            })
-
-            Promise.all(p).then(() => {
-                resolveExportImages()
-            })
-        })
-    }
-}

package/src/exporter/jats/bibliography.js

@@ -1,183 +0,0 @@
-import {escapeText} from "fwtoolkit"
-import {convertTexts} from "./text.js"
-
-// This list is based on values listed at https://jats.nlm.nih.gov/archiving/tag-library/1.2/attribute/publication-type.html
-// And the advice given here: https://jats4r.org/citations/#recommendation
-const PUBLICATION_TYPES = {
-    article: "journal",
-    "article-journal": "journal",
-    "article-magazine": "journal",
-    "article-newspaper": "journal",
-    book: "book",
-    bookinbook: "book",
-    booklet: "book",
-    chapter: "book",
-    collection: "standard",
-    dataset: "dataset",
-    "entry-dictionary": "standard",
-    "entry-encyclopedia": "standard",
-    inbook: "book",
-    incollection: "book",
-    inproceedings: "standard",
-    inreference: "standard",
-    manual: "book",
-    misc: "standard",
-    mvbook: "book",
-    mvcollection: "standard",
-    mvproceedings: "book",
-    mvreference: "standard",
-    online: "standard",
-    patent: "patent",
-    periodical: "book",
-    post: "standards",
-    "post-weblog": "standard",
-    proceedings: "book",
-    reference: "standard",
-    report: "report",
-    review: "review",
-    suppbook: "book",
-    suppcollection: "book",
-    suppperiodical: "journal",
-    thesis: "standard",
-    unpublished: "standard"
-}
-
-export function jatsBib(bib, id) {
-    let start = "",
-        end = ""
-    start += `<ref id="ref-${id}">`
-    end = "</ref>" + end
-    // Type
-    const publicationType = PUBLICATION_TYPES[bib.bib_type] ?? "standard"
-    start += `<element-citation publication-type="${publicationType}">`
-    end = "</element-citation>" + end
-
-    // authors
-    if (bib.fields.author && bib.fields.author.length) {
-        start += `<person-group person-group-type="author">${bib.fields.author
-            .map(author => {
-                if (author.literal) {
-                    return `<collab>${convertTexts(author.literal)}</collab>`
-                }
-                let nameStart = `<name><surname>${convertTexts(author.family)}</surname> <given-names>${convertTexts(author.given)}</given-names>`
-                if (author.prefix && author.prefix.length) {
-                    nameStart += ` <prefix>${convertTexts(author.prefix)}</prefix>`
-                }
-                if (author.suffix && author.suffix.length) {
-                    nameStart += ` <suffix>${convertTexts(author.suffix)}</suffix>`
-                }
-                const nameEnd = "</name>"
-                return nameStart + nameEnd
-            })
-            .join(", ")}</person-group>`
-    }
-
-    // title && container title
-    if (bib.fields.title) {
-        if (
-            bib.fields.shortjournal ||
-            bib.fields.booktitle ||
-            bib.fields.journaltitle
-        ) {
-            start += `<source>${convertTexts(bib.fields.shortjournal || bib.fields.booktitle || bib.fields.journaltitle)}</source>`
-            start += `<article-title>${convertTexts(bib.fields.title)}</article-title>`
-        } else {
-            start += `<source>${convertTexts(bib.fields.title)}</source>`
-        }
-    }
-
-    // editors
-    if (bib.fields.editor && bib.fields.editor.length) {
-        start += `<person-group person-group-type="editor">${bib.fields.editor
-            .map(editor => {
-                if (editor.literal) {
-                    return `<collab>${convertTexts(editor.literal)}</collab>`
-                }
-                let nameStart = `<name><surname>${convertTexts(editor.family)}</surname> <given-names>${convertTexts(editor.given)}</given-names>`
-                const nameEnd = "</name>"
-                if (editor.prefix && editor.prefix.length) {
-                    nameStart = `<prefix>${convertTexts(editor.prefix)}</prefix>`
-                }
-                if (editor.suffix && editor.suffix.length) {
-                    nameStart = `<suffix>${convertTexts(editor.suffix)}</suffix>`
-                }
-                return nameStart + nameEnd
-            })
-            .join(", ")}</person-group>`
-    }
-
-    // publisher
-    if (bib.fields.publisher && bib.fields.publisher.length) {
-        start += bib.fields.publisher
-            .map(
-                publisher =>
-                    `<publisher-name>${convertTexts(publisher)}</publisher-name>`
-            )
-            .join("")
-    }
-
-    // location
-    if (bib.fields.location && bib.fields.location.length) {
-        start += bib.fields.location
-            .map(
-                location =>
-                    `<publisher-loc>${convertTexts(location)}</publisher-loc>`
-            )
-            .join("")
-    }
-
-    // date
-    if (bib.fields.date && bib.fields.date.length) {
-        const date = bib.fields.date
-        const dateParts = date.split("-")
-        start += `<date iso-8601-date="${date}" date-type="published">${
-            dateParts.length > 2 ? `<day>${dateParts[2]}</day>` : ""
-        }${
-            dateParts.length > 1 ? `<month>${dateParts[1]}</month>` : ""
-        }<year>${dateParts[0]}</year></date>`
-    }
-
-    // volume
-    if (bib.fields.volume && bib.fields.volume.length) {
-        start += `<volume>${convertTexts(bib.fields.volume)}</volume>`
-    }
-
-    // issue
-    if (bib.fields.issue && bib.fields.issue.length) {
-        start += `<issue>${convertTexts(bib.fields.issue)}</issue>`
-    }
-
-    // pages
-    if (bib.fields.pages && bib.fields.pages.length) {
-        start += `<fpage>${convertTexts(bib.fields.pages[0][0])}</fpage>`
-        start += `<lpage>${convertTexts(bib.fields.pages.slice(-1)[0].slice(-1)[0])}</lpage>`
-        if (bib.fields.pages.length > 1) {
-            start += `<page-range>${bib.fields.pages
-                .map(pages => pages.map(page => convertTexts(page)).join("-"))
-                .join(", ")}</page-range>`
-        }
-    }
-
-    // doi
-    if (bib.fields.doi && bib.fields.doi.length) {
-        start += `<pub-id pub-id-type="doi">${escapeText(bib.fields.doi)}</pub-id>`
-    }
-
-    // url
-    if (bib.fields.url && bib.fields.url.length) {
-        start += `<ext-link ext-link-type="web" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="${escapeText(bib.fields.url)}"/>`
-    }
-
-    // url date
-    if (bib.fields.urldate && bib.fields.urldate.length) {
-        const date = bib.fields.urldate
-        const dateParts = date.split("-")
-        start += `<date-in-citation content-type="access-date" iso-8601-date="${date}">${
-            dateParts.length > 2 ? `<day>${dateParts[2]}</day>` : ""
-        }${
-            dateParts.length > 1 ? `<month>${dateParts[1]}</month>` : ""
-        }<year>${dateParts[0]}</year></date-in-citation>`
-    }
-
-    return start + end
-}

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
-        }
-    }
-}