@fiduswriter/editor 0.1.0

package/src/menus/headerbar/model.js

@@ -0,0 +1,1077 @@
+import {
+    Dialog,
+    addAlert,
+    addProgress,
+    postJson,
+    shortFileTitle
+} from "fwtoolkit"
+import {CopyrightDialog} from "../../../copyright_dialog"
+import {DocumentAccessRightsDialog} from "../../../documents/access_rights"
+import {SaveCopy, SaveRevision} from "../../../exporter/native"
+import {ExportFidusFile} from "../../../exporter/native/file"
+import {LanguageDialog, RevisionDialog} from "../../dialogs"
+import {E2EEKeyManager} from "../../e2ee/key-manager"
+import {PassphraseManager} from "../../e2ee/passphrase-manager"
+import {changePasswordDialog} from "../../e2ee/password-dialog"
+import {
+    KeyBindingsDialog,
+    SearchReplaceDialog,
+    WordCountDialog
+} from "../../tools"
+
+const exportProgress = doc => {
+    const title = shortFileTitle(doc.title, doc.path || "")
+    const task = addProgress("info", `${title}: ${gettext("Exporting...")}`, {
+        autoClose: false
+    })
+    return (message, percentage) => task.update(percentage, message)
+}
+
+const languageItem = (language, name, order) => ({
+    title: name,
+    type: "setting",
+    order,
+    action: editor => {
+        editor.view.dispatch(
+            editor.view.state.tr
+                .setDocAttribute("language", language)
+                .setMeta("settings", true)
+        )
+    },
+    selected: editor => {
+        return editor.view.state.doc.attrs.language === language
+    },
+    available: editor => {
+        return editor.view.state.doc.attrs.languages.includes(language)
+    }
+})
+
+export const headerbarModel = () => ({
+    open: window.innerWidth > 500, // Whether the menu is shown at all.
+    content: [
+        {
+            id: "file",
+            title: gettext("File"),
+            tooltip: gettext("File handling"),
+            type: "menu",
+            keys: "Alt-f",
+            order: 0,
+            content: [
+                {
+                    title: editor =>
+                        editor.user.is_authenticated &&
+                        editor.docInfo.token &&
+                        !editor.docInfo.is_owner
+                            ? gettext("Request Access")
+                            : gettext("Share"),
+                    type: "action",
+                    //icon: 'share',
+                    tooltip: editor =>
+                        editor.user.is_authenticated &&
+                        editor.docInfo.token &&
+                        !editor.docInfo.is_owner
+                            ? gettext("Request to be added as a collaborator.")
+                            : gettext("Share the document with other users."),
+                    order: 0,
+                    action: editor => {
+                        if (
+                            editor.user.is_authenticated &&
+                            editor.docInfo.token &&
+                            !editor.docInfo.is_owner
+                        ) {
+                            // TokenUser requesting access
+                            postJson("/api/document/request_access/", {
+                                document_id: editor.docInfo.id,
+                                rights: "write"
+                            })
+                                .then(({json}) => {
+                                    if (json.success) {
+                                        addAlert(
+                                            "success",
+                                            gettext(
+                                                "Your access request has been sent to the document owner."
+                                            )
+                                        )
+                                    } else {
+                                        addAlert(
+                                            "error",
+                                            json.error ||
+                                                gettext(
+                                                    "Could not send access request."
+                                                )
+                                        )
+                                    }
+                                })
+                                .catch(() => {
+                                    addAlert(
+                                        "error",
+                                        gettext(
+                                            "Could not send access request."
+                                        )
+                                    )
+                                })
+                            return
+                        }
+                        const onShareSuccess = async newAccessRights => {
+                            // Share the document password with newly-added user recipients.
+                            if (
+                                editor.e2ee?.password &&
+                                PassphraseManager.hasKeysInSession()
+                            ) {
+                                const userRecipients = newAccessRights.filter(
+                                    ar =>
+                                        ar.holder?.type === "user" &&
+                                        ar.rights !== "delete"
+                                )
+                                const noPassphraseUsers = []
+                                for (const ar of userRecipients) {
+                                    try {
+                                        const hasKeys =
+                                            await PassphraseManager.userHasEncryptionKeys(
+                                                ar.holder.id
+                                            )
+                                        if (hasKeys) {
+                                            // Recipient has passphrase keys —
+                                            // encrypt document password with their public key.
+                                            await PassphraseManager.saveDocumentPassword(
+                                                editor.docInfo.id,
+                                                editor.e2ee.password,
+                                                ar.holder.id,
+                                                "user",
+                                                false
+                                            )
+                                        } else {
+                                            noPassphraseUsers.push(
+                                                ar.holder?.name || "user"
+                                            )
+                                        }
+                                    } catch (_e) {
+                                        noPassphraseUsers.push(
+                                            ar.holder?.name || "user"
+                                        )
+                                    }
+                                }
+
+                                if (noPassphraseUsers.length > 0) {
+                                    const dialog = new Dialog({
+                                        title: gettext(
+                                            "Share Document Password"
+                                        ),
+                                        id: "share-password-dialog",
+                                        width: 500,
+                                        body: `<p>${gettext(
+                                            "The following users don't have passphrase encryption. Please share the document password with them directly."
+                                        )}</p><ul>${noPassphraseUsers
+                                            .map(
+                                                name =>
+                                                    `<li><strong>${name}</strong>: <code>${editor.e2ee.password}</code></li>`
+                                            )
+                                            .join("")}</ul>`,
+                                        buttons: [
+                                            {
+                                                text: gettext("Close"),
+                                                classes: "fw-dark",
+                                                click: () => dialog.close()
+                                            }
+                                        ]
+                                    })
+                                    dialog.open()
+                                }
+                            }
+                        }
+                        const dialog = new DocumentAccessRightsDialog(
+                            [editor.docInfo.id],
+                            editor.docInfo.owner.contacts,
+                            contactData => {
+                                editor.docInfo.owner.contacts.push(contactData)
+                            },
+                            editor.e2ee?.encrypted,
+                            editor.e2ee?.password || "",
+                            onShareSuccess,
+                            editor.app.settings
+                        )
+                        dialog.init()
+                    },
+                    disabled: editor => {
+                        return (
+                            editor.app.isOffline() ||
+                            !editor.user.is_authenticated
+                        )
+                    }
+                },
+                {
+                    title: editor =>
+                        editor.user.is_authenticated
+                            ? gettext("Close")
+                            : gettext("Sign up / Log in"),
+                    type: "action",
+                    //icon: 'times-circle',
+                    tooltip: editor =>
+                        editor.user.is_authenticated
+                            ? gettext(
+                                  "Close the document and return to the document overview menu."
+                              )
+                            : gettext("Sign up for an account or log in."),
+                    order: 1,
+                    action: editor => {
+                        if (editor.user.is_authenticated) {
+                            const folderPath = editor.docInfo.path.slice(
+                                0,
+                                editor.docInfo.path.lastIndexOf("/")
+                            )
+                            if (
+                                !folderPath.length &&
+                                editor.app.routes[""].app === "document"
+                            ) {
+                                editor.app.goTo("/")
+                            } else {
+                                editor.app.goTo(`/documents${folderPath}/`)
+                            }
+                        } else {
+                            if (
+                                editor.app.settings?.REGISTRATION_OPEN ||
+                                editor.app.settings?.SOCIALACCOUNT_OPEN
+                            ) {
+                                window.location.href = "/account/sign-up/"
+                            } else {
+                                window.location.href = "/"
+                            }
+                        }
+                        return
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("Save revision"),
+                    type: "action",
+                    //icon: 'save',
+                    tooltip: gettext("Save a revision of the document."),
+                    order: 2,
+                    keys: "Ctrl-s",
+                    action: editor => {
+                        const dialog = new RevisionDialog(editor.docInfo.dir)
+                        dialog.init().then(note => {
+                            const saver = new SaveRevision(
+                                editor.getDoc(),
+                                editor.mod.db.imageDB,
+                                editor.mod.db.bibDB,
+                                note,
+                                editor.app
+                            )
+                            return saver.init()
+                        })
+                    },
+                    disabled: editor =>
+                        editor.docInfo.access_rights !== "write" ||
+                        editor.app.isOffline() ||
+                        !!editor.docInfo.token
+                },
+                {
+                    title: gettext("Create copy"),
+                    type: "action",
+                    //icon: 'copy',
+                    tooltip: gettext("Create a copy of the document."),
+                    order: 3,
+                    action: editor => {
+                        const copier = new SaveCopy(
+                            editor.getDoc(),
+                            editor.mod.db.bibDB,
+                            editor.mod.db.imageDB,
+                            editor.user
+                        )
+                        copier
+                            .init()
+                            .then(({docInfo}) =>
+                                editor.app.goTo(`/document/${docInfo.id}/`)
+                            )
+                            .catch(() => false)
+                    },
+                    disabled: editor =>
+                        editor.app.isOffline() ||
+                        (!!editor.docInfo.token &&
+                            !editor.user.is_authenticated)
+                },
+                {
+                    title: gettext("Download"),
+                    type: "action",
+                    //icon: 'download',
+                    tooltip: gettext(
+                        "Export the document as a FIDUS file including its template."
+                    ),
+                    order: 4,
+                    action: editor => {
+                        new ExportFidusFile(
+                            editor.getDoc(),
+                            editor.mod.db.bibDB,
+                            editor.mod.db.imageDB,
+                            true,
+                            editor.docInfo.token
+                        )
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("Print/PDF"),
+                    type: "action",
+                    //icon: 'print',
+                    tooltip: gettext(
+                        "Either print or create a PDF using your browser print dialog."
+                    ),
+                    order: 5,
+                    keys: "Ctrl-p",
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/print/index"
+                        ).then(({PrintExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const title = shortFileTitle(
+                                doc.title,
+                                doc.path || ""
+                            )
+                            const task = addProgress(
+                                "info",
+                                `${title}: ${gettext("Preparing print view...")}`,
+                                {autoClose: false}
+                            )
+                            const exporter = new PrintExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.app.csl,
+                                editor.docInfo.updated,
+                                editor.mod.documentTemplate.documentStyles,
+                                (message, percentage) =>
+                                    task.update(percentage, message)
+                            )
+                            exporter.init()
+                        })
+                    }
+                },
+                {
+                    title: gettext("Change password"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Change the password of this encrypted document."
+                    ),
+                    order: 6,
+                    available: editor => editor.docInfo.e2ee,
+                    action: async editor => {
+                        if (!editor.e2ee?.key) {
+                            addAlert(
+                                "error",
+                                gettext(
+                                    "Document key is not available. Please reload the document."
+                                )
+                            )
+                            return
+                        }
+                        const isPassphraseUser =
+                            editor.e2ee?.usesPassphrase &&
+                            PassphraseManager.hasKeysInSession()
+                        const suggestedNewPassword = isPassphraseUser
+                            ? await PassphraseManager.generateDocumentPassword()
+                            : ""
+
+                        let changeOptions
+                        if (isPassphraseUser) {
+                            // Passphrase users: current password is known, new password
+                            // is auto-generated and shown in plaintext for sharing.
+                            changeOptions = {
+                                currentPassword:
+                                    editor.e2ee.password ||
+                                    E2EEKeyManager.getPasswordFromSession(
+                                        editor.docInfo.id
+                                    ) ||
+                                    "",
+                                suggestedNewPassword,
+                                hideCurrentPassword: true,
+                                showNewPasswordPlaintext: true,
+                                infoText: gettext(
+                                    "Your personal passphrase will still unlock this document. A new random password is generated automatically. Other passphrase users will receive it automatically; non-passphrase collaborators need it shared with them manually."
+                                )
+                            }
+                        } else {
+                            // Non-passphrase users: prefill current password from
+                            // sessionStorage if available, but keep it visible for
+                            // verification.
+                            const sessionPassword =
+                                E2EEKeyManager.getPasswordFromSession(
+                                    editor.docInfo.id
+                                )
+                            changeOptions = {
+                                currentPassword: sessionPassword || "",
+                                suggestedNewPassword: ""
+                            }
+                        }
+
+                        changePasswordDialog(
+                            async ({currentPassword, newPassword}) => {
+                                try {
+                                    // Verify the current password.
+                                    // If the entered password matches what is already cached
+                                    // in memory or sessionStorage, the document is already
+                                    // open with that key — skip the expensive PBKDF2
+                                    // re-derivation used only to prove correctness.
+                                    const cachedPassword =
+                                        editor.e2ee.password ||
+                                        E2EEKeyManager.getPasswordFromSession(
+                                            editor.docInfo.id
+                                        )
+                                    if (
+                                        !cachedPassword ||
+                                        currentPassword !== cachedPassword
+                                    ) {
+                                        const currentSaltBytes = new Uint8Array(
+                                            atob(editor.e2ee.encryptionSalt)
+                                                .split("")
+                                                .map(c => c.charCodeAt(0))
+                                        )
+                                        const currentKey =
+                                            await E2EEKeyManager.resolvePasswordToKey(
+                                                currentPassword,
+                                                currentSaltBytes,
+                                                editor.e2ee.encryptionIterations
+                                            )
+                                        const {E2EEEncryptor} = await import(
+                                            "../../e2ee/encryptor"
+                                        )
+                                        const testValue = "test"
+                                        const encryptedTest =
+                                            await E2EEEncryptor.encrypt(
+                                                testValue,
+                                                currentKey
+                                            )
+                                        await E2EEEncryptor.decrypt(
+                                            encryptedTest,
+                                            editor.e2ee.key
+                                        )
+                                    }
+
+                                    // Current password verified — generate new salt and key
+                                    const newSalt =
+                                        E2EEKeyManager.generateSalt()
+                                    const newSaltBase64 = btoa(
+                                        String.fromCharCode(...newSalt)
+                                    )
+                                    const newIterations = 600000
+                                    const newKey =
+                                        await E2EEKeyManager.resolvePasswordToKey(
+                                            newPassword,
+                                            newSalt,
+                                            newIterations
+                                        )
+
+                                    // Re-encrypt the document with the new key
+                                    await editor.e2ee.snapshotManager.reEncryptWithNewKey(
+                                        newKey,
+                                        newSaltBase64,
+                                        newIterations
+                                    )
+
+                                    // Update local E2EE state
+                                    editor.e2ee.encryptionSalt = newSaltBase64
+                                    editor.e2ee.encryptionIterations =
+                                        newIterations
+                                    editor.e2ee.key = newKey
+                                    editor.e2ee.password = newPassword
+
+                                    // Cache password and key in sessionStorage
+                                    E2EEKeyManager.storePasswordInSession(
+                                        editor.docInfo.id,
+                                        newPassword
+                                    )
+                                    await E2EEKeyManager.storeKeyInSession(
+                                        editor.docInfo.id,
+                                        newKey
+                                    )
+
+                                    // If passphrase user, update encrypted password on server
+                                    if (isPassphraseUser) {
+                                        try {
+                                            await PassphraseManager.saveDocumentPassword(
+                                                editor.docInfo.id,
+                                                newPassword,
+                                                null,
+                                                "user",
+                                                true
+                                            )
+                                        } catch (_e) {
+                                            console.error(
+                                                "Failed to update document password on server:",
+                                                _e
+                                            )
+                                        }
+                                    }
+
+                                    if (isPassphraseUser) {
+                                        addAlert(
+                                            "success",
+                                            gettext(
+                                                "Document encryption key rotated. Other passphrase users will receive the new key automatically."
+                                            )
+                                        )
+                                    } else {
+                                        addAlert(
+                                            "success",
+                                            gettext(
+                                                "Document password changed. Remember to share the new password with your collaborators."
+                                            )
+                                        )
+                                    }
+                                } catch (_error) {
+                                    addAlert(
+                                        "error",
+                                        gettext(
+                                            "The current password is incorrect."
+                                        )
+                                    )
+                                }
+                            },
+                            changeOptions
+                        )
+                    },
+                    disabled: editor =>
+                        !editor.e2ee?.encrypted ||
+                        editor.docInfo.access_rights !== "write"
+                }
+            ]
+        },
+        {
+            id: "export",
+            title: gettext("Export"),
+            tooltip: gettext("Export of the document contents"),
+            type: "menu",
+            order: 1,
+            keys: "Alt-e",
+            content: [
+                {
+                    title: gettext("HTML"),
+                    type: "action",
+                    tooltip: gettext("Export the document to an HTML file."),
+                    order: 0,
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/html/index"
+                        ).then(({HTMLExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const exporter = new HTMLExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.app.csl,
+                                editor.docInfo.updated,
+                                editor.mod.documentTemplate.documentStyles
+                            )
+                            exporter.progressCallback = exportProgress(doc)
+                            exporter.init()
+                        })
+                    }
+                },
+                {
+                    title: gettext("Epub"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Export the document to an Epub electronic reader file."
+                    ),
+                    order: 1,
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/epub/index"
+                        ).then(({EpubExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const exporter = new EpubExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.app.csl,
+                                editor.docInfo.updated,
+                                editor.mod.documentTemplate.documentStyles
+                            )
+                            exporter.progressCallback = exportProgress(doc)
+                            exporter.init()
+                        })
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("LaTeX"),
+                    type: "action",
+                    tooltip: gettext("Export the document to an LaTeX file."),
+                    order: 2,
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/latex/index"
+                        ).then(({LatexExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const exporter = new LatexExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.docInfo.updated
+                            )
+                            exporter.progressCallback = exportProgress(doc)
+                            exporter.init()
+                        })
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("JATS"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Export the document to a Journal Archiving and Interchange Tag Library NISO JATS Version 1.2 file."
+                    ),
+                    order: 2,
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/jats/index"
+                        ).then(({JATSExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const exporter = new JATSExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.app.csl,
+                                editor.docInfo.updated,
+                                "article"
+                            )
+                            exporter.progressCallback = exportProgress(doc)
+                            exporter.init()
+                        })
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("BITS"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Export the document to a Book Interchange Tag Set BITS Version 2.1 file."
+                    ),
+                    order: 2,
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/jats/index"
+                        ).then(({JATSExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const exporter = new JATSExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.app.csl,
+                                editor.docInfo.updated,
+                                "book-part-wrapper"
+                            )
+                            exporter.progressCallback = exportProgress(doc)
+                            exporter.init()
+                        })
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("Pandoc JSON"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Export the document to a Pandoc JSON file."
+                    ),
+                    order: 3,
+                    action: editor => {
+                        import(
+                            "@fiduswriter/document/exporter/pandoc/index"
+                        ).then(({PandocExporter}) => {
+                            const doc = editor.getDoc({
+                                changes: "acceptAllNoInsertions"
+                            })
+                            const exporter = new PandocExporter(
+                                doc,
+                                editor.mod.db.bibDB,
+                                editor.mod.db.imageDB,
+                                editor.app.csl,
+                                editor.docInfo.updated
+                            )
+                            exporter.progressCallback = exportProgress(doc)
+                            exporter.init()
+                        })
+                    },
+                    disabled: editor => editor.app.isOffline()
+                },
+                {
+                    title: gettext("Slim FIDUS"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Export the document to a FIDUS file without its template."
+                    ),
+                    order: 4,
+                    action: editor => {
+                        new ExportFidusFile(
+                            editor.getDoc(),
+                            editor.mod.db.bibDB,
+                            editor.mod.db.imageDB,
+                            false
+                        )
+                    }
+                }
+            ]
+        },
+        {
+            id: "settings",
+            title: gettext("Settings"),
+            tooltip: gettext("Configure settings of this document."),
+            type: "menu",
+            order: 2,
+            keys: "Alt-s",
+            content: [
+                {
+                    id: "citation_style",
+                    title: gettext("Citation Style"),
+                    type: "menu",
+                    tooltip: gettext("Choose your preferred citation style."),
+                    order: 1,
+                    disabled: editor => {
+                        return editor.docInfo.access_rights !== "write"
+                    },
+                    content: []
+                },
+                {
+                    id: "document_style",
+                    title: gettext("Document Style"),
+                    type: "menu",
+                    tooltip: gettext("Choose your preferred document style."),
+                    order: 2,
+                    disabled: editor => {
+                        return (
+                            editor.docInfo.access_rights !== "write" ||
+                            editor.app.isOffline()
+                        )
+                    },
+                    content: []
+                },
+                {
+                    id: "language",
+                    title: gettext("Text Language"),
+                    type: "menu",
+                    tooltip: gettext("Choose the language of the document."),
+                    order: 3,
+                    disabled: editor => {
+                        return editor.docInfo.access_rights !== "write"
+                    },
+                    content: [
+                        languageItem(
+                            "en-US",
+                            gettext("English (United States)"),
+                            0
+                        ),
+                        languageItem(
+                            "en-GB",
+                            gettext("English (United Kingdom)"),
+                            1
+                        ),
+                        languageItem("de-DE", gettext("German (Germany)"), 2),
+                        languageItem(
+                            "zh-CN",
+                            gettext("Chinese (Simplified)"),
+                            3
+                        ),
+                        languageItem("es", gettext("Spanish"), 4),
+                        languageItem("fr", gettext("French"), 5),
+                        languageItem("ja", gettext("Japanese"), 6),
+                        languageItem("it", gettext("Italian"), 7),
+                        //languageItem('pl', gettext('Polish'), 8),
+                        languageItem(
+                            "pt-BR",
+                            gettext("Portuguese (Brazil)"),
+                            9
+                        ),
+                        //languageItem('nl', gettext('Dutch'), 10),
+                        //languageItem('ru', gettext('Russian'), 11),
+                        {
+                            type: "separator",
+                            order: 12,
+                            available: editor => {
+                                // There has to be at least one language of the default languages
+                                // among the default ones and one that is not among the default ones.
+                                return (
+                                    !!editor.view.state.doc.attrs.languages.find(
+                                        lang =>
+                                            [
+                                                "en-US",
+                                                "en-GB",
+                                                "de-DE",
+                                                "zh-CN",
+                                                "es",
+                                                "fr",
+                                                "ja",
+                                                "it",
+                                                "pl",
+                                                "pt-BR",
+                                                "nl",
+                                                "ru"
+                                            ].includes(lang)
+                                    ) &&
+                                    !!editor.view.state.doc.attrs.languages.find(
+                                        lang =>
+                                            ![
+                                                "en-US",
+                                                "en-GB",
+                                                "de-DE",
+                                                "zh-CN",
+                                                "es",
+                                                "fr",
+                                                "ja",
+                                                "it",
+                                                "pl",
+                                                "pt-BR",
+                                                "nl",
+                                                "ru"
+                                            ].includes(lang)
+                                    )
+                                )
+                            }
+                        },
+                        {
+                            title: gettext("Other"),
+                            type: "setting",
+                            order: 13,
+                            action: editor => {
+                                const language =
+                                        editor.view.state.doc.attrs.language,
+                                    dialog = new LanguageDialog(
+                                        editor,
+                                        language
+                                    )
+                                dialog.init()
+                            },
+                            selected: editor => {
+                                return ![
+                                    "en-US",
+                                    "en-GB",
+                                    "de-DE",
+                                    "zh-CN",
+                                    "es",
+                                    "fr",
+                                    "ja",
+                                    "it",
+                                    "pl",
+                                    "pt-BR",
+                                    "nl",
+                                    "ru"
+                                ].includes(editor.view.state.doc.attrs.language)
+                            },
+                            available: editor =>
+                                !!editor.view.state.doc.attrs.languages.find(
+                                    lang =>
+                                        ![
+                                            "en-US",
+                                            "en-GB",
+                                            "de-DE",
+                                            "zh-CN",
+                                            "es",
+                                            "fr",
+                                            "ja",
+                                            "it",
+                                            "pl",
+                                            "pt-BR",
+                                            "nl",
+                                            "ru"
+                                        ].includes(lang)
+                                )
+                        }
+                    ]
+                },
+                {
+                    id: "paper_size",
+                    title: gettext("Paper Size"),
+                    type: "menu",
+                    tooltip: gettext(
+                        "Choose a papersize for print and PDF generation."
+                    ),
+                    order: 4,
+                    disabled: editor => {
+                        return editor.docInfo.access_rights !== "write"
+                    },
+                    content: [
+                        {
+                            title: gettext("DIN A4"),
+                            type: "setting",
+                            tooltip: gettext(
+                                "A4 (DIN A4/ISO 216) which is used in most of the world."
+                            ),
+                            order: 0,
+                            action: editor => {
+                                editor.view.dispatch(
+                                    editor.view.state.tr
+                                        .setDocAttribute("papersize", "A4")
+                                        .setMeta("settings", true)
+                                )
+                            },
+                            selected: editor => {
+                                return (
+                                    editor.view.state.doc.attrs.papersize ===
+                                    "A4"
+                                )
+                            },
+                            available: editor => {
+                                return editor.view.state.doc.attrs.papersizes.includes(
+                                    "A4"
+                                )
+                            }
+                        },
+                        {
+                            title: gettext("US Letter"),
+                            type: "setting",
+                            tooltip: gettext(
+                                "The format used by the USA and some other American countries."
+                            ),
+                            order: 1,
+                            action: editor => {
+                                editor.view.dispatch(
+                                    editor.view.state.tr
+                                        .setDocAttribute(
+                                            "papersize",
+                                            "US Letter"
+                                        )
+                                        .setMeta("settings", true)
+                                )
+                            },
+                            selected: editor => {
+                                return (
+                                    editor.view.state.doc.attrs.papersize ===
+                                    "US Letter"
+                                )
+                            },
+                            available: editor => {
+                                return editor.view.state.doc.attrs.papersizes.includes(
+                                    "US Letter"
+                                )
+                            }
+                        }
+                    ]
+                },
+                {
+                    title: gettext("Copyright Information"),
+                    type: "setting",
+                    order: 5,
+                    action: editor => {
+                        const dialog = new CopyrightDialog(
+                            editor.view.state.doc.attrs.copyright
+                        )
+                        dialog.init().then(copyright => {
+                            if (copyright) {
+                                editor.view.dispatch(
+                                    editor.view.state.tr
+                                        .setDocAttribute("copyright", copyright)
+                                        .setMeta("settings", true)
+                                )
+                            }
+                            editor.currentView.focus()
+                        })
+                    },
+                    disabled: editor => editor.docInfo.access_rights !== "write"
+                }
+            ]
+        },
+        {
+            id: "tools",
+            title: gettext("Tools"),
+            tooltip: gettext("Select document editing tool."),
+            type: "menu",
+            order: 3,
+            keys: "Alt-t",
+            content: [
+                {
+                    title: gettext("Word counter"),
+                    type: "action",
+                    tooltip: gettext("See document statistics."),
+                    order: 0,
+                    action: editor => {
+                        const dialog = new WordCountDialog(editor)
+                        dialog.init()
+                    }
+                },
+                {
+                    title: gettext("Search and replace"),
+                    type: "action",
+                    tooltip: gettext("Show a search and replace dialog."),
+                    order: 1,
+                    keys: "Ctrl-h",
+                    action: editor => {
+                        const dialog = new SearchReplaceDialog(editor)
+                        dialog.init()
+                    }
+                },
+                {
+                    title: gettext("Keyboard shortcuts"),
+                    type: "action",
+                    tooltip: gettext(
+                        "Show an overview of available keyboard shortcuts."
+                    ),
+                    order: 2,
+                    keys: "Shift-Ctrl-/",
+                    action: editor => {
+                        const dialog = new KeyBindingsDialog(editor)
+                        dialog.init()
+                    }
+                }
+            ]
+        },
+        {
+            title: gettext("Track changes"),
+            type: "menu",
+            tooltip: gettext("Tracking changes to the document"),
+            order: 4,
+            keys: "Alt-c",
+            disabled: editor => editor.docInfo.access_rights !== "write",
+            content: [
+                {
+                    title: gettext("Record"),
+                    type: "setting",
+                    tooltip: gettext("Record document changes"),
+                    order: 0,
+                    disabled: editor => {
+                        return editor.docInfo.access_rights !== "write"
+                    },
+                    action: editor => {
+                        const tracked = !editor.view.state.doc.attrs.tracked
+                        editor.view.dispatch(
+                            editor.view.state.tr
+                                .setDocAttribute("tracked", tracked)
+                                .setMeta("settings", true)
+                        )
+                    },
+                    selected: editor => {
+                        return editor.view.state.doc.attrs.tracked === true
+                    }
+                },
+                {
+                    title: gettext("Accept all"),
+                    type: "action",
+                    tooltip: gettext("Accept all tracked changes."),
+                    order: 1,
+                    action: editor => {
+                        editor.mod.track.acceptAll()
+                    }
+                },
+                {
+                    title: gettext("Reject all"),
+                    type: "action",
+                    tooltip: gettext("Reject all tracked changes."),
+                    order: 2,
+                    action: editor => {
+                        editor.mod.track.rejectAll()
+                    }
+                }
+            ]
+        }
+    ]
+})