@fiduswriter/bibliography-manager 0.1.0

package/src/form/fields/range_list.js

@@ -0,0 +1,42 @@
+import {InputList} from "fwtoolkit"
+import {RangeFieldForm} from "./range"
+
+export class RangeListForm {
+    constructor(dom, initialValue = [[]]) {
+        this.dom = dom
+        this.fieldHandlers = new WeakMap()
+        this.inputList = new InputList({
+            dom,
+            initialValues: initialValue,
+            emptyValue: [],
+            renderItem: value => ({
+                html: `<div class="range-field"></div>`,
+                bind: el => {
+                    const fieldHandler = new RangeFieldForm(
+                        el.firstElementChild,
+                        value
+                    )
+                    fieldHandler.init()
+                    this.fieldHandlers.set(el, fieldHandler)
+                }
+            }),
+            getValue: el => this.fieldHandlers.get(el).value
+        })
+    }
+
+    init() {
+        // InputList is already rendered by the constructor.
+    }
+
+    get value() {
+        const formValue = this.inputList.values.filter(value => value !== false)
+        if (formValue.length === 0) {
+            return false
+        }
+        return formValue
+    }
+
+    check() {
+        return true
+    }
+}

package/src/form/fields/tag_list.js

@@ -0,0 +1,33 @@
+import TokenField from "tokenfield"
+
+export class TagListForm {
+    constructor(dom, initialValue = []) {
+        this.dom = dom
+        this.initialValue = initialValue
+    }
+
+    init() {
+        this.dom.innerHTML = '<input class="tags" type="text">'
+        this.tokenInput = new TokenField({
+            el: this.dom.querySelector(".tags"),
+            setItems: this.initialValue.map((key, index) => {
+                return {id: index, name: key}
+            }),
+            keys: {
+                188: "delimiter"
+            }
+        })
+    }
+
+    get value() {
+        const formValue = this.tokenInput.getItems().map(item => {
+            return item.name
+        })
+        // If the form has not been filled out, don't consider this form
+        return formValue.length > 0 ? formValue : false
+    }
+
+    check() {
+        return true
+    }
+}

package/src/form/fields/title.js

@@ -0,0 +1,51 @@
+import {toggleMark} from "prosemirror-commands"
+
+import {InlineInput, icon} from "fwtoolkit"
+
+import {titleSchema} from "../../schema/title"
+
+export class TitleFieldForm {
+    constructor(dom, initialValue) {
+        this.inlineInput = new InlineInput(dom, {
+            schema: titleSchema,
+            nodeType: "literal",
+            initialValue,
+            tools: [
+                {
+                    command: toggleMark(titleSchema.marks.strong),
+                    dom: icon("strong", gettext("Strong"))
+                },
+                {
+                    command: toggleMark(titleSchema.marks.em),
+                    dom: icon("em", gettext("Emphasis"))
+                },
+                {
+                    command: toggleMark(titleSchema.marks.smallcaps),
+                    dom: icon("smallcaps", gettext("Small caps"))
+                },
+                {
+                    command: toggleMark(titleSchema.marks.sub),
+                    dom: icon("sub", gettext("Subscript₊"))
+                },
+                {
+                    command: toggleMark(titleSchema.marks.sup),
+                    dom: icon("sup", gettext("Supscript²"))
+                },
+                {
+                    command: toggleMark(titleSchema.marks.nocase),
+                    dom: icon("nocase", gettext("CasE ProTecT"))
+                }
+            ]
+        })
+    }
+
+    init() {}
+
+    get value() {
+        return this.inlineInput.value
+    }
+
+    check() {
+        return this.inlineInput.check()
+    }
+}

package/src/form/fields/uri.js

@@ -0,0 +1,43 @@
+// Simple regex to check for a basic URL structure
+const simpleUrlRegex = /^(https?:\/\/)?[\w.-]+\.[a-z]{2,}(\/\S*)?$/i
+
+function isValidUrl(string) {
+    if (simpleUrlRegex.test(string)) {
+        try {
+            new URL(string)
+            return true
+        } catch (_e) {
+            return false
+        }
+    }
+    return false
+}
+
+export class URIFieldForm {
+    constructor(dom, initialValue = "", placeHolder = "") {
+        this.dom = dom
+        this.initialValue = initialValue
+        this.placeHolder = placeHolder
+    }
+
+    init() {
+        this.dom.innerHTML = `<input class="uri" type="text" value="${this.initialValue}" placeholder="${this.placeHolder}">`
+    }
+
+    get value() {
+        const formValue = this.dom.querySelector("input.uri").value
+        // If the form has not been filled out, don't consider this form
+        return formValue.length > 0 ? formValue : false
+    }
+
+    check() {
+        const formValue = this.value
+        if (formValue) {
+            if (!isValidUrl(formValue)) {
+                this.dom.classList.add("fw-fomt-error")
+                return false
+            }
+        }
+        return true
+    }
+}

package/src/form/fields/verbatim.js

@@ -0,0 +1,21 @@
+export class VerbatimFieldForm {
+    constructor(dom, initialValue = "", placeHolder = "") {
+        this.dom = dom
+        this.initialValue = initialValue
+        this.placeHolder = placeHolder
+    }
+
+    init() {
+        this.dom.innerHTML = `<input class="verbatim" type="text" value="${this.initialValue}" placeholder="${this.placeHolder}">`
+    }
+
+    get value() {
+        const formValue = this.dom.querySelector("input.verbatim").value
+        // If the form has not been filled out, don't consider this form
+        return formValue.length > 0 ? formValue : false
+    }
+
+    check() {
+        return true
+    }
+}

package/src/form/index.js

@@ -0,0 +1,424 @@
+import {BibFieldTypes, BibTypes} from "bibliojson"
+import {Dialog, DialogTabs, InfoRow, addAlert} from "fwtoolkit"
+import {dateToYear, litToText, nameToText} from "../tools"
+import {CatsForm} from "./cats"
+import {DateFieldForm} from "./fields/date"
+import {KeyFieldForm} from "./fields/key"
+import {KeyListForm} from "./fields/key_list"
+import {LiteralFieldForm} from "./fields/literal"
+import {LiteralListForm} from "./fields/literal_list"
+import {LiteralLongFieldForm} from "./fields/literal_long"
+import {NameListForm} from "./fields/name_list"
+import {RangeListForm} from "./fields/range_list"
+import {TagListForm} from "./fields/tag_list"
+import {TitleFieldForm} from "./fields/title"
+import {URIFieldForm} from "./fields/uri"
+import {VerbatimFieldForm} from "./fields/verbatim"
+import {
+    BibFieldHelp,
+    BibFieldTitles,
+    BibTypeTitles,
+    getBibFieldTitle
+} from "./strings"
+import {bibDialog} from "./templates"
+
+const FIELD_FORMS = {
+    f_date: DateFieldForm,
+    f_integer: LiteralFieldForm,
+    f_literal: LiteralFieldForm,
+    l_literal: LiteralListForm,
+    f_long_literal: LiteralLongFieldForm,
+    f_key: KeyFieldForm,
+    l_key: KeyListForm,
+    l_name: NameListForm,
+    l_range: RangeListForm,
+    l_tag: TagListForm,
+    f_title: TitleFieldForm,
+    f_uri: URIFieldForm,
+    f_verbatim: VerbatimFieldForm
+}
+
+export class BibEntryForm {
+    constructor(bibDB, app = false, itemId = false) {
+        this.bibDB = bibDB
+        this.itemId = itemId
+        this.app = app
+        this.fields = {}
+        this.currentValues = {}
+    }
+
+    init() {
+        if (this.app && this.app.isOffline()) {
+            // Diable the editing of main user bibliography , since Document bibliography is stored in Editor/Document.
+            addAlert(
+                "info",
+                gettext(
+                    "You are currently offline. Please try again when you are back online."
+                )
+            )
+            return Promise.resolve()
+        }
+        if (this.itemId !== false) {
+            this.dialogHeader = gettext("Edit Source")
+            const bibEntry = this.bibDB.db[this.itemId]
+            this.currentValues = JSON.parse(JSON.stringify(bibEntry)) // copy current values
+        } else {
+            this.dialogHeader = gettext("Register New Source")
+            this.currentValues = {
+                bib_type: false,
+                cats: [],
+                entry_key: "",
+                fields: {}
+            }
+        }
+        return this.createForm()
+    }
+
+    addDialogToDOM() {
+        // Add form to DOM
+        const buttons = [
+            {
+                type: "close"
+            }
+        ]
+
+        return new Promise(resolve => {
+            buttons.push({
+                classes: "fw-dark",
+                text: gettext("Submit"),
+                click: () => {
+                    if (this.check()) {
+                        const returnValue = this.save()
+                        this.dialog.close()
+                        resolve(returnValue)
+                    }
+                }
+            })
+
+            this.entryKeyAutoGenerate = !this.currentValues.entry_key
+            this.programmaticallySettingKey = false
+            this.lastAutoGeneratedKey = null
+
+            const hasCats = this.bibDB.cats.length > 0
+            this.dialog = new Dialog({
+                title: this.dialogHeader,
+                id: "bib-dialog",
+                width: 940,
+                body: bibDialog({
+                    bib_type: this.currentValues.bib_type,
+                    BibTypes,
+                    hasCats
+                }),
+                buttons
+            })
+
+            this.dialog.open()
+
+            this.dialogTabs = new DialogTabs(
+                [
+                    {
+                        id: "req-fields-tab",
+                        title: gettext("Required Fields"),
+                        template: () => ""
+                    },
+                    {
+                        id: "opt-fields-tab",
+                        title: gettext("Optional Fields"),
+                        template: () => ""
+                    },
+                    ...(hasCats
+                        ? [
+                              {
+                                  id: "categories-tab",
+                                  title: gettext("Categories"),
+                                  template: () => ""
+                              }
+                          ]
+                        : [])
+                ],
+                {containerId: "bib-dialog-tabs"}
+            )
+            this.dialogTabs.bind(
+                this.dialog.dialogEl.querySelector("#bib-dialog-tabs")
+            )
+
+            const entryKeyInput = document.getElementById("entry-key")
+            if (entryKeyInput) {
+                entryKeyInput.value = this.currentValues.entry_key || ""
+                entryKeyInput.addEventListener("input", () => {
+                    if (this.programmaticallySettingKey) {
+                        return
+                    }
+                    this.entryKeyAutoGenerate = !entryKeyInput.value.trim()
+                    if (this.entryKeyAutoGenerate) {
+                        this.lastAutoGeneratedKey = null
+                    }
+                    this.checkEntryKey()
+                })
+                this.checkEntryKey()
+                this.dialog.dialogEl.addEventListener("focusout", () => {
+                    if (this.entryKeyAutoGenerate) {
+                        this.maybeAutoGenerateEntryKey()
+                    }
+                })
+            }
+
+            document
+                .getElementById("select-bibtype")
+                .addEventListener("change", () => resolve(this.changeBibType()))
+        })
+    }
+
+    addField(fieldName, dom) {
+        const fieldType = BibFieldTypes[fieldName]
+        const fieldTitleText = getBibFieldTitle(
+            fieldName,
+            this.currentValues.bib_type
+        )
+
+        const row = new InfoRow({
+            label: fieldTitleText,
+            helpText: BibFieldHelp[fieldName],
+            fieldClass: fieldName
+        })
+        dom.insertAdjacentHTML("beforeend", row.html())
+        const fieldDOM = dom.lastChild.lastChild
+        const FieldClass = FIELD_FORMS[fieldType.type]
+        if (FieldClass) {
+            const fieldHandler = new FieldClass(
+                fieldDOM,
+                this.currentValues.fields[fieldName],
+                undefined,
+                fieldType
+            )
+            fieldHandler.init()
+            this.fields[fieldName] = fieldHandler
+        }
+    }
+
+    createForm() {
+        const dialogPromise = this.addDialogToDOM()
+        if (this.currentValues.bib_type !== false) {
+            const eitherOrFields = document.getElementById("eo-fields")
+            BibTypes[this.currentValues.bib_type].eitheror.forEach(
+                fieldName => {
+                    this.addField(fieldName, eitherOrFields)
+                }
+            )
+            const reqFields = document.getElementById("req-fields")
+            BibTypes[this.currentValues.bib_type].required.forEach(
+                fieldName => {
+                    this.addField(fieldName, reqFields)
+                }
+            )
+            const optFields = document.getElementById("opt-fields")
+            BibTypes[this.currentValues.bib_type].optional.forEach(
+                fieldName => {
+                    this.addField(fieldName, optFields)
+                }
+            )
+            const catsField = document.getElementById("categories-field")
+            if (catsField) {
+                this.catsForm = new CatsForm(
+                    catsField,
+                    this.currentValues.cats,
+                    this.bibDB.cats
+                )
+                this.catsForm.init()
+            }
+        }
+        return dialogPromise
+    }
+
+    changeBibType() {
+        // Add all current values into temporary currentValues, in case the
+        // user still wants them.
+        const formValue = this.value
+        Object.assign(this.currentValues.fields, formValue.fields)
+        this.currentValues.cats = formValue.cats
+        this.currentValues.bib_type = formValue.bib_type
+        // Reset fields and close dialog.
+        this.fields = {}
+        this.dialog.close()
+        return this.createForm()
+    }
+
+    createEntryKey(bibItem) {
+        // We attempt to create a biblatex compatible entry key if there is no entry
+        // key so far.
+        let entryKey = ""
+        if (bibItem.fields.author) {
+            entryKey += nameToText(bibItem.fields.author).replace(
+                /\s|,|=|;|:|{|}/g,
+                ""
+            )
+        } else if (bibItem.fields.editor) {
+            entryKey += nameToText(bibItem.fields.editor).replace(
+                /\s|,|=|;|:|{|}/g,
+                ""
+            )
+        }
+        if (bibItem.fields.date) {
+            entryKey += bibItem.fields.date
+                .split("/")[0]
+                .replace(/\?|\*|u|~|-/g, "")
+        }
+        if (entryKey.length) {
+            bibItem.entry_key = entryKey
+        }
+    }
+
+    maybeAutoGenerateEntryKey() {
+        if (!this.entryKeyAutoGenerate) {
+            return
+        }
+        const input = document.getElementById("entry-key")
+        if (!input) {
+            return
+        }
+        const currentValue = input.value.trim()
+        if (currentValue && currentValue !== this.lastAutoGeneratedKey) {
+            return
+        }
+
+        let lastName = ""
+        const nameField = this.fields.author || this.fields.editor
+        if (nameField && nameField.value && nameField.value.length) {
+            const firstAuthor = nameField.value[0]
+            if (firstAuthor.family && firstAuthor.family.length) {
+                lastName = litToText(firstAuthor.family)
+            } else if (firstAuthor.literal && firstAuthor.literal.length) {
+                lastName = litToText(firstAuthor.literal)
+            }
+        }
+        lastName = lastName.replace(/[^a-zA-Z0-9_-]/g, "")
+
+        let year = ""
+        if (this.fields.date && this.fields.date.value) {
+            const yearStr = dateToYear(this.fields.date.value)
+            const yearMatch = yearStr.match(/-?(\d+)/)
+            year = yearMatch ? yearMatch[1] : ""
+        }
+        year = year.replace(/[^a-zA-Z0-9_-]/g, "")
+
+        const baseKey = `${lastName}${year}`
+        if (!baseKey) {
+            return
+        }
+
+        const existingKeys = new Set(
+            Object.entries(this.bibDB.db)
+                .filter(
+                    ([id]) =>
+                        Number.parseInt(id) !==
+                        Number.parseInt(this.itemId || 0)
+                )
+                .map(([, entry]) => entry.entry_key)
+        )
+
+        let key = baseKey
+        let suffix = ""
+        while (existingKeys.has(key + suffix)) {
+            suffix =
+                suffix === ""
+                    ? "a"
+                    : String.fromCharCode(suffix.charCodeAt(0) + 1)
+        }
+        key = key + suffix
+
+        if (key === currentValue) {
+            return
+        }
+
+        this.programmaticallySettingKey = true
+        input.value = key
+        this.programmaticallySettingKey = false
+        this.lastAutoGeneratedKey = key
+        this.checkEntryKey()
+    }
+
+    checkEntryKey() {
+        const input = document.getElementById("entry-key")
+        const warningEl = document.getElementById("entry-key-warning")
+        if (!input || !warningEl) {
+            return
+        }
+        const value = input.value.trim()
+        if (!value) {
+            warningEl.textContent = ""
+            return
+        }
+        const slugPattern = /^[a-zA-Z0-9_-]+$/
+        if (!slugPattern.test(value)) {
+            warningEl.textContent = gettext(
+                "Only letters, numbers, hyphens and underscores are allowed."
+            )
+            return
+        }
+        // Check for duplicates in the user's library (soft requirement - just warn)
+        const duplicate = Object.entries(this.bibDB.db).find(
+            ([id, entry]) =>
+                entry.entry_key === value &&
+                Number.parseInt(id) !== Number.parseInt(this.itemId || 0)
+        )
+        if (duplicate) {
+            warningEl.textContent = gettext(
+                "Warning: this key is already used in your library."
+            )
+        } else {
+            warningEl.textContent = ""
+        }
+    }
+
+    get value() {
+        const entryKeyInput = document.querySelector("#entry-key")
+        const entryKey = entryKeyInput
+            ? entryKeyInput.value.trim()
+            : this.currentValues.entry_key
+        const returnObj = {
+            bib_type: document.querySelector("#select-bibtype").value,
+            cats: this.catsForm ? this.catsForm.value : [],
+            entry_key: entryKey,
+            fields: {}
+        }
+        Object.keys(this.fields).forEach(fieldName => {
+            const fieldValue = this.fields[fieldName].value
+            if (fieldValue !== false) {
+                returnObj["fields"][fieldName] = fieldValue
+            }
+        })
+        return returnObj
+    }
+
+    save() {
+        const isNew = this.itemId === false ? true : false,
+            itemId = this.itemId === false ? 0 : this.itemId,
+            item = this.value
+
+        if (!item.entry_key) {
+            this.createEntryKey(item)
+        }
+        const saveObj = {}
+        saveObj[itemId] = item
+        return this.bibDB.saveBibEntries(saveObj, isNew)
+    }
+
+    check() {
+        let passed = true
+        if (!this.currentValues.bib_type) {
+            return false
+        }
+        Object.keys(this.fields).forEach(fieldName => {
+            if (this.fields[fieldName].check() !== true) {
+                passed = false
+            }
+        })
+        if (!passed) {
+            addAlert(
+                "error",
+                gettext("Error in form, check highlighted values!")
+            )
+        }
+        return passed
+    }
+}