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

package/src/importer/pandoc/index.ts

@@ -0,0 +1,171 @@
+import {escapeText} from "fwtoolkit"
+
+import {PandocConvert} from "./convert.js"
+import {NativeImporter} from "../native/importer.js"
+
+import type {
+    BibDBEntry,
+    E2EEOptions,
+    FidusNode,
+    NativeImporterBackend,
+    User
+} from "../../types.js"
+
+interface PandocImporterOptions {
+    getTemplate: (importId: string | number | null) => Promise<Record<string, unknown>>
+    importBibliography: (bibString: string) => Promise<Record<string, BibDBEntry>>
+    nativeBackend: NativeImporterBackend
+    e2eeOptions?: E2EEOptions | null
+}
+
+export class PandocImporter {
+    file: Blob
+    user: User
+    path: string
+    importId: string | number | null
+    additionalFiles: Record<string, any>
+    e2eeOptions: E2EEOptions | null
+    getTemplate: (importId: string | number | null) => Promise<Record<string, unknown>>
+    importBibliography: (bibString: string) => Promise<Record<string, BibDBEntry>>
+    nativeBackend: NativeImporterBackend
+
+    template: Record<string, unknown> | null = null
+    output: {
+        ok: boolean
+        statusText: string
+        doc: Record<string, unknown> | null
+        docInfo: Record<string, unknown> | null
+    } = {
+        ok: false,
+        statusText: "",
+        doc: null,
+        docInfo: null
+    }
+    title = "Untitled"
+
+    constructor(
+        file: Blob,
+        user: User,
+        path: string,
+        importId: string | number | null,
+        options: PandocImporterOptions
+    ) {
+        this.file = file
+        this.user = user
+        this.path = path
+        this.importId = importId
+        this.additionalFiles = (options as PandocImporterOptions & {files?: Record<string, any>}).files || {}
+        this.e2eeOptions = options.e2eeOptions ?? null
+        this.getTemplate = options.getTemplate
+        this.importBibliography = options.importBibliography
+        this.nativeBackend = options.nativeBackend
+    }
+
+    async init(): Promise<typeof this.output> {
+        await this.getTemplate(this.importId)
+            .then(template => {
+                this.template = template
+            })
+            .catch(error => {
+                this.output.statusText = error.message
+            })
+        if (this.output.statusText) {
+            return this.output
+        }
+        const text = await this.file.text()
+        return this.handlePandocJson(
+            text,
+            this.additionalFiles?.images,
+            this.additionalFiles?.bibliography
+        )
+    }
+
+    handlePandocJson(
+        jsonString: string,
+        images: Record<string, Blob> = {},
+        bibString = ""
+    ): Promise<typeof this.output> {
+        let pandocJson
+        try {
+            pandocJson = JSON.parse(jsonString)
+        } catch (error: any) {
+            this.output.statusText = error.message
+            return Promise.resolve(this.output)
+        }
+
+        return this.importBibliography(bibString)
+            .then(bibliography => {
+                const converter = new PandocConvert(
+                    pandocJson,
+                    this.importId as string,
+                    this.template as {content: any},
+                    bibliography
+                )
+
+                let convertedDoc
+                try {
+                    convertedDoc = converter.init()
+                } catch (error: any) {
+                    this.output.statusText = error.message
+                    console.error(error)
+                    return this.output
+                }
+                const firstText =
+                    (convertedDoc.content as FidusNode).content?.[0].content?.[0]
+                        .text
+                if (["", "Untitled"].includes(firstText || "")) {
+                    ;(
+                        (convertedDoc.content as FidusNode).content![0]
+                            .content![0] as any
+                    ).text = this.title
+                } else {
+                    this.title = firstText || this.title
+                }
+
+                const nativeImporter = new NativeImporter(
+                    {
+                        content: convertedDoc.content,
+                        title: this.title,
+                        comments: {},
+                        settings: convertedDoc.settings
+                    },
+                    bibliography,
+                    converter.images as any,
+                    Object.entries(images).map(([filename, blob]) => ({
+                        filename,
+                        content: blob
+                    })),
+                    this.user,
+                    this.nativeBackend,
+                    {
+                        importId: null,
+                        requestedPath: this.path + this.title,
+                        template: null,
+                        e2eeOptions: this.e2eeOptions
+                    }
+                )
+
+                return nativeImporter
+                    .init()
+                    .then(({doc, docInfo}) => {
+                        this.output.ok = true
+                        this.output.doc = doc
+                        this.output.docInfo = docInfo
+                        this.output.statusText = `${escapeText(
+                            doc.title as string
+                        )} successfully imported.`
+                        return this.output
+                    })
+                    .catch(error => {
+                        this.output.statusText = error.message
+                        console.error(error)
+                        return this.output
+                    })
+            })
+            .catch(error => {
+                this.output.statusText = error.message
+                console.error(error)
+                return this.output
+            })
+    }
+}

package/src/importer/registry.ts

@@ -0,0 +1,69 @@
+import {ZipAnalyzer} from "./zip_analyzer.js"
+
+interface ImporterEntry {
+    importer: any
+    description: string
+}
+
+export class ImporterRegistry {
+    importers: Map<string, ImporterEntry>
+
+    constructor() {
+        this.importers = new Map()
+    }
+
+    register(
+        fileTypes: Array<[string, Array<string>]>,
+        importer: any
+    ): void {
+        fileTypes.forEach(([description, types]) => {
+            types.forEach(extension =>
+                this.importers.set(extension, {importer, description})
+            )
+        })
+    }
+
+    getZipImporter(zip: any): {
+        importer: any
+        getContents: () => ReturnType<ZipAnalyzer["getContents"]>
+    } | null {
+        const analyzer = new ZipAnalyzer(zip, this.getAllFormats())
+        const analysis = analyzer.analyze()
+
+        if (analysis.hasConvertible && analysis.format) {
+            return {
+                importer: this.getImporter(analysis.format)["importer"],
+                getContents: () => analyzer.getContents()
+            }
+        }
+
+        return null
+    }
+
+    getImporter(format: string): ImporterEntry {
+        return this.importers.get(format) as ImporterEntry
+    }
+
+    getAllFormats(): string[] {
+        return Array.from(this.importers.keys())
+    }
+
+    getAllDescriptions(): Record<string, string[]> {
+        return Array.from(this.importers).reduce(
+            (acc, [extension, {description}]) => {
+                ;(acc[description] = acc[description] || []).push(extension)
+                return acc
+            },
+            {} as Record<string, string[]>
+        )
+    }
+}
+
+export const importerRegistry = new ImporterRegistry()
+
+export function registerImporter(
+    fileTypes: Array<[string, Array<string>]>,
+    importer: any
+): void {
+    importerRegistry.register(fileTypes, importer)
+}

package/src/importer/{zip_analyzer.js → zip_analyzer.ts}

@@ -1,25 +1,49 @@
+import type JSZip from "jszip"
+
+interface ZipAnalysis {
+    hasConvertible: boolean
+    format: string | null
+    convertibleFile: {
+        path: string
+        entry: JSZip.JSZipObject
+        fileName: string
+        format: string
+    } | null
+    imageFiles: Array<{path: string; entry: JSZip.JSZipObject}>
+    bibFile: JSZip.JSZipObject | null
+}
+
+interface ZipContents {
+    images: Record<string, Blob>
+    bibliography: string | null
+    mainContent: File | null
+}
+
 export class ZipAnalyzer {
-    constructor(zip, formats = []) {
+    zip: JSZip
+    formats: string[]
+    analysis: ZipAnalysis | null
+
+    constructor(zip: JSZip, formats: string[] = []) {
         this.zip = zip
         this.formats = formats
-
         this.analysis = null
     }
 
-    analyze() {
+    analyze(): ZipAnalysis {
         if (this.analysis) {
             return this.analysis
         }
 
-        let convertibleFile = null
-        const imageFiles = []
-        let bibFile = null
+        let convertibleFile: ZipAnalysis["convertibleFile"] = null
+        const imageFiles: ZipAnalysis["imageFiles"] = []
+        let bibFile: JSZip.JSZipObject | null = null
 
         // Analyze all files in the ZIP
         this.zip.forEach((relativePath, zipEntry) => {
             if (!zipEntry.dir) {
-                const fileName = relativePath.split("/").pop()
-                const extension = fileName.split(".").pop().toLowerCase()
+                const fileName = relativePath.split("/").pop() || ""
+                const extension = fileName.split(".").pop()?.toLowerCase() || ""
 
                 if (extension === "bib") {
                     bibFile = zipEntry
@@ -52,7 +76,9 @@ export class ZipAnalyzer {
 
         this.analysis = {
             hasConvertible: Boolean(convertibleFile),
-            format: convertibleFile ? convertibleFile.format : null,
+            format: convertibleFile
+                ? (convertibleFile as Exclude<ZipAnalysis["convertibleFile"], null>).format
+                : null,
             convertibleFile,
             imageFiles,
             bibFile
@@ -61,29 +87,29 @@ export class ZipAnalyzer {
         return this.analysis
     }
 
-    async getContents() {
+    async getContents(): Promise<ZipContents> {
         if (!this.analysis) {
-            await this.analyze()
+            this.analyze()
         }
 
-        const contents = {
+        const contents: ZipContents = {
             images: {},
             bibliography: null,
             mainContent: null
         }
 
         // Load main content file
-        if (this.analysis.hasConvertible) {
+        if (this.analysis!.hasConvertible && this.analysis!.convertibleFile) {
             const mainBlob =
-                await this.analysis.convertibleFile.entry.async("blob")
+                await this.analysis!.convertibleFile.entry.async("blob")
             contents.mainContent = new File(
                 [mainBlob],
-                this.analysis.convertibleFile.fileName
+                this.analysis!.convertibleFile.fileName
             )
         }
 
         // Load images
-        const imagePromises = this.analysis.imageFiles.map(
+        const imagePromises = this.analysis!.imageFiles.map(
             async ({path, entry}) => {
                 const blob = await entry.async("blob")
                 contents.images[path] = blob
@@ -93,8 +119,8 @@ export class ZipAnalyzer {
         await Promise.all(imagePromises)
 
         // Load bibliography if present
-        if (this.analysis.bibFile) {
-            contents.bibliography = await this.analysis.bibFile.async("text")
+        if (this.analysis!.bibFile) {
+            contents.bibliography = await this.analysis!.bibFile.async("text")
         }
 
         return contents

package/src/mathlive/{opf_includes.js → opf_includes.ts}

@@ -21,4 +21,4 @@ export const mathliveOpfIncludes = `
 <item id="mathlive-18" href="css/media/KaTeX_Main-Regular.woff2" media-type="font/woff2" />
 <item id="mathlive-19" href="css/media/KaTeX_Math-Italic.woff2" media-type="font/woff2" />
 <item id="mathlive-20" href="css/media/KaTeX_Typewriter-Regular.woff2" media-type="font/woff2" />
-`
+`

package/src/modules.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ambient type declarations for dependencies that do not ship their own types.
+ */
+
+declare module "downloadjs" {
+    /**
+     * Trigger a browser download of the given data.
+     * @param data - File content (Blob or string).
+     * @param filename - Suggested filename for the download.
+     * @param mimeType - MIME type of the data.
+     */
+    function download(
+        data: Blob | string,
+        filename?: string,
+        mimeType?: string
+    ): void
+    export default download
+}
+
+declare module "pretty" {
+    /**
+     * Pretty-print HTML/XML markup.
+     * @param input - Markup string to format.
+     * @param options - Formatting options.
+     */
+    function pretty(input: string, options?: {ocd?: boolean}): string
+    export default pretty
+}
+
+declare module "@vivliostyle/print" {
+    /**
+     * Render the given HTML with Vivliostyle for printing.
+     * @param html - HTML content to print.
+     * @param config - Optional print configuration.
+     */
+    export function printHTML(
+        html: string,
+        config?: Record<string, unknown>
+    ): Promise<unknown>
+}

package/src/schema/common/{annotate.js → annotate.ts}

@@ -1,3 +1,5 @@
+import type {MarkSpec} from "prosemirror-model"
+
 // Annotation tag is not used by the core Fidus Writer editor, but can be used by plugins that need to add annotation capability.
 export const annotation_tag = {
     attrs: {
@@ -17,9 +19,9 @@ export const annotation_tag = {
     parseDOM: [
         {
             tag: "span.annotation-tag[data-type]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    type: dom.dataset.type,
+                    type: dom.dataset.type || "",
                     key: dom.dataset.key ? dom.dataset.key : "",
                     value: dom.dataset.value ? dom.dataset.value : ""
                 }
@@ -27,7 +29,7 @@ export const annotation_tag = {
         }
     ],
     toDOM(node) {
-        const attrs = {
+        const attrs: Record<string, unknown> = {
             class: "annotation-tag",
             "data-type": node.attrs.type
         }
@@ -39,7 +41,7 @@ export const annotation_tag = {
         }
         return ["span", attrs]
     }
-}
+} satisfies MarkSpec
 
 export const comment = {
     attrs: {
@@ -53,9 +55,9 @@ export const comment = {
     parseDOM: [
         {
             tag: "span.comment[data-id]",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    id: Number.parseInt(dom.dataset.id)
+                    id: Number.parseInt(dom.dataset.id || "0")
                 }
             }
         }
@@ -69,8 +71,8 @@ export const comment = {
             }
         ]
     }
-}
+} satisfies MarkSpec
 
-export function randomCommentId() {
+export function randomCommentId(): string {
     return String(Math.floor(Math.random() * 0xffffffff))
 }

package/src/schema/common/{base.js → base.ts}

@@ -1,3 +1,5 @@
+import type {MarkSpec, NodeSpec} from "prosemirror-model"
+
 import {parseTracks} from "./track.js"
 
 // :: NodeSpec A plain paragraph textblock. Represented in the DOM
@@ -13,7 +15,7 @@ export const paragraph = {
     parseDOM: [
         {
             tag: "p",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     track: parseTracks(dom.dataset.track)
                 }
@@ -27,7 +29,7 @@ export const paragraph = {
                 : {}
         return ["p", attrs, 0]
     }
-}
+} satisfies NodeSpec
 
 // :: NodeSpec A blockquote (`<blockquote>`) wrapping one or more blocks.
 export const blockquote = {
@@ -43,7 +45,7 @@ export const blockquote = {
     parseDOM: [
         {
             tag: "blockquote",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     track: parseTracks(dom.dataset.track)
                 }
@@ -57,7 +59,7 @@ export const blockquote = {
                 : {}
         return ["blockquote", attrs, 0]
     }
-}
+} satisfies NodeSpec
 
 // :: NodeSpec A horizontal rule (`<hr>`).
 export const horizontal_rule = {
@@ -70,7 +72,7 @@ export const horizontal_rule = {
     parseDOM: [
         {
             tag: "hr",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     track: parseTracks(dom.dataset.track)
                 }
@@ -84,14 +86,14 @@ export const horizontal_rule = {
                 : {}
         return ["hr", attrs]
     }
-}
+} satisfies NodeSpec
 
 export const underline = {
     parseDOM: [{tag: "span.underline"}],
     toDOM() {
         return ["span", {class: "underline"}, 0]
     }
-}
+} satisfies MarkSpec
 
 export const sup = {
     parseDOM: [{tag: "sup"}],
@@ -99,7 +101,7 @@ export const sup = {
         return ["sup", 0]
     },
     excludes: "sub"
-}
+} satisfies MarkSpec
 
 export const sub = {
     parseDOM: [{tag: "sub"}],
@@ -107,7 +109,7 @@ export const sub = {
         return ["sub", 0]
     },
     excludes: "sup"
-}
+} satisfies MarkSpec
 
 export const code = {
     parseDOM: [{tag: "code"}],
@@ -115,4 +117,4 @@ export const code = {
         return ["code", 0]
     },
     excludes: "strong em underline link sup sub"
-}
+} satisfies MarkSpec

package/src/schema/common/{citation.js → citation.ts}

@@ -1,8 +1,16 @@
-function parseReferences(str) {
+import type {NodeSpec} from "prosemirror-model"
+
+export interface CitationReference {
+    id: number
+    locator?: string
+    prefix?: string
+}
+
+function parseReferences(str: string | undefined): CitationReference[] {
     if (!str) {
         return []
     }
-    let references
+    let references: unknown
     try {
         references = JSON.parse(str)
     } catch (_error) {
@@ -13,15 +21,16 @@ function parseReferences(str) {
     }
     return references
         .filter(
-            ref => ref.hasOwnProperty("id") // ensure there is an id.
+            (ref): ref is Record<string, unknown> =>
+                typeof ref === "object" && ref !== null && Object.prototype.hasOwnProperty.call(ref, "id")
         )
         .map(ref => {
-            const mRef = {id: ref.id}
+            const mRef: CitationReference = {id: Number(ref.id)}
             if (ref.locator) {
-                mRef.locator = ref.locator
+                mRef.locator = String(ref.locator)
             }
             if (ref.prefix) {
-                mRef.prefix = ref.prefix
+                mRef.prefix = String(ref.prefix)
             }
             return mRef
         })
@@ -41,7 +50,7 @@ export const citation = {
     parseDOM: [
         {
             tag: "span.citation",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
                     format: dom.dataset.format || "",
                     references: parseReferences(dom.dataset.references)
@@ -59,4 +68,4 @@ export const citation = {
             }
         ]
     }
-}
+} satisfies NodeSpec

package/src/schema/common/{equation.js → equation.ts}

@@ -1,3 +1,5 @@
+import type {NodeSpec} from "prosemirror-model"
+
 export const equation = {
     inline: true,
     group: "inline",
@@ -9,9 +11,9 @@ export const equation = {
     parseDOM: [
         {
             tag: "span.equation",
-            getAttrs(dom) {
+            getAttrs(dom: HTMLElement) {
                 return {
-                    equation: dom.dataset.equation
+                    equation: dom.dataset.equation || ""
                 }
             }
         }
@@ -23,9 +25,9 @@ export const equation = {
         import("mathlive").then(MathLive => {
             dom.innerHTML = MathLive.convertLatexToMarkup(node.attrs.equation, {
                 mathstyle: "textstyle"
-            })
+            } as unknown as Record<string, unknown>)
         })
         dom.setAttribute("contenteditable", "false")
         return dom
     }
-}
+} satisfies NodeSpec