@fiduswriter/bibliography-manager 0.1.0

package/src/form/strings.js

@@ -0,0 +1,122 @@
+import {
+    BibFieldTypes,
+    BibTypes,
+    getFieldHelp,
+    getFieldTitle,
+    getLangidTitle,
+    getLocale,
+    getOtherOptionTitle,
+    getTypeTitle
+} from "bibliojson"
+
+// Cache for the current locale to avoid repeated lookups
+let cachedLocale = null
+let cachedLang = null
+
+function getCachedLocale() {
+    const lang = document.documentElement.lang || "en"
+    if (lang !== cachedLang) {
+        cachedLocale = getLocale(lang)
+        cachedLang = lang
+    }
+    return cachedLocale
+}
+
+// Dynamic field title getter that uses bibliojson's i18n
+export function getBibFieldTitle(fieldKey, bibType = null) {
+    const locale = getCachedLocale()
+    if (bibType && BibTypes[bibType]) {
+        return getFieldTitle(locale, bibType, fieldKey)
+    }
+    // Fallback to generic field title
+    const fieldType = BibFieldTypes[fieldKey]
+    if (fieldType && fieldType.title) {
+        return fieldType.title
+    }
+    return fieldKey
+}
+
+// Dynamic type title getter
+export function getBibTypeTitle(typeKey) {
+    const locale = getCachedLocale()
+    return getTypeTitle(locale, typeKey)
+}
+
+// Dynamic field help getter
+export function getBibFieldHelp(fieldKey) {
+    const locale = getCachedLocale()
+    return getFieldHelp(locale, fieldKey)
+}
+
+// Dynamic option title getter (for editortype, pagination, pubstate, etc.)
+export function getBibOptionTitle(optionKey) {
+    const locale = getCachedLocale()
+    return getOtherOptionTitle(locale, optionKey)
+}
+
+// Dynamic langid title getter
+export function getBibLangidTitle(langidKey) {
+    const locale = getCachedLocale()
+    return getLangidTitle(locale, langidKey)
+}
+
+// For backward compatibility, create proxy objects that dynamically return translations
+// These should be used sparingly - prefer using the function versions above
+export const BibFieldTitles = new Proxy(
+    {},
+    {
+        get(_target, prop) {
+            return getBibFieldTitle(prop)
+        }
+    }
+)
+
+export const BibTypeTitles = new Proxy(
+    {},
+    {
+        get(_target, prop) {
+            return getBibTypeTitle(prop)
+        }
+    }
+)
+
+export const BibFieldHelp = new Proxy(
+    {},
+    {
+        get(_target, prop) {
+            return getBibFieldHelp(prop)
+        }
+    }
+)
+
+export const BibOptionTitles = new Proxy(
+    {},
+    {
+        get(_target, prop) {
+            return getBibOptionTitle(prop)
+        }
+    }
+)
+
+// Export a function to get all type titles as an object (for templates that need to map all types)
+export function getAllTypeTitles() {
+    const locale = getCachedLocale()
+    const titles = {}
+    Object.keys(BibTypes).forEach(typeKey => {
+        titles[typeKey] = getTypeTitle(locale, typeKey)
+    })
+    return titles
+}
+
+// Export a function to get all field help texts
+export function getAllFieldHelp() {
+    const locale = getCachedLocale()
+    const help = {}
+    Object.keys(BibFieldTypes).forEach(fieldKey => {
+        const helpText = getFieldHelp(locale, fieldKey)
+        if (helpText) {
+            help[fieldKey] = helpText
+        }
+    })
+    return help
+}

package/src/form/templates.js

@@ -0,0 +1,70 @@
+/** A template for the bibliography item edit dialog. */
+import {DialogTabs} from "fwtoolkit"
+import {getAllTypeTitles} from "./strings"
+
+const requiredFieldsTemplate = () =>
+    `<table class="fw-dialog-table"><tbody id="eo-fields"></tbody></table>
+    <table class="fw-dialog-table"><tbody id="req-fields"></tbody></table>`
+
+const optionalFieldsTemplate = () =>
+    `<table class="fw-dialog-table"><tbody id="opt-fields"></tbody></table>`
+
+const categoriesTemplate = () =>
+    `<table class="fw-dialog-table">
+        <tbody>
+            <tr>
+                <th><h4 class="fw-tablerow-title">${gettext("Categories")}</h4></th>
+                <td id="categories-field"></td>
+            </tr>
+        </tbody>
+    </table>`
+
+export const bibDialog = ({bib_type, BibTypes, hasCats}) => {
+    const typeTitles = getAllTypeTitles()
+    const tabs = [
+        {
+            id: "req-fields-tab",
+            title: gettext("Required Fields"),
+            template: requiredFieldsTemplate
+        },
+        {
+            id: "opt-fields-tab",
+            title: gettext("Optional Fields"),
+            template: optionalFieldsTemplate
+        }
+    ]
+    if (hasCats) {
+        tabs.push({
+            id: "categories-tab",
+            title: gettext("Categories"),
+            template: categoriesTemplate
+        })
+    }
+    const dialogTabs = new DialogTabs(tabs, {containerId: "bib-dialog-tabs"})
+    return `<div class="bib-dialog-header">
+            <div class="fw-select-container">
+                <select id="select-bibtype" class="fw-button fw-light fw-large" required>
+                    ${
+                        bib_type === false
+                            ? `<option class="fw-placeholder" selected disabled value="">${gettext("Select source type")}</option>`
+                            : ""
+                    }
+                    ${Object.keys(BibTypes)
+                        .map(
+                            key =>
+                                `<option value="${key}"
+                                    ${key === bib_type ? "selected" : ""}>
+                                ${typeTitles[key]}
+                            </option>`
+                        )
+                        .join("")}
+                </select>
+                <div class="fw-select-arrow fa fa-caret-down"></div>
+            </div>
+            <div class="entry-key-input-container">
+                <input type="text" id="entry-key" class="fw-button fw-light" value="" placeholder="${gettext("Citation key")}" />
+                <div id="entry-key-warning" class="entry-key-warning"></div>
+            </div>
+        </div>
+        ${dialogTabs.render()}`
+}

package/src/import/bibliography_import.js

@@ -0,0 +1,104 @@
+import {sniffFormat} from "bibliojson"
+import {addAlert, makeWorker} from "fwtoolkit"
+
+const ERROR_MSG = {
+    no_entries: gettext(
+        "No bibliography entries could be found in import file."
+    ),
+    entry_error: gettext("An error occured while reading a bibliography entry"),
+    unknown_field: gettext(
+        "Field cannot not be saved. Fidus Writer does not support the field."
+    ),
+    unknown_type: gettext(
+        'Entry has been saved as "misc". Fidus Writer does not support the entry type.'
+    ),
+    unknown_date: gettext("Field does not contain a valid EDTF string."),
+    server_save: gettext("The bibliography could not be updated"),
+    unsupported_format: gettext("The file format could not be recognized.")
+}
+
+export class BibliographyImporter {
+    constructor(
+        fileContents,
+        bibDB,
+        addToListCall,
+        callback,
+        showAlerts = true
+    ) {
+        this.fileContents = fileContents
+        this.bibDB = bibDB
+        this.addToListCall = addToListCall
+        this.callback = callback
+        this.showAlerts = showAlerts
+    }
+
+    init() {
+        // Detect the format of the input file
+        const format = sniffFormat(this.fileContents)
+
+        if (!format) {
+            if (this.showAlerts) {
+                addAlert("error", ERROR_MSG.unsupported_format)
+            }
+            if (this.callback) {
+                this.callback()
+            }
+            return
+        }
+
+        // Use the worker for the detected format
+        const importWorker = makeWorker(
+            staticUrl("js/bibliography_import_worker.js")
+        )
+        importWorker.onmessage = message => this.onMessage(message.data)
+        importWorker.postMessage({
+            fileContents: this.fileContents,
+            format: format
+        })
+    }
+
+    onMessage(message) {
+        let errorMsg, data
+        switch (message.type) {
+            case "error":
+            case "warning":
+                errorMsg = ERROR_MSG[message.errorCode]
+                if (!errorMsg) {
+                    errorMsg = gettext(
+                        "There was an issue with the bibliography import"
+                    )
+                }
+                if (message.errorType) {
+                    errorMsg += `, error_type: ${message.errorType}`
+                }
+                if (message.key) {
+                    errorMsg += `, key: ${message.key}`
+                }
+                if (message.type_name) {
+                    errorMsg += `, entry: ${message.type_name}`
+                }
+                if (message.field_name) {
+                    errorMsg += `, field_name: ${message.field_name}`
+                }
+                if (message.entry) {
+                    errorMsg += `, entry: ${message.entry}`
+                }
+                if (this.showAlerts) {
+                    addAlert(message.type, errorMsg)
+                }
+                break
+            case "data":
+                data = message.data
+                this.bibDB.saveBibEntries(data, true).then(idTranslations => {
+                    const newIds = idTranslations.map(idTrans => idTrans[1])
+                    this.addToListCall(newIds)
+                })
+                break
+            default:
+                break
+        }
+        if (message.done && this.callback) {
+            this.callback()
+        }
+    }
+}

package/src/import/dialog.js

@@ -0,0 +1,95 @@
+import {Dialog, activateWait, addAlert, deactivateWait} from "fwtoolkit"
+import {importBibFileTemplate} from "./templates"
+/** First step of the bibliography file import. Creates a dialog box to specify upload file.
+ * Supports multiple formats: BibTeX/BibLaTeX, CSL-JSON, RIS, EndNote, Citavi, NBIB, ODT/DOCX citations.
+ */
+
+export class BibliographyFileImportDialog {
+    constructor(bibDB, addToListCall, app) {
+        this.bibDB = bibDB
+        this.addToListCall = addToListCall
+        this.tmpDB = false
+        this.app = app
+    }
+
+    init() {
+        if (this.app.isOffline()) {
+            addAlert(
+                "info",
+                gettext(
+                    "You are currently offline. Please try again when you are back online."
+                )
+            )
+            return
+        }
+        const buttons = [
+            {
+                text: gettext("Import"),
+                classes: "fw-dark submit-import",
+                click: () => {
+                    let bibFile = document.getElementById("bib-uploader").files
+                    if (0 === bibFile.length) {
+                        return false
+                    }
+                    bibFile = bibFile[0]
+                    if (10485760 < bibFile.size) {
+                        return false
+                    }
+                    if (this.app.isOffline()) {
+                        addAlert(
+                            "info",
+                            gettext(
+                                "You are currently offline. Please try again when you are back online."
+                            )
+                        )
+                        dialog.close()
+                        return false
+                    }
+                    activateWait()
+                    const reader = new window.FileReader()
+                    reader.onload = event => {
+                        import("./bibliography_import").then(
+                            ({BibliographyImporter}) => {
+                                const importer = new BibliographyImporter(
+                                    event.target.result,
+                                    this.bibDB,
+                                    this.addToListCall,
+                                    () => deactivateWait()
+                                )
+                                importer.init()
+                            }
+                        )
+                    }
+                    reader.readAsText(bibFile)
+                    dialog.close()
+                }
+            },
+            {
+                type: "cancel"
+            }
+        ]
+        const dialog = new Dialog({
+            id: "importbibtex",
+            title: gettext("Import a bibliography"),
+            body: importBibFileTemplate(),
+            height: 200,
+            buttons
+        })
+        dialog.open()
+        document
+            .getElementById("bib-uploader")
+            .addEventListener(
+                "change",
+                () =>
+                    (document.getElementById("import-bib-name").innerHTML =
+                        document
+                            .getElementById("bib-uploader")
+                            .value.replace(/C:\\fakepath\\/i, ""))
+            )
+        document
+            .getElementById("import-bib-btn")
+            .addEventListener("click", () =>
+                document.getElementById("bib-uploader").click()
+            )
+    }
+}

package/src/import/index.js

@@ -0,0 +1,2 @@
+export {BibliographyFileImportDialog} from "./dialog"
+export {BibliographyImporter} from "./bibliography_import"

package/src/import/templates.js

@@ -0,0 +1,12 @@
+/** a template for the bibliography file import dialog */
+export const importBibFileTemplate = () =>
+    `<form id="import-bib-form" method="post" enctype="multipart/form-data" class="ajax-upload">
+        <input type="file" id="bib-uploader" name="bib" required />
+        <span id="import-bib-btn" class="fw-button fw-light fw-large">
+            ${gettext("Select a file")}
+        </span>
+        <label id="import-bib-name" class="ajax-upload-label"></label>
+        <div class="import-format-info" style="margin-top: 10px; font-size: 0.9em; color: #666;">
+            ${gettext("Supported formats: BibTeX/BibLaTeX, CSL-JSON, RIS, EndNote XML, EndNote Tagged, Citavi XML, Citavi JSON, NBIB/PubMed, ODT citations, DOCX citations")}
+        </div>
+    </form>`

package/src/index.js

@@ -0,0 +1,5 @@
+export {BibliographyOverview} from "./overview/index.js"
+export {BibEntryForm} from "./form/index.js"
+export {BibliographyDB} from "./database/index.js"
+export {importBibFile} from "./import/index.js"
+export {exportBibFile} from "./export/index.js"