@fiduswriter/bibliography-manager 0.1.0

package/src/export/index.js

@@ -0,0 +1,27 @@
+import {ZipFileCreator} from "@fiduswriter/document/exporter/tools/zip"
+import download from "downloadjs"
+
+export class BibLatexFileExporter {
+    constructor(bibDB, pks) {
+        this.pks = pks // A list of pk values of the bibliography items to be exported.
+        this.bibDB = bibDB // The bibliography database to export from.
+    }
+
+    init() {
+        import("bibliojson").then(({BibLatexExporter}) => {
+            const exporter = new BibLatexExporter(this.bibDB.db, this.pks)
+
+            const zipper = new ZipFileCreator([
+                {
+                    filename: "bibliography.bib",
+                    contents: exporter.output
+                }
+            ])
+            zipper
+                .init()
+                .then(blob =>
+                    download(blob, "bibliography.zip", "application/zip")
+                )
+        })
+    }
+}

package/src/form/cats.js

@@ -0,0 +1,24 @@
+import {CheckableList} from "fwtoolkit"
+
+export class CatsForm {
+    constructor(dom, initialValue = [], options = []) {
+        this.dom = dom
+        this.checkableList = new CheckableList({
+            dom,
+            options: options.map(option => ({
+                id: option.id,
+                label: option.category_title
+            })),
+            initialValue,
+            multiple: true
+        })
+    }
+
+    init() {
+        // CheckableList is already rendered by the constructor.
+    }
+
+    get value() {
+        return this.checkableList.value
+    }
+}

package/src/form/fields/date.js

@@ -0,0 +1,31 @@
+import {edtfParse} from "bibliojson"
+
+export class DateFieldForm {
+    constructor(dom, initialValue = "", placeHolder = "") {
+        this.dom = dom
+        this.initialValue = initialValue
+        this.placeHolder = placeHolder
+    }
+
+    init() {
+        this.dom.innerHTML = `<input class="fw-date" type="text" value="${this.initialValue}" placeholder="${this.placeHolder}">`
+    }
+
+    get value() {
+        const formValue = this.dom.querySelector("input.fw-date").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) {
+            const checkValue = edtfParse(formValue).valid
+            if (!checkValue) {
+                this.dom.classList.add("fw-fomt-error")
+                return false
+            }
+        }
+        return true
+    }
+}

package/src/form/fields/key.js

@@ -0,0 +1,113 @@
+import {TypeSwitch} from "fwtoolkit"
+import {getBibOptionTitle} from "../strings"
+import {LiteralFieldForm} from "./literal"
+
+export class KeyFieldForm {
+    constructor(dom, initialValue, _unused, fieldType = undefined) {
+        this.currentValue = {}
+        this.dom = dom
+        this.fieldType = fieldType
+        // We set the mode based on the type of value
+        if (typeof initialValue === "object") {
+            this.predefined = false
+            this.currentValue["custom"] = initialValue
+        } else {
+            this.predefined = true
+            this.currentValue["predefined"] = initialValue
+        }
+    }
+
+    init() {
+        this.typeSwitch = new TypeSwitch({
+            dom: this.dom,
+            label1: gettext("From list"),
+            label2: gettext("Custom"),
+            initialMode: this.predefined ? 1 : 2,
+            disabled: this.fieldType.strict,
+            beforeChange: () => {
+                const formValue = this.value
+                if (formValue) {
+                    if (this.predefined) {
+                        this.currentValue["predefined"] = formValue
+                    } else {
+                        this.currentValue["custom"] = formValue
+                    }
+                }
+            },
+            onChange: mode => {
+                this.predefined = mode === 1
+                this.drawForm()
+            }
+        })
+        this.drawForm()
+    }
+
+    drawForm() {
+        if (this.predefined) {
+            this.drawSelectionListForm()
+        } else {
+            this.drawCustomInputForm()
+        }
+    }
+
+    drawSelectionListForm() {
+        this.typeSwitch.innerElement.innerHTML = `
+                <select class='key-selection'><option value=''></option></select>
+                <div class="fw-select-arrow fa fa-caret-down"></div>
+            `
+        const selectEl =
+            this.typeSwitch.innerElement.querySelector(".key-selection")
+        if (Array.isArray(this.fieldType.options)) {
+            this.fieldType.options.forEach(option => {
+                selectEl.insertAdjacentHTML(
+                    "beforeend",
+                    `<option value="${option}">${getBibOptionTitle(option)}</option>`
+                )
+            })
+        } else {
+            Object.keys(this.fieldType.options).forEach(option => {
+                selectEl.insertAdjacentHTML(
+                    "beforeend",
+                    `<option value="${option}">${getBibOptionTitle(option)}</option>`
+                )
+            })
+        }
+
+        if (this.currentValue["predefined"]) {
+            selectEl.value = this.currentValue["predefined"]
+        }
+    }
+
+    drawCustomInputForm() {
+        this.fields = {}
+        this.typeSwitch.innerElement.innerHTML = `<div class='custom-input field-part field-part-single'></div>`
+        this.fields["custom"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".custom-input"),
+            this.currentValue["custom"]
+        )
+        this.fields.custom.init()
+    }
+
+    get value() {
+        if (this.predefined) {
+            const selectEl =
+                this.typeSwitch.innerElement.querySelector(".key-selection")
+            const selectionValue =
+                selectEl.options[selectEl.selectedIndex].value
+            if (selectionValue === "") {
+                return false
+            } else {
+                return selectionValue
+            }
+        } else {
+            if (!this.fields.custom.value) {
+                return false
+            }
+            return this.fields.custom.value
+        }
+    }
+
+    check() {
+        return true
+    }
+}

package/src/form/fields/key_list.js

@@ -0,0 +1,45 @@
+import {InputList} from "fwtoolkit"
+import {KeyFieldForm} from "./key"
+
+export class KeyListForm {
+    constructor(dom, initialValue = [""], _unused, fieldType = undefined) {
+        this.dom = dom
+        this.fieldType = fieldType
+        this.fieldHandlers = new WeakMap()
+        this.inputList = new InputList({
+            dom,
+            initialValues: initialValue,
+            emptyValue: "",
+            renderItem: value => ({
+                html: `<div class="key-field"></div>`,
+                bind: el => {
+                    const fieldHandler = new KeyFieldForm(
+                        el.firstElementChild,
+                        value,
+                        false,
+                        this.fieldType
+                    )
+                    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/literal.js

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

package/src/form/fields/literal_list.js

@@ -0,0 +1,42 @@
+import {InputList} from "fwtoolkit"
+import {LiteralFieldForm} from "./literal"
+
+export class LiteralListForm {
+    constructor(dom, initialValue = [[]]) {
+        this.dom = dom
+        this.fieldHandlers = new WeakMap()
+        this.inputList = new InputList({
+            dom,
+            initialValues: initialValue,
+            emptyValue: [],
+            renderItem: value => ({
+                html: `<div class="literal-field"></div>`,
+                bind: el => {
+                    const fieldHandler = new LiteralFieldForm(
+                        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/literal_long.js

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

package/src/form/fields/name.js

@@ -0,0 +1,152 @@
+import {TypeSwitch, getFocusIndex, setFocusIndex} from "fwtoolkit"
+import {LiteralFieldForm} from "./literal"
+
+// There are only name lists, no name fields in the data format. The separation
+// between NameFieldForm and NameListForm is for keeping consistency with other fields
+// and lists.
+
+export class NameFieldForm {
+    constructor(
+        dom,
+        initialValue = {
+            given: [],
+            family: [],
+            prefix: [],
+            suffix: [],
+            useprefix: false,
+            literal: []
+        }
+    ) {
+        this.currentValue = initialValue
+        this.dom = dom
+        // We set the mode based on whether there was a literal name.
+        if (initialValue.literal) {
+            this.realPerson = false
+        } else {
+            this.realPerson = true
+        }
+    }
+
+    init() {
+        this.typeSwitch = new TypeSwitch({
+            dom: this.dom,
+            label1: gettext("Person"),
+            label2: gettext("Organization"),
+            initialMode: this.realPerson ? 1 : 2,
+            beforeChange: () => {
+                const formValue = this.value
+                if (formValue) {
+                    Object.assign(this.currentValue, formValue)
+                }
+            },
+            onChange: mode => {
+                this.realPerson = mode === 1
+                const focusIndex = getFocusIndex()
+                this.drawForm()
+                setFocusIndex(focusIndex)
+            }
+        })
+        this.drawForm()
+    }
+
+    drawForm() {
+        if (this.realPerson) {
+            this.drawPersonForm()
+        } else {
+            this.drawOrganizationForm()
+        }
+    }
+
+    drawPersonForm() {
+        this.fields = {}
+        this.typeSwitch.innerElement.innerHTML = `
+                <div class='given field-part field-part-long'></div>
+                <div class='prefix field-part field-part-short'></div>
+                <div class='family field-part field-part-long'></div>
+                <div class='suffix field-part field-part-short'></div>
+                <div class='useprefix field-part'>
+                    <input type='checkbox' class='useprefix'
+                        ${this.currentValue.useprefix ? "checked" : ""}>
+                    &nbsp;${gettext("Prefix used")}
+                </div>
+            `
+        this.fields["given"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".given"),
+            this.currentValue.given,
+            gettext("First name")
+        )
+        this.fields.given.init()
+        this.fields["prefix"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".prefix"),
+            this.currentValue.prefix,
+            gettext("Prefix")
+        )
+        this.fields.prefix.init()
+        this.fields["family"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".family"),
+            this.currentValue.family,
+            gettext("Last name")
+        )
+        this.fields.family.init()
+        this.fields["suffix"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".suffix"),
+            this.currentValue.suffix,
+            gettext("Suffix")
+        )
+        this.fields.suffix.init()
+    }
+
+    drawOrganizationForm() {
+        this.fields = {}
+        this.typeSwitch.innerElement.innerHTML = `<div class='literal-text field-part field-part-single'></div>`
+        this.fields["literal"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".literal-text"),
+            this.currentValue.literal,
+            gettext("Organization name")
+        )
+        this.fields.literal.init()
+    }
+
+    get value() {
+        if (this.realPerson) {
+            if (
+                !this.fields.family.value &&
+                !this.fields.given.value &&
+                !this.fields.prefix.value &&
+                !this.fields.suffix.value
+            ) {
+                return false
+            }
+            const returnObject = {
+                family: this.fields.family.value
+                    ? this.fields.family.value
+                    : [],
+                given: this.fields.given.value ? this.fields.given.value : []
+            }
+            if (this.fields.prefix.value) {
+                returnObject["prefix"] = this.fields.prefix.value
+                returnObject["useprefix"] =
+                    this.typeSwitch.innerElement.querySelector(
+                        "input.useprefix"
+                    ).checked
+                        ? true
+                        : false
+            }
+            if (this.fields.suffix.value) {
+                returnObject["suffix"] = this.fields.suffix.value
+            }
+            return returnObject
+        } else {
+            if (!this.fields.literal.value) {
+                return false
+            }
+            return {
+                literal: this.fields.literal.value
+            }
+        }
+    }
+
+    check() {
+        return true
+    }
+}

package/src/form/fields/name_list.js

@@ -0,0 +1,42 @@
+import {InputList} from "fwtoolkit"
+import {NameFieldForm} from "./name"
+
+export class NameListForm {
+    constructor(dom, initialValue = [[]]) {
+        this.dom = dom
+        this.fieldHandlers = new WeakMap()
+        this.inputList = new InputList({
+            dom,
+            initialValues: initialValue,
+            emptyValue: [],
+            renderItem: value => ({
+                html: `<div class="name-field"></div>`,
+                bind: el => {
+                    const fieldHandler = new NameFieldForm(
+                        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/range.js

@@ -0,0 +1,104 @@
+import {TypeSwitch, getFocusIndex, setFocusIndex} from "fwtoolkit"
+import {LiteralFieldForm} from "./literal"
+
+// There are only range lists, no range fields in the data format. The separation
+// between RangeFieldForm and RangeListForm is for keeping consistency with other fields
+// and lists.
+
+export class RangeFieldForm {
+    constructor(dom, initialValue = [[]]) {
+        this.currentValue = initialValue
+        this.dom = dom
+        // We set the mode based on whether there is one or two initial values.
+        if (initialValue.length > 1) {
+            this.range = true
+        } else {
+            this.range = false
+        }
+    }
+
+    init() {
+        this.typeSwitch = new TypeSwitch({
+            dom: this.dom,
+            label1: gettext("Single value"),
+            label2: gettext("Range"),
+            initialMode: this.range ? 2 : 1,
+            beforeChange: () => {
+                const formValue = this.value
+                if (formValue) {
+                    Object.assign(this.currentValue, formValue)
+                }
+            },
+            onChange: mode => {
+                this.range = mode === 2
+                const focusIndex = getFocusIndex()
+                this.drawForm()
+                setFocusIndex(focusIndex)
+            }
+        })
+        this.drawForm()
+    }
+
+    drawForm() {
+        if (this.range) {
+            this.drawRangeForm()
+        } else {
+            this.drawSingleValueForm()
+        }
+    }
+
+    drawSingleValueForm() {
+        this.fields = {}
+        this.typeSwitch.innerElement.innerHTML = `<div class='single-value field-part field-part-single'></div>`
+        this.fields["single"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".single-value"),
+            this.currentValue[0]
+        )
+        this.fields.single.init()
+    }
+
+    drawRangeForm() {
+        this.fields = {}
+        this.typeSwitch.innerElement.innerHTML = `
+                <div class='range-from field-part field-part-huge'></div>
+                <div class='range-to field-part field-part-huge'></div>
+            `
+        this.fields["from"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".range-from"),
+            this.currentValue[0],
+            gettext("From")
+        )
+        this.fields.from.init()
+        this.fields["to"] = new LiteralFieldForm(
+            this.typeSwitch.innerElement.querySelector(".range-to"),
+            this.currentValue[1],
+            gettext("To")
+        )
+        this.fields.to.init()
+    }
+
+    get value() {
+        if (this.range) {
+            if (!this.fields.from.value && !this.fields.to.value) {
+                return false
+            }
+            return [
+                this.fields.from.value
+                    ? this.fields.from.value
+                    : [{type: "text", text: ""}],
+                this.fields.to.value
+                    ? this.fields.to.value
+                    : [{type: "text", text: ""}]
+            ]
+        } else {
+            if (!this.fields.single.value) {
+                return false
+            }
+            return [this.fields.single.value]
+        }
+    }
+
+    check() {
+        return true
+    }
+}