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

package/src/exporter/epub/{index.js → index.ts}

@@ -1,5 +1,7 @@
 import pretty from "pretty"
+
 import {HTMLExporter} from "../html/index.js"
+import type {BibDB, CSL, ExportDoc, ImageDB} from "../../types.js"
 
 import {
     containerTemplate,
@@ -15,24 +17,42 @@ import {
 } from "./tools.js"
 
 export class EpubExporter extends HTMLExporter {
-    constructor(doc, bibDB, imageDB, csl, updated, documentStyles) {
+    documentFileName: string
+    lang: string
+    shortLang: string
+
+    constructor(
+        doc: ExportDoc,
+        bibDB: BibDB,
+        imageDB: ImageDB,
+        csl: CSL,
+        updated: any,
+        documentStyles: Array<{
+            slug: string
+            contents: string
+            documentstylefile_set: Array<[string, string]>
+        }>
+    ) {
         super(doc, bibDB, imageDB, csl, updated, documentStyles, {
             xhtml: true,
             epub: true
         })
         // Overriden properties
         this.documentFileName = "document.xhtml"
+        this.contentFileName = "document.xhtml"
         this.fileEnding = "epub"
         this.mimeType = "application/epub+zip"
+        this.lang = doc.settings.language || "en-US"
+        this.shortLang = this.lang.split("-")[0]
     }
 
-    createZip() {
+    createZip(): Promise<void> {
         this.prefixFiles()
         this.createEPUBFiles()
         return super.createZip()
     }
 
-    prefixFiles() {
+    prefixFiles(): void {
         // prefix all files with "EPUB/"
         this.textFiles = this.textFiles.map(file =>
             Object.assign({}, file, {filename: `EPUB/${file.filename}`})
@@ -45,7 +65,7 @@ export class EpubExporter extends HTMLExporter {
         )
     }
 
-    createEPUBFiles() {
+    createEPUBFiles(): void {
         // Generate the required EPUB-specific files using the converted content
         this.textFiles.push(
             {
@@ -67,29 +87,33 @@ export class EpubExporter extends HTMLExporter {
         )
     }
 
-    createOPF() {
+    createOPF(): string {
         const timestamp = getTimestamp(this.updated)
         const images = this.httpFiles
             .map(file =>
                 Object.assign({mimeType: getImageMimeType(file.filename)}, file)
             )
-            .filter(image => image.mimeType)
+            .filter(image => image.mimeType) as Array<
+            {filename: string; url: string; mimeType: string}
+        >
 
         const fontFiles = this.httpFiles
             .map(file =>
                 Object.assign({mimeType: getFontMimeType(file.filename)}, file)
             )
-            .filter(file => file.mimeType)
+            .filter(file => file.mimeType) as Array<
+            {filename: string; url: string; mimeType: string}
+        >
 
         const styleSheets = this.textFiles.filter(file =>
             file.filename.endsWith(".css")
         )
 
         // Extract authors and keywords from metaData
-        const authors = this.converter.metaData.authors.map(
-            ({attrs: author}) => {
+        const rawAuthors = this.converter.metaData.authors.map(
+            ({attrs: author}: any) => {
                 if (author.firstname || author.lastname) {
-                    const nameParts = []
+                    const nameParts: string[] = []
                     if (author.firstname) {
                         nameParts.push(author.firstname)
                     }
@@ -102,34 +126,39 @@ export class EpubExporter extends HTMLExporter {
                 }
             }
         )
+        const authors = rawAuthors.filter(
+            (author: any): author is string => typeof author === "string"
+        )
         return opfTemplate({
             language: this.lang,
             title: this.docTitle,
             authors,
             keywords: this.converter.metaData.keywords,
             idType: "fidus",
-            id: this.doc.id,
+            id: String(this.doc.id),
             date: timestamp.slice(0, 10),
             modified: timestamp,
             styleSheets,
             math: this.converter.features.math,
             images,
             fontFiles,
-            copyright: this.doc.settings.copyright
+            copyright: this.doc.settings.copyright as
+                | {holder?: string; year?: number}
+                | undefined
         })
     }
 
-    createNCX() {
+    createNCX(): string {
         return ncxTemplate({
             shortLang: this.shortLang,
             title: this.docTitle,
             idType: "fidus",
-            id: this.doc.id,
+            id: String(this.doc.id),
             toc: buildHierarchy(this.converter.metaData.toc)
         })
     }
 
-    createNav() {
+    createNav(): string {
         const styleSheets = this.textFiles.filter(file =>
             file.filename.endsWith(".css")
         )

package/src/exporter/epub/{templates.js → templates.ts}

@@ -1,6 +1,46 @@
 import {escapeText} from "fwtoolkit"
+
 import {mathliveOpfIncludes} from "../../mathlive/opf_includes.js"
 
+interface EpubImage {
+    filename: string
+    mimeType: string
+    coverImage?: boolean
+}
+
+interface EpubFile {
+    filename: string
+    mimeType: string
+}
+
+interface EpubStyleSheet {
+    filename: string
+}
+
+interface EpubTocItem {
+    id: string
+    title: string
+    docNum?: number
+    link?: string
+    children: EpubTocItem[]
+}
+
+interface OpfTemplateOptions {
+    id: string
+    idType: string
+    title: string
+    language: string
+    authors: string[]
+    keywords: string[]
+    date: string
+    modified: string
+    images: EpubImage[]
+    fontFiles: EpubFile[]
+    styleSheets: EpubStyleSheet[]
+    math: boolean
+    copyright?: {holder?: string; year?: number}
+}
+
 /** A template for the OPF file of an epub. */
 export const opfTemplate = ({
     id,
@@ -16,7 +56,7 @@ export const opfTemplate = ({
     styleSheets,
     math,
     copyright
-}) =>
+}: OpfTemplateOptions): string =>
     `<?xml version="1.0" encoding="UTF-8"?>
 <package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="${idType}" xml:lang="${language}" prefix="cc: http://creativecommons.org/ns#">
     <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
@@ -65,8 +105,8 @@ ${images
     </spine>
 </package>`
 
-/** A template for the contianer XML of an epub file. */
-export const containerTemplate = () =>
+/** A template for the container XML of an epub file. */
+export const containerTemplate = (): string =>
     `<?xml version="1.0" encoding="UTF-8"?>
 <container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0">
     <rootfiles>
@@ -74,8 +114,22 @@ export const containerTemplate = () =>
     </rootfiles>
 </container>`
 
+interface NcxTemplateOptions {
+    shortLang: string
+    idType: string
+    id: string
+    title: string
+    toc: EpubTocItem[]
+}
+
 /** A template of the NCX file of an epub. */
-export const ncxTemplate = ({shortLang, idType, id, title, toc}) =>
+export const ncxTemplate = ({
+    shortLang,
+    idType,
+    id,
+    title,
+    toc
+}: NcxTemplateOptions): string =>
     `<?xml version="1.0" encoding="UTF-8"?>
 <ncx xmlns:ncx="http://www.daisy.org/z3986/2005/ncx/" xmlns="http://www.daisy.org/z3986/2005/ncx/" version="2005-1" xml:lang="${shortLang}">
     <head>
@@ -91,7 +145,7 @@ ${toc.map(item => ncxItemTemplate({item})).join("")}
 </ncx>`
 
 /** A template for each list item in the navMap of an epub's NCX file. */
-export const ncxItemTemplate = ({item}) =>
+export const ncxItemTemplate = ({item}: {item: EpubTocItem}): string =>
     `        <navPoint id="t${item.docNum ? `${item.id}-${item.docNum}` : item.id}">
             <navLabel><text>${escapeText(item.title)}</text></navLabel>
             <content src="${item.link ? item.link : item.docNum ? `document-${item.docNum}.xhtml#${item.id}` : `document.xhtml#${item.id}`}"/>
@@ -99,7 +153,7 @@ ${item.children?.map(item => ncxItemTemplate({item})).join("") || ""}
         </navPoint>\n`
 
 /** A template for each item in an epub's navigation document. */
-const navItemTemplate = ({item}) =>
+const navItemTemplate = ({item}: {item: EpubTocItem}): string =>
     `\t\t\t\t<li><a href="${
         item.link
             ? item.link
@@ -116,8 +170,18 @@ ${
 }
 </li>`
 
+interface NavTemplateOptions {
+    shortLang: string
+    toc: EpubTocItem[]
+    styleSheets: EpubStyleSheet[]
+}
+
 /** A template for an epub's navigation document. */
-export const navTemplate = ({shortLang, toc, styleSheets}) =>
+export const navTemplate = ({
+    shortLang,
+    toc,
+    styleSheets
+}: NavTemplateOptions): string =>
     `<?xml version="1.0" encoding="UTF-8"?>
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="${shortLang}" lang="${shortLang}" xmlns:epub="http://www.idpf.org/2007/ops">
     <head>

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

@@ -1,33 +1,33 @@
-export function getTimestamp(date) {
+export function getTimestamp(date: Date): string {
     let second = date.getUTCSeconds()
     let minute = date.getUTCMinutes()
     let hour = date.getUTCHours()
     let day = date.getUTCDate()
-    let month = date.getUTCMonth() + 1 //January is 0!
+    let month = date.getUTCMonth() + 1 // January is 0!
     const year = date.getUTCFullYear()
 
     if (second < 10) {
-        second = "0" + second
+        second = Number("0" + second)
     }
     if (minute < 10) {
-        minute = "0" + minute
+        minute = Number("0" + minute)
     }
     if (hour < 10) {
-        hour = "0" + hour
+        hour = Number("0" + hour)
     }
     if (day < 10) {
-        day = "0" + day
+        day = Number("0" + day)
     }
     if (month < 10) {
-        month = "0" + month
+        month = Number("0" + month)
     }
 
     return `${year}-${month}-${day}T${hour}:${minute}:${second}Z`
 }
 
-export function getFontMimeType(filename) {
+export function getFontMimeType(filename: string): string | null {
     // Define a mapping of font file extensions to MIME types
-    const fontMimeTypes = {
+    const fontMimeTypes: Record<string, string> = {
         ttf: "font/ttf",
         otf: "font/otf",
         woff: "font/woff",
@@ -36,15 +36,15 @@ export function getFontMimeType(filename) {
     }
 
     // Extract the file extension from the filename
-    const extension = filename.split(".").pop().toLowerCase()
+    const extension = filename.split(".").pop()?.toLowerCase()
 
     // Check if the extension matches a known font type and return the MIME type
-    return fontMimeTypes[extension] || null // Return null if it's not a font file
+    return extension ? fontMimeTypes[extension] || null : null
 }
 
-export function getImageMimeType(filename) {
+export function getImageMimeType(filename: string): string | null {
     // Define a mapping of image file extensions to MIME types
-    const imageMimeTypes = {
+    const imageMimeTypes: Record<string, string> = {
         jpg: "image/jpeg",
         jpeg: "image/jpeg",
         png: "image/png",
@@ -58,36 +58,42 @@ export function getImageMimeType(filename) {
     }
 
     // Extract the file extension from the filename
-    const extension = filename.split(".").pop().toLowerCase()
+    const extension = filename.split(".").pop()?.toLowerCase()
 
     // Check if the extension matches a known image type and return the MIME type
-    return imageMimeTypes[extension] || null // Return null if it's not an image file
+    return extension ? imageMimeTypes[extension] || null : null
 }
 
-export function buildHierarchy(flatList) {
-    const hierarchy = []
-    const levelMap = {}
+export interface HierarchyItem extends Record<string, unknown> {
+    id: string
+    title: string
+    level: number
+    link?: string
+    docNum?: number
+    children: HierarchyItem[]
+}
+
+export function buildHierarchy(flatList: HierarchyItem[]): HierarchyItem[] {
+    const hierarchy: HierarchyItem[] = []
+    const levelMap: Record<number, HierarchyItem[]> = {}
 
     flatList.forEach(item => {
         // Ensure there's an array for the current level in the map
         levelMap[item.level] = levelMap[item.level] || []
 
         // Add the current item to its level in the map
-        levelMap[item.level].push({...item, children: []})
+        const itemWithChildren: HierarchyItem = {...item, children: []}
+        levelMap[item.level].push(itemWithChildren)
 
         if (item.level === 0) {
             // Top-level items are added directly to the hierarchy
-            hierarchy.push(
-                levelMap[item.level][levelMap[item.level].length - 1]
-            )
+            hierarchy.push(itemWithChildren)
         } else {
             // Non-top-level items are added as children of the last item at the previous level
             const parentLevel = levelMap[item.level - 1]
             if (parentLevel) {
                 const parent = parentLevel[parentLevel.length - 1]
-                parent.children.push(
-                    levelMap[item.level][levelMap[item.level].length - 1]
-                )
+                parent.children.push(itemWithChildren)
             }
         }
     })

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

@@ -1,9 +1,34 @@
-import {FormatCitations} from "../../citations/format.js"
 import {escapeText} from "fwtoolkit"
+
+import {FormatCitations} from "../../citations/format.js"
 import {BIBLIOGRAPHY_HEADERS} from "../../schema/i18n.js"
+import type {BibDB, CSL, DocSettings} from "../../types.js"
+
+interface CitationLayout {
+    prefix?: string
+    suffix?: string
+    delimiter?: string
+}
+
+interface CSLStyleChild {
+    name: string
+    children?: CSLStyleChild[]
+    attrs?: Record<string, unknown>
+}
 
 export class HTMLExporterCitations {
-    constructor(docSettings, bibDB, csl) {
+    docSettings: DocSettings
+    bibDB: BibDB
+    csl: CSL
+
+    citationTexts: string[]
+    citFm: FormatCitations | false
+    bibHTML: string
+    bibCSS: string
+    htmlIdConvert: Record<string, number>
+    citInfos: Record<string, unknown>[]
+
+    constructor(docSettings: DocSettings, bibDB: BibDB, csl: CSL) {
         this.docSettings = docSettings
         this.bibDB = bibDB
         this.csl = csl
@@ -13,9 +38,15 @@ export class HTMLExporterCitations {
         this.bibHTML = ""
         this.bibCSS = ""
         this.htmlIdConvert = {}
+        this.citInfos = []
     }
 
-    async init(citInfos) {
+    async init(citInfos: Record<string, unknown>[]): Promise<{
+        type: string
+        bibCSS: string
+        bibHTML: string
+        citationTexts: string[]
+    }> {
         this.citInfos = citInfos
         if (!citInfos.length) {
             return this.getOutput()
@@ -24,7 +55,12 @@ export class HTMLExporterCitations {
         return this.getOutput()
     }
 
-    getOutput() {
+    getOutput(): {
+        type: string
+        bibCSS: string
+        bibHTML: string
+        citationTexts: string[]
+    } {
         return {
             type: this.citFm ? this.citFm.citationType : "",
             bibCSS: this.bibCSS,
@@ -35,46 +71,58 @@ export class HTMLExporterCitations {
 
     // Citations are highly interdependent -- so we need to format them all
     // together before laying out the document.
-    async formatCitations() {
+    async formatCitations(): Promise<void> {
+        if (!this.csl.getStyle) {
+            return
+        }
         const citationstyle = await this.csl.getStyle(
-            this.docSettings.citationstyle
+            this.docSettings.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
-        const origCitationLayout = JSON.parse(JSON.stringify(citationLayout))
+            .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.docSettings.language
         )
+        this.citFm = citFm
 
-        await this.citFm.init()
+        await (citFm.init() as Promise<void>)
 
         // We need to add 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 html bibliography are 1 and up in this order
-        this.citFm.bibliography[0].entry_ids.forEach(
+        const bibliography = citFm.bibliography
+        if (!bibliography) {
+            return
+        }
+        bibliography[0].entry_ids.forEach(
             (id, index) => (this.htmlIdConvert[id] = index + 1)
         )
-        this.citationTexts = this.citFm.citationTexts.map((ref, index) => {
+        this.citationTexts = citFm.citationTexts.map((ref, index) => {
             const content = ref
                 .split("{{delimiter}}")
                 .map((citationText, conIndex) => {
                     const prefixSplit = citationText.split("{{prefix}}")
                     const prefix =
                         prefixSplit.length > 1
-                            ? prefixSplit.shift() +
+                            ? prefixSplit.shift()! +
                               (origCitationLayout.prefix || "")
                             : ""
                     citationText = prefixSplit[0]
@@ -82,11 +130,11 @@ export class HTMLExporterCitations {
                     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 htmlId = this.htmlIdConvert[citId]
                     return `${prefix}<a class="bibliography" href="#ref-${htmlId}">${citationText}</a>${suffix}`
                 })
@@ -95,27 +143,27 @@ export class HTMLExporterCitations {
         })
 
         if (
-            this.citFm.bibliography?.length &&
-            this.citFm.bibliography[0].entry_ids.length
+            bibliography?.length &&
+            bibliography[0].entry_ids.length
         ) {
-            this.assembleBib()
+            this.assembleBib(citFm, bibliography)
         }
     }
 
-    assembleBib() {
+    assembleBib(citFm: FormatCitations, bibliography: import("../../types.js").BibliographyResult): void {
         const bibliographyHeader =
-            this.docSettings.bibliography_header[this.docSettings.language] ||
-            BIBLIOGRAPHY_HEADERS[this.docSettings.language]
-        let bibHTML = `<h1 class="doc-bibliography-header">${escapeText(bibliographyHeader)}</h1>`
-        bibHTML += this.citFm.bibliography[0].bibstart
-        bibHTML += this.citFm.bibliography[1]
+            (this.docSettings.bibliography_header as Record<string, string> | undefined)?.[this.docSettings.language || "en-US"] ||
+            (BIBLIOGRAPHY_HEADERS as Record<string, string>)[this.docSettings.language || "en-US"]
+        let bibHTML = `<h1 class="doc-bibliography-header">${escapeText(bibliographyHeader || "Bibliography")}</h1>`
+        bibHTML += bibliography[0].bibstart
+        bibHTML += bibliography[1]
             .map(
                 (reference, index) =>
                     `<div id="ref-${index + 1}">${reference}</div>`
             )
             .join("")
-        bibHTML += this.citFm.bibliography[0].bibend
+        bibHTML += bibliography[0].bibend
         this.bibHTML = bibHTML
-        this.bibCSS = this.citFm.bibCSS
+        this.bibCSS = citFm.bibCSS
     }
 }