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

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

@@ -1,11 +1,19 @@
-import {xmlDOM} from "./xml.js"
-
 import {get} from "fwtoolkit"
+
+import {xmlDOM, XMLElement} from "./xml.js"
+
 // Handle a zip file containing XML files. Make sure files are only opened once,
 // and provide a mechanism to save the file.
 
 export class XmlZip {
-    constructor(url, mimeType) {
+    url: string
+    mimeType: string
+    docs: Record<string, XMLElement>
+    extraFiles: Record<string, unknown>
+    rawFile: Blob | false
+    zip: any
+
+    constructor(url: string, mimeType: string) {
         this.url = url
         this.mimeType = mimeType
         this.docs = {}
@@ -33,7 +41,7 @@ export class XmlZip {
     }
 
     // Open file at filePath from zip file and parse it as XML.
-    getXml(filePath, defaultContents) {
+    getXml(filePath: string, defaultContents?: string): Promise<XMLElement> {
         if (this.docs[filePath]) {
             // file has been loaded already.
             return Promise.resolve(this.docs[filePath])
@@ -41,7 +49,7 @@ export class XmlZip {
             return this.zip
                 .file(filePath)
                 .async("string")
-                .then(string => {
+                .then((string: string) => {
                     this.docs[filePath] = xmlDOM(string)
                     return Promise.resolve(this.docs[filePath])
                 })
@@ -57,36 +65,36 @@ export class XmlZip {
     }
 
     // Add an xml file at filepath without checking for previous version
-    addXmlFile(filePath, xmlContents) {
+    addXmlFile(filePath: string, xmlContents: XMLElement): void {
         this.docs[filePath] = xmlContents
     }
 
     // Add extra file to be saved in zip later.
-    addExtraFile(filePath, fileContents) {
+    addExtraFile(filePath: string, fileContents: unknown): void {
         this.extraFiles[filePath] = fileContents
     }
 
     // Put all currently open XML files into zip.
-    allXMLToZip() {
+    allXMLToZip(): void {
         for (const fileName in this.docs) {
             this.xmlToZip(fileName)
         }
     }
 
     // Put all extra files into zip.
-    allExtraToZip() {
+    allExtraToZip(): void {
         for (const fileName in this.extraFiles) {
             this.zip.file(fileName, this.extraFiles[fileName])
         }
     }
 
     // Put the xml identified by filePath into zip.
-    xmlToZip(filePath) {
+    xmlToZip(filePath: string): void {
         const string = this.docs[filePath].toString()
         this.zip.file(filePath, string)
     }
 
-    prepareBlob() {
+    prepareBlob(): Promise<Blob> {
         this.allXMLToZip()
         this.allExtraToZip()
 

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

@@ -1,18 +1,42 @@
-import {convertDataURIToBlob, get} from "fwtoolkit"
+import {convertDataURIToBlob as convertDataURIToBlobFn, get} from "fwtoolkit"
+
+export interface ZipTextFile {
+    filename: string
+    contents: string
+}
+
+export interface ZipBinaryFile {
+    url: string
+    filename: string
+    blob?: Blob
+}
+
+export interface ZipIncludeFile {
+    url: string
+    directory: string
+    blob?: Blob
+}
 
 /** Creates a zip file.
  * @function zipFileCreator
- * @param {list} textFiles A list of files in plain text format.
- * @param {list} binaryFiles A list fo files that have to be downloaded from the internet before being included.
- * @param {list} includeZips A list of zip files to be merged into the output zip file.
- * @param {string} [mimeType=application/zip] The mimetype of the file that is to be created.
+ * @param textFiles A list of files in plain text format.
+ * @param binaryFiles A list fo files that have to be downloaded from the internet before being included.
+ * @param includeZips A list of zip files to be merged into the output zip file.
+ * @param mimeType The mimetype of the file that is to be created.
  */
 
 export class ZipFileCreator {
+    textFiles: ZipTextFile[]
+    binaryFiles: ZipBinaryFile[]
+    zipFiles: ZipIncludeFile[]
+    mimeType: string
+    date: Date
+    zipFs: any
+
     constructor(
-        textFiles = [],
-        binaryFiles = [],
-        zipFiles = [],
+        textFiles: ZipTextFile[] = [],
+        binaryFiles: ZipBinaryFile[] = [],
+        zipFiles: ZipIncludeFile[] = [],
         mimeType = "application/zip",
         date = new Date()
     ) {
@@ -25,7 +49,7 @@ export class ZipFileCreator {
 
     init() {
         return import("jszip").then(({default: JSZip}) => {
-            JSZip.defaults.date = this.date
+            ;(JSZip as any).defaults.date = this.date
             this.zipFs = new JSZip()
             if (this.mimeType !== "application/zip") {
                 this.zipFs.file("mimetype", this.mimeType, {
@@ -84,7 +108,7 @@ export class ZipFileCreator {
     }
 
     // Legacy - remove in 3.12. Can be sued directly from function in common/blob.js
-    convertDataURIToBlob(dataURI) {
-        return convertDataURIToBlob(dataURI)
+    convertDataURIToBlob(dataURI: string): Blob {
+        return convertDataURIToBlobFn(dataURI)
     }
 }

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

@@ -6,11 +6,28 @@
 
 import {CSLExporter} from "biblatex-csl-converter"
 
+import type {BibDB} from "../../types.js"
+
+interface CitationReference {
+    id: number
+    locator?: string
+    prefix?: string
+    item?: Record<string, unknown>
+}
+
+interface ZoteroCitationItem {
+    id: number
+    uris: string[]
+    itemData: Record<string, unknown>
+    locator?: string
+    prefix?: string
+}
+
 /**
  * Generate a random citation ID similar to Zotero's format.
  * Zotero uses 8-10 character alphanumeric IDs.
  */
-function generateCitationId() {
+function generateCitationId(): string {
     const chars = "abcdefghijklmnopqrstuvwxyz0123456789"
     let id = ""
     for (let i = 0; i < 8; i++) {
@@ -21,29 +38,29 @@ function generateCitationId() {
 
 /**
  * Convert bibliography entries to CSL-JSON format.
- * @param {Object} bibDB - The bibliography database
- * @param {Array} ids - Array of entry IDs to convert
- * @returns {Object} Object mapping IDs to CSL-JSON entries
+ * @param bibDB - The bibliography database
+ * @param ids - Array of entry IDs to convert
+ * @returns Object mapping IDs to CSL-JSON entries
  */
-function convertToCSL(bibDB, ids) {
-    const exporter = new CSLExporter(bibDB.db, ids)
+function convertToCSL(bibDB: BibDB, ids: number[]): Record<string, unknown> {
+    const exporter = new CSLExporter(bibDB.db as Record<string, any>, ids as unknown as string[])
     return exporter.parse()
 }
 
 /**
  * Create a Zotero citation JSON object.
- * @param {Array} references - Array of {id, prefix?, locator?} from citation node
- * @param {Object} bibDB - Bibliography database
- * @param {string} formattedCitation - Pre-formatted citation text from citeproc
- * @param {string} citationId - Optional citation ID (generated if not provided)
- * @returns {Object} Zotero citation JSON object
+ * @param references - Array of {id, prefix?, locator?} from citation node
+ * @param bibDB - Bibliography database
+ * @param formattedCitation - Pre-formatted citation text from citeproc
+ * @param citationId - Optional citation ID (generated if not provided)
+ * @returns Zotero citation JSON object
  */
 export function createZoteroCitation(
-    references,
-    bibDB,
-    formattedCitation,
-    citationId = null
-) {
+    references: CitationReference[],
+    bibDB: BibDB,
+    formattedCitation: string,
+    citationId: string | null = null
+): Record<string, unknown> {
     const citationID = citationId || generateCitationId()
 
     // Get the IDs of all referenced items
@@ -59,7 +76,7 @@ export function createZoteroCitation(
                 return null
             }
             const citationKey = entry.entry_key || String(ref.id)
-            const item = {
+            const item: ZoteroCitationItem = {
                 id: ref.id,
                 uris: [],
                 itemData: {
@@ -78,7 +95,7 @@ export function createZoteroCitation(
 
             return item
         })
-        .filter(item => item !== null)
+        .filter((item): item is ZoteroCitationItem => item !== null)
 
     return {
         citationID,

package/src/global.d.ts

@@ -9,3 +9,5 @@ declare function interpolate(
     args: Array<string | number>,
     named?: boolean
 ): string
+
+declare function staticUrl(path: string): string

package/src/importer/citations.ts

@@ -0,0 +1,116 @@
+/**
+ * Shared citation utilities for DOCX and ODT importers.
+ */
+
+import type {BibDB, FidusNode} from "../types.js"
+
+interface CitationEntry {
+    entry_key: string
+    fields: Record<string, unknown>
+    bib_type?: string
+    [key: string]: unknown
+}
+
+interface CitationMetadata {
+    entry_key: string
+    prefix?: string
+    suffix?: string
+    locator?: string
+    authorOnly?: boolean
+    authorYear?: boolean
+    suppressAuthor?: boolean
+    [key: string]: unknown
+}
+
+interface CitationResult {
+    isCitation: boolean
+    entries: Record<string, CitationEntry>
+    metadata?: CitationMetadata[]
+}
+
+function mergeBibEntries(
+    entries: Record<string, CitationEntry>,
+    bibliography: Record<string, CitationEntry>,
+    bibDB: BibDB | false
+): Record<string, string> {
+    const keyMap: Record<string, string> = {}
+
+    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) as Array<Record<string, any>>).find(
+                    bibEntry => bibEntry && bibEntry.entry_key === entryKey
+                )
+                if (bibEntry) {
+                    entry.fields = JSON.parse(JSON.stringify(bibEntry.fields))
+                    entry.bib_type = bibEntry.bib_type as string
+                }
+            }
+            // 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
+}
+
+export function citationResultToNode(
+    result: CitationResult,
+    bibliography: Record<string, any>,
+    bibDB: BibDB | false = false
+): FidusNode | null {
+    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)
+
+    const references = Object.entries(entries).map(([, 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
+    }
+
+    const format =
+        metadata.length === 1 &&
+        (metadata[0].authorOnly || metadata[0].authorYear)
+            ? "textcite"
+            : "autocite"
+
+    return {
+        type: "citation",
+        attrs: {
+            format,
+            references
+        }
+    }
+}

package/src/importer/docx/{citations.js → citations.ts}

@@ -1,15 +1,15 @@
 import {DocxCitationsParser} from "biblatex-csl-converter"
+
 import {citationResultToNode} from "../citations.js"
+import type {BibDB, FidusNode} from "../../types.js"
+import type {XMLElement} from "../../exporter/tools/xml.js"
 
 /**
  * Check whether a field instruction string belongs to a citation.
  * Uses DocxCitationsParser.fieldCitation() with retrieve=false so no BibDB
  * is allocated for the check.
- *
- * @param {string} instrText - Concatenated w:instrText content
- * @returns {boolean}
  */
-export function isDocxCitationField(instrText) {
+export function isDocxCitationField(instrText: string): boolean {
     if (!instrText) {
         return false
     }
@@ -21,11 +21,8 @@ export function isDocxCitationField(instrText) {
  * (Zotero ZOTERO_BIBL, Word native BIBLIOGRAPHY, EN.REFLIST, etc.).
  * Uses DocxCitationsParser.fieldBibliography() with the accumulated
  * instruction text between begin and separate markers.
- *
- * @param {string} instrText - Concatenated w:instrText content
- * @returns {boolean}
  */
-export function isDocxBibliographyField(instrText) {
+export function isDocxBibliographyField(instrText: string): boolean {
     if (!instrText) {
         return false
     }
@@ -36,11 +33,10 @@ export function isDocxBibliographyField(instrText) {
 /**
  * Check whether a w:sdt node contains a citation (Mendeley v3, Citavi).
  * Uses DocxCitationsParser.sdtCitation() with retrieve=false.
- *
- * @param {Object} sdtNode - The parsed w:sdt XMLElement node
- * @returns {boolean}
  */
-export function isDocxSdtCitation(sdtNode) {
+export function isDocxSdtCitation(
+    sdtNode: XMLElement | null | undefined
+): boolean {
     if (!sdtNode) {
         return false
     }
@@ -51,11 +47,10 @@ export function isDocxSdtCitation(sdtNode) {
  * Check whether a w:sdt node is a bibliography rendering region
  * (Mendeley v3 bibliography, Citavi bibliography).
  * Uses DocxCitationsParser.sdtBibliography().
- *
- * @param {Object} sdtNode - The parsed w:sdt XMLElement node
- * @returns {boolean}
  */
-export function isDocxSdtBibliography(sdtNode) {
+export function isDocxSdtBibliography(
+    sdtNode: XMLElement | null | undefined
+): boolean {
     if (!sdtNode) {
         return false
     }
@@ -69,21 +64,13 @@ export function isDocxSdtBibliography(sdtNode) {
  * Handles all field-based citation managers: Zotero, Mendeley Desktop
  * (legacy), EndNote (both inline and fldData forms), Citavi (older ADDIN
  * form), and Word native (requires sourcesXml).
- *
- * @param {string}      instrText    - Concatenated w:instrText for this field
- * @param {string|null} fldData      - Base64 content of w:fldData (EndNote),
- *                                     or null/undefined if absent
- * @param {string|null} sourcesXml   - Content of customXml/item1.xml (required
- *                                     only for Word-native citations)
- * @param {Object}      bibliography - Fidus Writer bibliography (mutated)
- * @returns {Object|null}  ProseMirror citation node or null
  */
 export function parseDocxFieldCitation(
-    instrText,
-    fldData,
-    sourcesXml,
-    bibliography
-) {
+    instrText: string,
+    fldData: string | null | undefined,
+    sourcesXml: string | null | undefined,
+    bibliography: Record<string, any>
+): FidusNode | null {
     if (!instrText) {
         return null
     }
@@ -96,8 +83,7 @@ export function parseDocxFieldCitation(
         fldData || undefined,
         options
     )
-    const node = citationResultToNode(result, bibliography)
-    return node
+    return citationResultToNode(result as any, bibliography)
 }
 
 /**
@@ -105,12 +91,11 @@ export function parseDocxFieldCitation(
  * new bibliography entries into `bibliography`.
  *
  * Handles Mendeley Cite v3 and Citavi (modern SDT form).
- *
- * @param {Object} sdtNode      - The parsed w:sdt XMLElement node
- * @param {Object} bibliography - Fidus Writer bibliography (mutated)
- * @returns {Object|null}  ProseMirror citation node or null
  */
-export function parseDocxSdtCitation(sdtNode, bibliography) {
+export function parseDocxSdtCitation(
+    sdtNode: XMLElement | null | undefined,
+    bibliography: Record<string, any>
+): FidusNode | null {
     if (!sdtNode) {
         return null
     }
@@ -119,5 +104,5 @@ export function parseDocxSdtCitation(sdtNode, bibliography) {
         true, // retrieve
         true // retrieveMetadata
     )
-    return citationResultToNode(result, bibliography)
+    return citationResultToNode(result as any, bibliography)
 }