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

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

@@ -1,25 +1,42 @@
 import {printHTML} from "@vivliostyle/print"
-import {addAlert, shortFileTitle} from "fwtoolkit"
+import {addAlert, shortFileTitle, gettext, staticUrl} from "fwtoolkit"
+
 import {PAPER_SIZES} from "../../schema/const.js"
+import type {BibDB, CSL, ExportDoc, FidusNode, ImageDB} from "../../types.js"
 import {HTMLExporter} from "../html/index.js"
 import {HTMLExporterConvert} from "../html/convert.js"
 import {removeHidden} from "../tools/doc_content.js"
 
 export class PrintExporter extends HTMLExporter {
-    constructor(doc, bibDB, imageDB, csl, updated, documentStyles) {
+    constructor(
+        doc: ExportDoc,
+        bibDB: BibDB,
+        imageDB: ImageDB,
+        csl: CSL,
+        updated: unknown,
+        documentStyles: Array<{
+            slug: string
+            contents: string
+            documentstylefile_set: Array<[string, string]>
+        }>
+    ) {
         super(doc, bibDB, imageDB, csl, updated, documentStyles, {
             relativeUrls: false
         })
     }
 
-    async init() {
+    async init(): Promise<void> {
         addAlert(
             "info",
-            `${shortFileTitle(this.doc.title, this.doc.path)}: ${gettext("Printing has been initiated.")}`
+            `${shortFileTitle(this.doc.title, this.doc.path || "")}: ${gettext("Printing has been initiated.")}`
         )
-        this.docContent = removeHidden(this.doc.content)
+        this.docContent = removeHidden(this.doc.content) as FidusNode
 
-        const styleSheets = [
+        const styleSheets: Array<{
+            url?: string
+            contents?: string
+            filename?: string
+        }> = [
             {url: staticUrl("css/document.css")},
             {
                 contents: `a.footnote, a.affiliation {
@@ -84,7 +101,7 @@ export class PrintExporter extends HTMLExporter {
                     background-color: white;
                 }
                 @page {
-                    size: ${PAPER_SIZES.find(size => size[0] === this.doc.settings.papersize)[1]};
+                    size: ${(PAPER_SIZES.find(size => size[0] === this.doc.settings.papersize) || ["", "A4"])[1]};
                     @top-center {
                         content: env(doc-title);
                     }
@@ -121,18 +138,20 @@ export class PrintExporter extends HTMLExporter {
 
         const {html, metaData} = await this.converter.init()
 
-        const config = {title: metaData.title}
+        const config: {title?: string; printCallback?: (iframeWin: Window) => void} = {
+            title: metaData.title
+        }
 
         if (navigator.userAgent.includes("Gecko/")) {
             // Firefox has issues printing images when in iframe. This workaround can be
             // removed once that has been fixed. TODO: Add gecko bug number if there is one.
             config.printCallback = iframeWin => {
                 const oldBody = document.body
-                document.body.parentElement.dataset.vivliostylePaginated = true
+                document.body.parentElement!.dataset.vivliostylePaginated = "true"
                 document.body = iframeWin.document.body
                 document.body
                     .querySelectorAll("figure, table")
-                    .forEach(el => delete el.dataset.category)
+                    .forEach(el => delete (el as HTMLElement).dataset.category)
                 iframeWin.document
                     .querySelectorAll("style")
                     .forEach(el => document.body.appendChild(el))
@@ -141,33 +160,33 @@ export class PrintExporter extends HTMLExporter {
                 document.body.appendChild(backgroundStyle)
                 window.print()
                 document.body = oldBody
-                delete document.body.parentElement.dataset.vivliostylePaginated
+                delete document.body.parentElement!.dataset.vivliostylePaginated
             }
         }
-        return printHTML(html, config)
+        await printHTML(html, config)
     }
 
-    getDocStyle(doc) {
+    getDocStyle(doc: ExportDoc): {contents: string; filename: string} | false {
         // Override the default as we need to use the original URLs in print.
         const docStyle = this.documentStyles.find(
-            docStyle => docStyle.slug === doc.settings.documentstyle
+            (ds: {slug: string}) => ds.slug === doc.settings.documentstyle
         )
         if (!docStyle) {
-            return
+            return false
         }
 
         let contents = docStyle.contents
         docStyle.documentstylefile_set.forEach(
-            ([url, filename]) =>
+            ([url, filename]: [string, string]) =>
                 (contents = contents.replace(
                     new RegExp(filename, "g"),
-                    new URL(url, window.location).href
+                    new URL(url, window.location.href).href
                 ))
         )
-        return {contents}
+        return {contents, filename: ""}
     }
 
-    loadStyle(sheet) {
+    loadStyle(sheet: {url?: string; filename?: string; contents?: string}): Promise<void> {
         if (sheet.url) {
             sheet.filename = sheet.url
             delete sheet.url

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

@@ -1,8 +1,10 @@
+import type {FidusNode} from "../../types.js"
+
 // Return a json that is the same as the existing json, but with all parts
 // marked as hidden removed.
 
 export const removeHidden = (
-    node,
+    node: FidusNode,
     // Whether to leave the outer part of the removed node.
     // True for tree-walking exporters, false for DOM-changing exporters.
     leaveStub = true,
@@ -10,12 +12,12 @@ export const removeHidden = (
     removeTableCaptionText = false,
     removeFigureCaption = false,
     removeFigureCaptionText = false
-) => {
-    const returnNode = {}
+): FidusNode | false => {
+    const returnNode: FidusNode = {type: node.type}
 
     Object.keys(node).forEach(key => {
         if (key !== "content") {
-            returnNode[key] = node[key]
+            ;(returnNode as unknown as Record<string, unknown>)[key] = (node as unknown as Record<string, unknown>)[key]
         }
     })
     if (node.attrs?.hidden) {
@@ -60,15 +62,15 @@ export const removeHidden = (
                 removeFigureCaptionText
             )
             if (cleanedChild) {
-                returnNode.content.push(cleanedChild)
+                returnNode.content!.push(cleanedChild)
             }
         })
     }
     return returnNode
 }
 
-export const descendantNodes = node => {
-    let returnValue = [node]
+export const descendantNodes = (node: FidusNode): FidusNode[] => {
+    let returnValue: FidusNode[] = [node]
     if (node.content) {
         node.content.forEach(childNode => {
             returnValue = returnValue.concat(descendantNodes(childNode))
@@ -77,7 +79,7 @@ export const descendantNodes = node => {
     return returnValue
 }
 
-export const textContent = node =>
+export const textContent = (node: FidusNode): string =>
     descendantNodes(node).reduce((returnString, subNode) => {
         if (subNode.text) {
             returnString += subNode.text
@@ -88,43 +90,51 @@ export const textContent = node =>
 // PM/HTML don't have cells that have been covered, but in ODT/DOCX, these cells
 // need to be present. So we add them.
 
-const addCoveredTableCells = node => {
-    const columns = node.content[0].content.reduce(
-        (columns, cell) => columns + cell.attrs.colspan,
+interface TableCellAttrs {
+    rowspan?: number
+    colspan?: number
+    [key: string]: unknown
+}
+
+const addCoveredTableCells = (node: FidusNode): void => {
+    const rows = node.content!
+    const columns = (rows[0].content || []).reduce(
+        (cols, cell) => cols + ((cell.attrs?.colspan as number) || 1),
         0
     )
-    const rows = node.content.length
     // Add empty cells for col/rowspan
-    const fixedTableMatrix = Array.apply(0, {length: rows}).map(_item => ({
+    const fixedTableMatrix: FidusNode[] = Array.from({length: rows.length}, () => ({
         type: "table_row",
-        content: Array.apply(0, {length: columns})
+        content: Array.from({length: columns}, () => ({} as FidusNode))
     }))
     let rowIndex = -1
-    node.content.forEach(row => {
+    rows.forEach(row => {
         let columnIndex = 0
         rowIndex++
         if (!row.content) {
             return
         }
         row.content.forEach(cell => {
-            while (fixedTableMatrix[rowIndex].content[columnIndex]) {
+            while (fixedTableMatrix[rowIndex].content![columnIndex]) {
                 columnIndex++
             }
-            for (let i = 0; i < cell.attrs.rowspan; i++) {
-                for (let j = 0; j < cell.attrs.colspan; j++) {
-                    let fixedCell
+            const rowspan = ((cell.attrs as TableCellAttrs)?.rowspan as number) || 1
+            const colspan = ((cell.attrs as TableCellAttrs)?.colspan as number) || 1
+            for (let i = 0; i < rowspan; i++) {
+                for (let j = 0; j < colspan; j++) {
+                    let fixedCell: FidusNode
                     if (i === 0 && j === 0) {
                         fixedCell = cell
                     } else {
                         fixedCell = {
                             type: "table_cell",
                             attrs: {
-                                rowspan: cell.attrs.rowspan > 1 ? 0 : 1,
-                                colspan: cell.attrs.colspan > 1 ? 0 : 1
-                            }
+                                rowspan: rowspan > 1 ? 0 : 1,
+                                colspan: colspan > 1 ? 0 : 1
+                            } as TableCellAttrs
                         }
                     }
-                    fixedTableMatrix[rowIndex + i].content[columnIndex + j] =
+                    fixedTableMatrix[rowIndex + i].content![columnIndex + j] =
                         fixedCell
                 }
             }
@@ -133,7 +143,7 @@ const addCoveredTableCells = node => {
     node.content = fixedTableMatrix
 }
 
-export const fixTables = node => {
+export const fixTables = (node: FidusNode): FidusNode => {
     if (node.type === "table_body") {
         addCoveredTableCells(node)
     }

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

@@ -1,4 +1,4 @@
-export const createSlug = str => {
+export const createSlug = (str: string): string => {
     if (str === "") {
         str = gettext("Untitled")
     }

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

@@ -1,6 +1,13 @@
-/** Same functionality as objToNode/nodeToObj in diffDOM.js, but also offers output in XHTML format (obj2Node) and without form support. */
-export const obj2Node = (obj, docType) => {
-    let parser
+import type {NativeDomNode} from "../../types.js"
+
+/** Same functionality as objToNode/nodeToObj in diffDOM.js, but also offers
+ *  output in XHTML format (obj2Node) and without form support.
+ */
+export const obj2Node = (
+    obj: NativeDomNode | undefined,
+    docType?: "xhtml"
+): Node | false => {
+    let parser: Document
     if (obj === undefined) {
         return false
     }
@@ -10,28 +17,28 @@ export const obj2Node = (obj, docType) => {
         parser = document
     }
 
-    function inner(obj, insideSvg) {
-        let node
-        if (obj.hasOwnProperty("t")) {
-            node = parser.createTextNode(obj.t)
-        } else if (obj.hasOwnProperty("co")) {
-            node = parser.createComment(obj.co)
+    function inner(obj: NativeDomNode, insideSvg = false): Node {
+        let node: Node
+        if (Object.prototype.hasOwnProperty.call(obj, "t")) {
+            node = parser.createTextNode(obj.t as string)
+        } else if (Object.prototype.hasOwnProperty.call(obj, "co")) {
+            node = parser.createComment(obj.co as string)
         } else {
             if (obj.nn === "svg" || insideSvg) {
                 node = parser.createElementNS(
                     "http://www.w3.org/2000/svg",
-                    obj.nn
+                    obj.nn as string
                 )
                 insideSvg = true
             } else if (obj.nn === "script") {
                 // Do not allow scripts
                 return parser.createTextNode("")
             } else {
-                node = parser.createElement(obj.nn.toLowerCase())
+                node = parser.createElement((obj.nn as string).toLowerCase())
             }
             if (obj.a) {
                 for (let i = 0; i < obj.a.length; i++) {
-                    node.setAttribute(obj.a[i][0], obj.a[i][1])
+                    ;(node as Element).setAttribute(obj.a[i][0], obj.a[i][1])
                 }
             }
             if (obj.c) {
@@ -45,19 +52,23 @@ export const obj2Node = (obj, docType) => {
     return inner(obj)
 }
 
-export const node2Obj = node => {
-    const obj = {}
+export const node2Obj = (node: Node): NativeDomNode => {
+    const obj: NativeDomNode = {}
 
     if (node.nodeType === 3) {
-        obj.t = node.data
+        obj.t = (node as Text).data
     } else if (node.nodeType === 8) {
-        obj.co = node.data
+        obj.co = (node as Comment).data
     } else {
         obj.nn = node.nodeName
-        if (node.attributes?.length > 0) {
+        const element = node as Element
+        if (element.attributes?.length > 0) {
             obj.a = []
-            for (let i = 0; i < node.attributes.length; i++) {
-                obj.a.push([node.attributes[i].name, node.attributes[i].value])
+            for (let i = 0; i < element.attributes.length; i++) {
+                obj.a.push([
+                    element.attributes[i].name,
+                    element.attributes[i].value
+                ])
             }
         }
         if (node.childNodes?.length > 0) {

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

@@ -1,6 +1,12 @@
 import {convertDataURIToBlob} from "fwtoolkit"
 
-export function svg2png(blob) {
+interface Svg2pngResult {
+    blob: Blob
+    width: number
+    height: number
+}
+
+export function svg2png(blob: Blob): Promise<Svg2pngResult> {
     const img = document.createElement("img")
     const src = URL.createObjectURL(blob)
     img.src = src
@@ -8,7 +14,7 @@ export function svg2png(blob) {
     return new Promise(resolve => {
         img.onload = function onload() {
             const canvas = document.createElement("canvas")
-            const ctx = canvas.getContext("2d")
+            const ctx = canvas.getContext("2d")!
             const ratio = Math.min(
                 Math.min(img.width, img.height) / img.width,
                 Math.min(img.width, img.height) / img.height
@@ -19,7 +25,7 @@ export function svg2png(blob) {
             canvas.height = height
             ctx.drawImage(img, 0, 0, width, height)
             const src = canvas.toDataURL("image/png")
-            img.parentElement.removeChild(img)
+            img.parentElement!.removeChild(img)
             URL.revokeObjectURL(src)
             const pngBlob = convertDataURIToBlob(src)
             resolve({blob: pngBlob, width, height})