@fiduswriter/editor 0.1.0

package/src/copyright_dialog/index.js

@@ -0,0 +1,179 @@
+import {edtfParse} from "bibliojson"
+import deepEqual from "fast-deep-equal"
+import {Dialog, InputList, TypeSwitch, escapeText} from "fwtoolkit"
+import {
+    copyrightTemplate,
+    licenseInputTemplate,
+    licenseSelectTemplate
+} from "./templates"
+
+export const LICENSE_URLS = [
+    ["CC BY 4.0", "https://creativecommons.org/licenses/by/4.0/"],
+    ["CC BY-SA 4.0", "https://creativecommons.org/licenses/by-sa/4.0/"],
+    ["CC BY-ND 4.0", "https://creativecommons.org/licenses/by-nd/4.0/"],
+    ["CC BY-NC 4.0", "https://creativecommons.org/licenses/by-nc/4.0/"],
+    ["CC BY-NC-SA 4.0", "https://creativecommons.org/licenses/by-nc-sa/4.0/"],
+    ["CC BY-NC-ND 4.0", "https://creativecommons.org/licenses/by-nc-nd/4.0/"],
+    ["CC0", "https://creativecommons.org/publicdomain/zero/1.0/"]
+]
+
+function getLicenseTitle(url) {
+    const license = LICENSE_URLS.find(license => license[1] === url)
+    return license ? license[0] : ""
+}
+
+export class CopyrightDialog {
+    constructor(copyright) {
+        this.copyright = copyright
+        this.origCopyright = copyright
+        this.dialog = false
+    }
+
+    getCurrentValue() {
+        this.copyright = {}
+        const holder = this.dialog.dialogEl.querySelector(".holder").value
+        this.copyright.holder = holder.length ? holder : false
+        const year = this.dialog.dialogEl.querySelector(".year").value
+        this.copyright.year = year.length
+            ? Math.max(0, Math.min(Number.parseInt(year) || 0, 2100))
+            : false
+        this.copyright.freeToRead = this.dialog.dialogEl.querySelector(
+            ".free-to-read:checked"
+        )
+            ? true
+            : false
+        const licenseStartDates = Array.from(
+            this.dialog.dialogEl.querySelectorAll(".license-start")
+        ).map(el => el.value)
+        this.copyright.licenses = this.licensesList.values
+            .map((license, index) => {
+                if (!license.url.length) {
+                    return false
+                }
+                const returnValue = {
+                    url: license.url,
+                    title: license.title
+                }
+                const startDate = edtfParse(licenseStartDates[index])
+                if (
+                    startDate.valid &&
+                    (startDate.type === "Date" ||
+                        startDate.type === "YearMonth" ||
+                        startDate.type === "Year") &&
+                    !startDate.uncertain &&
+                    !startDate.approximate
+                ) {
+                    returnValue.start = startDate.cleanedString
+                }
+                return returnValue
+            })
+            .filter(license => license)
+    }
+
+    init() {
+        return new Promise(resolve => {
+            const buttons = []
+            buttons.push({
+                text: gettext("Change"),
+                classes: "fw-dark",
+                click: () => {
+                    this.dialog.close()
+                    this.getCurrentValue()
+                    if (deepEqual(this.copyright, this.origCopyright)) {
+                        // No change.
+                        resolve(false)
+                    }
+                    resolve(this.copyright)
+                }
+            })
+
+            buttons.push({
+                type: "cancel"
+            })
+
+            this.dialog = new Dialog({
+                width: 940,
+                height: 300,
+                id: "configure-copyright",
+                title: gettext("Set copyright information"),
+                body: copyrightTemplate(this.copyright),
+                buttons
+            })
+
+            this.dialog.open()
+            this.bind()
+        })
+    }
+
+    bind() {
+        this.licensesList = new InputList({
+            dom: this.dialog.dialogEl.querySelector(".copyright-licenses-list"),
+            initialValues: this.copyright.licenses || [],
+            emptyValue: {url: "", title: "", start: false},
+            renderItem: license => ({
+                html: `<div class="copyright-license-switch"></div>
+                    <div class="field-part field-part-small">
+                        <input type="text" class="license-start" value="${license.start ? escapeText(license.start) : ""}" placeholder="${gettext("Start date")}">
+                    </div>`,
+                bind: el => {
+                    const licenseContainer = el.closest("tr")
+                    const startInput =
+                        licenseContainer.querySelector(".license-start")
+                    if (license.start) {
+                        startInput.value = license.start
+                    }
+
+                    const mode =
+                        license.url === "" ||
+                        LICENSE_URLS.find(
+                            licenseUrl => licenseUrl[1] === license.url
+                        )
+                            ? 1
+                            : 2
+                    new TypeSwitch({
+                        dom: el.querySelector(".copyright-license-switch"),
+                        label1: gettext("From list"),
+                        label2: gettext("Custom"),
+                        initialMode: mode,
+                        render1: () =>
+                            licenseSelectTemplate({url: license.url}),
+                        render2: () =>
+                            licenseInputTemplate({
+                                url: license.url,
+                                title: license.title
+                            }),
+                        onChange: () => {
+                            // Restore focus to the license input after switching.
+                            const focusable = el.querySelector(
+                                ".fw-type-switch-input-inner input, .fw-type-switch-input-inner select"
+                            )
+                            if (focusable) {
+                                focusable.focus()
+                            }
+                        }
+                    })
+                }
+            }),
+            getValue: el => {
+                const licenseInput = el.querySelector(
+                    ".fw-type-switch-input-inner"
+                )
+                const selectEl = licenseInput.querySelector("select.license")
+                let url, title
+                if (selectEl) {
+                    url = selectEl.value
+                    title = getLicenseTitle(url)
+                } else {
+                    url = licenseInput.querySelector("input.license").value
+                    title = licenseInput.querySelector(
+                        "input.license-title"
+                    ).value
+                }
+                const start =
+                    el.closest("tr").querySelector(".license-start").value ||
+                    false
+                return {url, title, start}
+            }
+        })
+    }
+}

package/src/copyright_dialog/templates.js

@@ -0,0 +1,56 @@
+import {escapeText} from "fwtoolkit"
+import {LICENSE_URLS} from "./index"
+
+export const licenseSelectTemplate = ({url}) =>
+    `<select class="license">
+        <option value=""></option>
+        ${LICENSE_URLS.map(
+            licenseUrl =>
+                `<option value="${licenseUrl[1]}"${url === licenseUrl[1] ? " selected" : ""}>${licenseUrl[0]}</option>`
+        ).join("")}
+    </select>
+    <div class="fw-select-arrow fa fa-caret-down"></div>`
+
+export const licenseInputTemplate = ({url, title}) =>
+    `<div class="field-part field-part-huge">
+        <input type='text' class='license' value="${escapeText(url)}" placeholder="${gettext("License URL")}">
+    </div>
+    <div class="field-part field-part-huge">
+        <input type='text' class='license-title' value="${escapeText(title)}" placeholder="${gettext("License Title")}">
+    </div>`
+
+export const copyrightTemplate = ({holder, year, freeToRead}) =>
+    `<table class="fw-dialog-table">
+        <tbody>
+            <tr>
+                <th><h4 class="fw-tablerow-title fw-wtooltip">
+                    ${gettext("Copyright holder")}
+                    <span class="fw-tooltip">${gettext("If the work is not in the public domain, specify who the copyright holder is.")}</span>
+                </h4></th>
+                <td class="fw-entry-field"><input type="text" class="holder" value="${holder ? escapeText(holder) : ""}"></td>
+            </tr>
+            <tr>
+                <th><h4 class="fw-tablerow-title fw-wtooltip">
+                    ${gettext("Copyright year")}
+                    <span class="fw-tooltip">${gettext("If the work is not in the public domain, specify the year of the copyright.")}</span>
+                </h4></th>
+                <td class="fw-entry-field"><input type="number" class="year" min=0 max=2100 value="${year ? year : ""}"></td>
+            </tr>
+            <tr>
+                <th><h4 class="fw-tablerow-title fw-wtooltip">
+                    ${gettext("Available to read for free?")}
+                    <span class="fw-tooltip">${gettext("Specify whether the work can be accessed without paying a fee.")}</span>
+                </h4></th>
+                <td class="fw-entry-field"><input type="checkbox" class="free-to-read"${freeToRead ? " checked" : ""}></td>
+            </tr>
+            <tr>
+                <th><h4 class="fw-tablerow-title fw-wtooltip">
+                    ${gettext("License(s)")}
+                    <span class="fw-tooltip">${gettext('List any licenses the work is available under. If the license only applies from a given date, please specify the date in the ISO8601 format (such as "2012-10-15").')}</span>
+                </h4></th>
+                <td class="fw-entry-field licenses">
+                    <div class="copyright-licenses-list"></div>
+                </td>
+            </tr>
+        </tbody>
+    </table>`

package/src/databases/bibliography.js

@@ -0,0 +1,179 @@
+import deepEqual from "fast-deep-equal"
+
+function randomID() {
+    return Math.floor(Math.random() * 0xffffffff)
+}
+
+export class ModBibliographyDB {
+    constructor(mod) {
+        mod.bibDB = this
+        this.mod = mod
+        this.db = false
+        this.unsent = []
+        // cats aren't used, but we keep this for consistency
+        this.cats = []
+    }
+
+    setDB(db) {
+        this.db = db
+        this.unsent = []
+    }
+
+    mustSend() {
+        // Set a timeout so that the update can be combines with other updates
+        // if they happen more or less simultaneously.
+        window.setTimeout(
+            () => this.mod.editor.mod.collab.doc.sendToCollaborators(),
+            100
+        )
+    }
+
+    // function saveBibEntries is the same as in user's individual BibliographyDB.
+    // Function added to make document's and user's bibDBs be connectable to the
+    // same interface functions.
+    saveBibEntries(tmpDB, isNew) {
+        const idTranslations = []
+        Object.keys(tmpDB).forEach(bibKey => {
+            const reference = tmpDB[bibKey],
+                bibId = Number.parseInt(bibKey)
+            delete reference.cats
+            const oldRef = this.findReference(reference)
+            if (oldRef) {
+                idTranslations.push([bibId, oldRef])
+            } else if (isNew) {
+                const id = this.addReference(reference, bibId)
+                idTranslations.push([bibId, id])
+            } else {
+                this.updateReference(bibId, reference)
+                idTranslations.push([bibId, bibId])
+            }
+            // We don't use cats in the document internal bibDB, so just
+            // to make sure, we remove it.
+        })
+        return Promise.resolve(idTranslations)
+    }
+
+    // Function added here for compatibility with user's bibDB. See comment at
+    // saveBibEntries function.
+    updateLocalBibEntries(tmpDB, idTranslations) {
+        idTranslations.forEach(bibTrans => {
+            this.updateLocalReference([bibTrans[1]], tmpDB[bibTrans[0]])
+        })
+        return idTranslations
+    }
+
+    // Function added here for compatibility with user's bibDB. See comment at
+    // saveBibEntries function.
+    deleteBibEntries(ids) {
+        ids.forEach(id => this.deleteReference(id))
+        return Promise.resolve(ids)
+    }
+
+    // This function only makes real sense in the user's bibDB. It is kept here
+    // for compatibility reasons.
+    getDB() {
+        return new Promise(resolve => {
+            window.setTimeout(() => resolve({bibPks: [], bibCats: []}), 100)
+        })
+    }
+
+    addReference(reference, id) {
+        while (!id || this.db[id]) {
+            id = randomID()
+        }
+        this.updateReference(id, reference)
+        return id
+    }
+
+    // Add or update a reference to the bibliography database both remotely and locally.
+    updateReference(id, reference) {
+        this.updateLocalReference(id, reference)
+        this.unsent.push({
+            type: "update",
+            id
+        })
+        this.mustSend()
+    }
+
+    // Add or update a reference only locally.
+    updateLocalReference(id, reference) {
+        const preExisting = this.db[id] ? true : false
+        this.db[id] = reference
+        if (preExisting) {
+            this.mod.editor.mod.citations.resetCitations()
+        } else {
+            this.mod.editor.mod.citations.layoutCitations()
+        }
+    }
+
+    deleteReference(id) {
+        this.deleteLocalReference(id)
+        this.unsent.push({
+            type: "delete",
+            id
+        })
+        this.mustSend()
+    }
+
+    deleteLocalReference(id) {
+        delete this.db[id]
+    }
+
+    hasUnsentEvents() {
+        return this.unsent.length
+    }
+
+    unsentEvents() {
+        return this.unsent.map(event => {
+            if (event.type === "delete") {
+                return event
+            } else if (event.type === "update") {
+                // Check bib entry still exists. Otherwise ignore.
+                const reference = this.db[event.id]
+                if (reference) {
+                    return {
+                        type: "update",
+                        id: event.id,
+                        reference
+                    }
+                } else {
+                    return {
+                        type: "ignore"
+                    }
+                }
+            }
+        })
+    }
+
+    eventsSent(n) {
+        this.unsent = this.unsent.slice(n.length)
+    }
+
+    receive(events) {
+        events.forEach(event => {
+            if (event.type == "delete") {
+                this.deleteLocalReference(event.id)
+            } else if (event.type == "update") {
+                this.updateLocalReference(event.id, event.reference)
+            }
+        })
+    }
+
+    findReference(ref) {
+        return Object.keys(this.db).find(id => {
+            const bib = this.db[id]
+            return (
+                bib.bib_type === ref.bib_type &&
+                deepEqual(bib.fields, ref.fields)
+            )
+        })
+    }
+
+    hasReference(ref) {
+        if (this.findReference(ref) !== undefined) {
+            return true
+        } else {
+            return false
+        }
+    }
+}