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

package/src/exporter/html/{tools.js → tools.ts}

@@ -1,6 +1,6 @@
-const numberToRoman = number => {
+const numberToRoman = (number: number): string => {
     let roman = ""
-    const romanNumList = {
+    const romanNumList: Record<string, number> = {
         M: 1000,
         CM: 900,
         D: 500,
@@ -15,7 +15,7 @@ const numberToRoman = number => {
         IV: 4,
         I: 1
     }
-    let a
+    let a: number
     for (const key in romanNumList) {
         a = Math.floor(number / romanNumList[key])
         if (a >= 0) {
@@ -28,10 +28,10 @@ const numberToRoman = number => {
     return roman
 }
 
-const numberToAlpha = number => {
+const numberToAlpha = (number: number): string => {
     const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     let alpha = ""
-    let a
+    let a: number
     for (let i = 0; i < number; i++) {
         a = i % 26
         alpha += alphabet[a]
@@ -39,7 +39,10 @@ const numberToAlpha = number => {
     return alpha
 }
 
-export const displayNumber = (number, system) => {
+export const displayNumber = (
+    number: number,
+    system?: string
+): string | number => {
     if (system === "roman") {
         return numberToRoman(number)
     }

package/src/exporter/jats/bibliography.ts

@@ -0,0 +1,199 @@
+import {escapeText} from "fwtoolkit"
+
+import type {BibDBEntry, FidusNode} from "../../types.js"
+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: Record<string, string> = {
+    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"
+}
+
+interface NameLike {
+    literal?: string
+    family?: string
+    given?: string
+    prefix?: string
+    suffix?: string
+}
+
+export function jatsBib(bib: BibDBEntry, id: number): string {
+    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
+
+    const fields = (bib.fields || {}) as Record<string, unknown>
+
+    // authors
+    if (fields.author && Array.isArray(fields.author) && fields.author.length) {
+        start += `<person-group person-group-type="author">${fields.author
+            .map((author: unknown) => {
+                const a = author as NameLike
+                if (a.literal) {
+                    return `<collab>${convertTexts((a.literal) as unknown as FidusNode[])}</collab>`
+                }
+                let nameStart = `<name><surname>${convertTexts((a.family || "") as unknown as FidusNode[])}</surname> <given-names>${convertTexts((a.given || "") as unknown as FidusNode[])}</given-names>`
+                if (a.prefix && a.prefix.length) {
+                    nameStart += ` <prefix>${convertTexts((a.prefix) as unknown as FidusNode[])}</prefix>`
+                }
+                if (a.suffix && a.suffix.length) {
+                    nameStart += ` <suffix>${convertTexts((a.suffix) as unknown as FidusNode[])}</suffix>`
+                }
+                const nameEnd = "</name>"
+                return nameStart + nameEnd
+            })
+            .join(", ")}</person-group>`
+    }
+
+    // title && container title
+    if (fields.title) {
+        if (
+            fields.shortjournal ||
+            fields.booktitle ||
+            fields.journaltitle
+        ) {
+            start += `<source>${convertTexts((String(fields.shortjournal || fields.booktitle || fields.journaltitle) as unknown as FidusNode[]))}</source>`
+            start += `<article-title>${convertTexts((String(fields.title) as unknown as FidusNode[]))}</article-title>`
+        } else {
+            start += `<source>${convertTexts((String(fields.title) as unknown as FidusNode[]))}</source>`
+        }
+    }
+
+    // editors
+    if (fields.editor && Array.isArray(fields.editor) && fields.editor.length) {
+        start += `<person-group person-group-type="editor">${fields.editor
+            .map((editor: unknown) => {
+                const e = editor as NameLike
+                if (e.literal) {
+                    return `<collab>${convertTexts((e.literal) as unknown as FidusNode[])}</collab>`
+                }
+                let nameStart = `<name><surname>${convertTexts((e.family || "") as unknown as FidusNode[])}</surname> <given-names>${convertTexts((e.given || "") as unknown as FidusNode[])}</given-names>`
+                const nameEnd = "</name>"
+                if (e.prefix && e.prefix.length) {
+                    nameStart += ` <prefix>${convertTexts((e.prefix) as unknown as FidusNode[])}</prefix>`
+                }
+                if (e.suffix && e.suffix.length) {
+                    nameStart += ` <suffix>${convertTexts((e.suffix) as unknown as FidusNode[])}</suffix>`
+                }
+                return nameStart + nameEnd
+            })
+            .join(", ")}</person-group>`
+    }
+
+    // publisher
+    if (fields.publisher && Array.isArray(fields.publisher) && fields.publisher.length) {
+        start += fields.publisher
+            .map(
+                publisher =>
+                    `<publisher-name>${convertTexts((String(publisher) as unknown as FidusNode[]))}</publisher-name>`
+            )
+            .join("")
+    }
+
+    // location
+    if (fields.location && Array.isArray(fields.location) && fields.location.length) {
+        start += fields.location
+            .map(
+                location =>
+                    `<publisher-loc>${convertTexts((String(location) as unknown as FidusNode[]))}</publisher-loc>`
+            )
+            .join("")
+    }
+
+    // date
+    if (fields.date && String(fields.date).length) {
+        const date = String(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 (fields.volume && String(fields.volume).length) {
+        start += `<volume>${convertTexts((String(fields.volume) as unknown as FidusNode[]))}</volume>`
+    }
+
+    // issue
+    if (fields.issue && String(fields.issue).length) {
+        start += `<issue>${convertTexts((String(fields.issue) as unknown as FidusNode[]))}</issue>`
+    }
+
+    // pages
+    if (fields.pages && Array.isArray(fields.pages) && fields.pages.length) {
+        const pages = fields.pages as Array<string[]>
+        start += `<fpage>${convertTexts((pages[0][0]) as unknown as FidusNode[])}</fpage>`
+        const lastPageGroup = pages.slice(-1)[0]
+        start += `<lpage>${convertTexts((lastPageGroup.slice(-1)[0]) as unknown as FidusNode[])}</lpage>`
+        if (pages.length > 1) {
+            start += `<page-range>${pages
+                .map(pageGroup => pageGroup.map(page => convertTexts((page) as unknown as FidusNode[])).join("-"))
+                .join(", ")}</page-range>`
+        }
+    }
+
+    // doi
+    if (fields.doi && String(fields.doi).length) {
+        start += `<pub-id pub-id-type="doi">${escapeText(String(fields.doi))}</pub-id>`
+    }
+
+    // url
+    if (fields.url && String(fields.url).length) {
+        start += `<ext-link ext-link-type="web" xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="${escapeText(String(fields.url))}"/>`
+    }
+
+    // url date
+    if (fields.urldate && String(fields.urldate).length) {
+        const date = String(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/{citations.js → citations.ts}

@@ -1,9 +1,32 @@
 import {FormatCitations} from "../../citations/format.js"
 
+import type {BibDB, CSL, ExportDoc} from "../../types.js"
 import {jatsBib} from "./bibliography.js"
 
+interface CitationLayout {
+    prefix?: string
+    suffix?: string
+    delimiter?: string
+}
+
+interface CSLStyleChild {
+    name: string
+    children?: CSLStyleChild[]
+    attrs?: Record<string, unknown>
+}
+
 export class JATSExporterCitations {
-    constructor(doc, bibDB, csl) {
+    doc: ExportDoc
+    bibDB: BibDB
+    csl: CSL
+
+    citationTexts: string[]
+    citFm: FormatCitations | false
+    jatsBib: string
+    jatsIdConvert: Record<string, number>
+    citInfos: Record<string, unknown>[]
+
+    constructor(doc: ExportDoc, bibDB: BibDB, csl: CSL) {
         this.doc = doc
         this.bibDB = bibDB
         this.csl = csl
@@ -12,9 +35,10 @@ export class JATSExporterCitations {
         this.citFm = false
         this.jatsBib = ""
         this.jatsIdConvert = {}
+        this.citInfos = []
     }
 
-    init(citInfos) {
+    init(citInfos: Record<string, unknown>[]): Promise<void> {
         this.citInfos = citInfos
         if (!citInfos.length) {
             return Promise.resolve()
@@ -25,44 +49,58 @@ export class JATSExporterCitations {
     // Citations are highly interdependent -- so we need to format them all
     // together before laying out the document.
     // We disregard the styling of the bibliography and instead create our own, JATS-specific bibliography.
-    formatCitations() {
+    formatCitations(): Promise<void> {
+        if (!this.csl.getStyle) {
+            return Promise.resolve()
+        }
         return this.csl
-            .getStyle(this.doc.settings.citationstyle)
+            .getStyle(this.doc.settings.citationstyle || "")
             .then(citationstyle => {
-                const modStyle = JSON.parse(JSON.stringify(citationstyle))
+                const modStyle = JSON.parse(JSON.stringify(citationstyle)) as {
+                    children: CSLStyleChild[]
+                }
                 const citationLayout = modStyle.children
-                    .find(section => section.name === "citation")
-                    .children.find(section => section.name === "layout").attrs
+                    .find(section => section.name === "citation")!
+                    .children!.find(section => section.name === "layout")!.attrs as CitationLayout
                 const origCitationLayout = JSON.parse(
                     JSON.stringify(citationLayout)
-                )
+                ) as CitationLayout
                 citationLayout.prefix = "{{prefix}}"
                 citationLayout.suffix = "{{suffix}}"
                 citationLayout.delimiter = "{{delimiter}}"
-                this.citFm = new FormatCitations(
+                const citFm = new FormatCitations(
                     this.csl,
-                    this.citInfos,
-                    modStyle,
+                    this.citInfos as any,
+                    modStyle as any,
                     "",
                     this.bibDB,
                     false,
                     this.doc.settings.language
                 )
+                this.citFm = citFm
                 return Promise.all([
                     Promise.resolve(origCitationLayout),
-                    this.citFm.init()
+                    citFm.init() as Promise<void>
                 ])
             })
             .then(([origCitationLayout]) => {
+                if (!this.citFm) {
+                    return Promise.resolve()
+                }
+                const citFm = this.citFm
                 // We need to add xref-links to the bibliography items. And there may be more than one work cited
                 // so we need to first split, then add the links and eventually put the citation back together
                 // again.
                 // The IDs used in the jats bibliography are 1 and up in this order
-                this.citFm.bibliography[0].entry_ids.forEach((id, index) => {
+                const bibliography = citFm.bibliography
+                if (!bibliography) {
+                    return Promise.resolve()
+                }
+                bibliography[0].entry_ids.forEach((id, index) => {
                     this.jatsIdConvert[id] = index + 1
                     this.jatsBib += jatsBib(this.bibDB.db[id], index + 1)
                 })
-                this.citationTexts = this.citFm.citationTexts.map(
+                this.citationTexts = citFm.citationTexts.map(
                     (ref, index) => {
                         const content = ref
                             .split("{{delimiter}}")
@@ -71,7 +109,7 @@ export class JATSExporterCitations {
                                     citationText.split("{{prefix}}")
                                 const prefix =
                                     prefixSplit.length > 1
-                                        ? prefixSplit.shift() +
+                                        ? prefixSplit.shift()! +
                                           (origCitationLayout.prefix || "")
                                         : ""
                                 citationText = prefixSplit[0]
@@ -80,13 +118,11 @@ export class JATSExporterCitations {
                                 const suffix =
                                     suffixSplit.length > 1
                                         ? (origCitationLayout.suffix || "") +
-                                          suffixSplit.pop()
+                                          suffixSplit.pop()!
                                         : ""
                                 citationText = suffixSplit[0]
-                                const citId =
-                                    this.citFm.citations[index].sortedItems[
-                                        conIndex
-                                    ][1].id
+                                const sortedItems = ((citFm.citations[index] as unknown as {sortedItems: Array<[unknown, {id: string}]>}).sortedItems)
+                                const citId = sortedItems[conIndex][1].id
                                 const jatsId = this.jatsIdConvert[citId]
                                 return `${prefix}<xref ref-type="bibr" rid="ref-${jatsId}">${citationText}</xref>${suffix}`
                             })