@fiduswriter/editor 0.1.0

package/src/no_collab_save/index.js

@@ -0,0 +1,209 @@
+import {addAlert, postJson} from "fwtoolkit"
+import {receiveTransaction} from "prosemirror-collab"
+import {Transform} from "prosemirror-transform"
+import {recreateTransform} from "../collab/merge/recreate_transform"
+
+/**
+ * Handles periodic saving and conflict resolution for the editor
+ when EDITOR_SAVE_MODE is "direct" (no WebSocket).
+ */
+export class NoCollabSave {
+    constructor(editor) {
+        this.editor = editor
+        this.saveInterval = null
+        this.savePromise = null
+        this._beforeUnloadHandler = null
+        this._lastSaveTime = 0
+    }
+
+    start() {
+        if (this.saveInterval) {
+            return
+        }
+        // Save every 10 seconds when the document is loaded and writable.
+        this.saveInterval = window.setInterval(() => {
+            if (
+                !this.editor.waitingForDocument &&
+                !this.savePromise &&
+                this.editor.docInfo.access_rights === "write" &&
+                this._hasUnsavedChanges()
+            ) {
+                this.save()
+            }
+        }, 10000)
+
+        // For non-E2EE documents, try to save on tab close / page hide.
+        // E2EE encryption is async and cannot run reliably in unload handlers.
+        if (!this.editor.e2ee?.encrypted) {
+            this._beforeUnloadHandler = () => {
+                if (
+                    this.editor.docInfo.access_rights === "write" &&
+                    this._hasUnsavedChanges()
+                ) {
+                    this._save(true)
+                }
+            }
+            window.addEventListener("beforeunload", this._beforeUnloadHandler)
+            window.addEventListener("pagehide", this._beforeUnloadHandler)
+        }
+    }
+
+    stop() {
+        if (this.saveInterval) {
+            window.clearInterval(this.saveInterval)
+            this.saveInterval = null
+        }
+        if (this._beforeUnloadHandler) {
+            window.removeEventListener(
+                "beforeunload",
+                this._beforeUnloadHandler
+            )
+            window.removeEventListener("pagehide", this._beforeUnloadHandler)
+            this._beforeUnloadHandler = null
+        }
+    }
+
+    async save() {
+        if (this.savePromise) {
+            return this.savePromise
+        }
+        this.savePromise = this._save()
+        try {
+            await this.savePromise
+        } finally {
+            this.savePromise = null
+        }
+    }
+
+    _hasUnsavedChanges() {
+        return this.editor.docInfo.updated.getTime() > this._lastSaveTime
+    }
+
+    async _save(keepalive = false) {
+        if (this.editor.docInfo.access_rights !== "write") {
+            return
+        }
+        const doc = this.editor.getDoc({use_current_view: true})
+        let payload = {
+            id: this.editor.docInfo.id,
+            content: doc.content,
+            comments: this.editor.mod.comments.store.comments,
+            bibliography: this.editor.mod.db.bibDB.db,
+            title: doc.title,
+            version: this.editor.docInfo.version,
+            image_updates: this.editor.mod.db.imageDB.unsentEvents()
+        }
+
+        if (
+            this.editor.e2ee &&
+            this.editor.e2ee.encrypted &&
+            this.editor.e2ee.snapshotManager
+        ) {
+            const snapshot =
+                await this.editor.e2ee.snapshotManager.getEncryptedSnapshot()
+            if (snapshot) {
+                payload = {
+                    id: this.editor.docInfo.id,
+                    content: snapshot.content,
+                    comments: snapshot.comments,
+                    bibliography: snapshot.bibliography,
+                    title: snapshot.title,
+                    version: snapshot.v,
+                    e2ee_salt: snapshot.e2ee_salt,
+                    e2ee_iterations: snapshot.e2ee_iterations,
+                    e2ee_snapshot_version: snapshot.v
+                }
+            }
+        }
+
+        try {
+            const {json, status} = await postJson(
+                "/api/document/save/",
+                payload,
+                {},
+                {keepalive}
+            )
+            if (status === 409) {
+                if (!keepalive) {
+                    await this._handleVersionConflict()
+                }
+                return
+            }
+            if (json.version !== undefined) {
+                this.editor.docInfo.version = json.version
+            }
+            this.editor.docInfo.updated = new Date()
+            this.editor.docInfo.confirmedDoc = this.editor.view.state.doc
+            this._lastSaveTime = Date.now()
+            // Clear unsent event queues since the full state has been saved.
+            this.editor.mod.db.bibDB.unsent = []
+            this.editor.mod.db.imageDB.unsent = []
+            this.editor.mod.comments.store.unsent = []
+        } catch (error) {
+            if (!keepalive) {
+                console.error("Failed to save document:", error)
+                addAlert("error", gettext("Could not save document."))
+            }
+        }
+    }
+
+    async _handleVersionConflict() {
+        if (this.editor.docInfo.access_rights !== "write") {
+            return
+        }
+        const payload = {id: this.editor.docInfo.id}
+        if (this.editor.docInfo.token) {
+            payload.token = this.editor.docInfo.token
+        }
+        try {
+            const {json} = await postJson(
+                "/api/document/get_doc_data/",
+                payload
+            )
+            const serverDoc = this.editor.schema.nodeFromJSON(json.doc.content)
+            const currentDoc = this.editor.view.state.doc
+            const confirmedDoc = this.editor.docInfo.confirmedDoc
+
+            const remoteTr = recreateTransform(confirmedDoc, serverDoc)
+            const localTr = recreateTransform(confirmedDoc, currentDoc)
+
+            const mappedSteps = []
+            remoteTr.steps.forEach(step => {
+                const mapped = step.map(localTr.mapping)
+                if (mapped) {
+                    mappedSteps.push(mapped)
+                }
+            })
+
+            if (mappedSteps.length) {
+                this.editor.view.dispatch(
+                    receiveTransaction(
+                        this.editor.view.state,
+                        mappedSteps,
+                        mappedSteps.map(() => "remote")
+                    ).setMeta("remote", true)
+                )
+            }
+
+            // Update metadata from server
+            this.editor.mod.db.bibDB.setDB(json.doc.bibliography)
+            this.editor.mod.db.imageDB.setDB(json.doc.images)
+            this.editor.mod.comments.store.loadComments(json.doc.comments)
+            this.editor.docInfo.version = json.doc.v
+            this.editor.docInfo.confirmedDoc = this.editor.view.state.doc
+            this.editor.docInfo.updated = new Date(json.time)
+            this.editor.mod.footnotes.fnEditor.renderAllFootnotes()
+
+            // Retry save with the merged document
+            await this.save()
+        } catch (error) {
+            console.error("Failed to handle version conflict:", error)
+            addAlert(
+                "error",
+                gettext(
+                    "Document has been modified by another user. Please reload the page."
+                )
+            )
+        }
+    }
+}

package/src/plugins/citation_dialog/index.js

@@ -0,0 +1 @@
+export const plugins = []

package/src/plugins/editor/index.js

@@ -0,0 +1 @@
+export const plugins = []

package/src/state_plugins/access_rights.js

@@ -0,0 +1,47 @@
+import {Plugin, PluginKey} from "prosemirror-state"
+import {COMMENT_ONLY_ROLES, READ_ONLY_ROLES} from ".."
+
+const key = new PluginKey("accessRights")
+
+export const accessRightsPlugin = options =>
+    new Plugin({
+        key,
+        filterTransaction: (tr, _state) => {
+            let allowed = true
+            const remote = tr.getMeta("remote")
+            if (remote) {
+                return allowed
+            }
+
+            if (
+                READ_ONLY_ROLES.includes(
+                    options.editor.docInfo.access_rights
+                ) &&
+                tr.docChanged
+            ) {
+                // User only has read access. Don't allow anything.
+                allowed = false
+            } else if (
+                COMMENT_ONLY_ROLES.includes(
+                    options.editor.docInfo.access_rights
+                )
+            ) {
+                //User has a comment-only role (commentator, editor or reviewer)
+
+                //Check all transaction steps. If step type not allowed = prohibit
+                //check if in allowed array. if false - exit loop
+                if (
+                    !tr.steps.every(
+                        step =>
+                            (step.jsonID === "addMark" ||
+                                step.jsonID === "removeMark") &&
+                            step.mark.type.name === "comment"
+                    )
+                ) {
+                    allowed = false
+                }
+            }
+
+            return allowed
+        }
+    })

package/src/state_plugins/citation_render.js

@@ -0,0 +1,88 @@
+import {Plugin, PluginKey} from "prosemirror-state"
+import {ReplaceAroundStep, ReplaceStep} from "prosemirror-transform"
+
+const key = new PluginKey("citationRender")
+
+export const citationRenderPlugin = options =>
+    new Plugin({
+        key,
+        state: {
+            init() {
+                return {action: false}
+            },
+            apply(tr, _prev, oldState, _state) {
+                const meta = tr.getMeta(key)
+                if (meta) {
+                    // There has been an update, return values from meta instead
+                    // of previous values
+                    return meta
+                }
+                let {action} = this.getState(oldState)
+
+                if (action || tr.getMeta("settings")) {
+                    return {action} // We already need to reset the bibliography or another setting is used. Don't bother checking for more reasons to do so.
+                }
+                tr.steps.forEach((step, index) => {
+                    if (
+                        step instanceof ReplaceStep ||
+                        step instanceof ReplaceAroundStep
+                    ) {
+                        if (step.from !== step.to) {
+                            tr.docs[index].nodesBetween(
+                                step.from,
+                                step.to,
+                                node => {
+                                    if (node.type.name === "citation") {
+                                        // A citation was replaced. We need to reset
+                                        action = "reset"
+                                    } else if (
+                                        !action &&
+                                        node.type.name === "footnote"
+                                    ) {
+                                        action = "numbers"
+                                    }
+                                }
+                            )
+                        }
+                        if (step.slice?.content) {
+                            step.slice.content.descendants(node => {
+                                if (node.type.name === "citation") {
+                                    // A citation was added. We need to reset
+                                    action = "reset"
+                                } else if (
+                                    !action &&
+                                    node.type.name === "footnote"
+                                ) {
+                                    action = "numbers"
+                                }
+                            })
+                        }
+                    }
+                })
+
+                return {action}
+            }
+        },
+        view(_view) {
+            options.editor.mod.citations.resetCitations()
+            return {
+                update: (view, _prevState) => {
+                    const {action} = key.getState(view.state)
+                    if (action === "reset") {
+                        options.editor.mod.citations.resetCitations()
+                        const tr = view.state.tr.setMeta(key, {action: false})
+                        view.dispatch(tr)
+                    } else if (action === "numbers") {
+                        options.editor.mod.citations.footnoteNumberOverride()
+                        const tr = view.state.tr.setMeta(key, {action: false})
+                        view.dispatch(tr)
+                    } else if (view.dom.querySelector(".citation:empty")) {
+                        options.editor.mod.citations.resetCitations()
+                    }
+                },
+                destroy: () => {
+                    options.editor.mod.citations.resetCitations()
+                }
+            }
+        }
+    })

package/src/state_plugins/clipboard.js

@@ -0,0 +1,289 @@
+import fixUTF8 from "fix-utf8"
+
+import {Fragment, Slice} from "prosemirror-model"
+import {Plugin, PluginKey, TextSelection} from "prosemirror-state"
+import {ReplaceStep} from "prosemirror-transform"
+
+import {docClipboardSerializer, fnClipboardSerializer} from "../clipboard/copy"
+import {HTMLPaste, TextPaste} from "../clipboard/paste"
+import {getAllowedElementsAndMarks} from "./document_template"
+
+const key = new PluginKey("clipboard")
+
+export const getPasteRange = state => {
+    const {pasteRange} = key.getState(state)
+    return pasteRange
+}
+
+export const resetPasteRange = tr => {
+    tr.setMeta(key, {pasteRange: null})
+}
+
+// Filter a fragment to only include allowed nodes and marks
+// parentNode is optional - used to check if converted nodes are valid children
+const filterFragment = (
+    fragment,
+    allowedElements,
+    allowedMarks,
+    schema,
+    parentNode = null
+) => {
+    const nodes = []
+
+    fragment.forEach(node => {
+        // Check if this node type is allowed
+        const nodeTypeAllowed =
+            !allowedElements || allowedElements.includes(node.type.name)
+
+        if (!nodeTypeAllowed) {
+            // Try to convert to paragraph if allowed
+            if (
+                allowedElements &&
+                allowedElements.includes("paragraph") &&
+                node.isBlock
+            ) {
+                const paragraph = schema.nodes.paragraph
+                if (paragraph) {
+                    // Check if paragraph can be a child of the parent node
+                    const canUseParagraph =
+                        !parentNode ||
+                        parentNode.type.contentMatch.matchType(paragraph)
+
+                    if (canUseParagraph) {
+                        // Convert the node to a paragraph, recursively filtering its content
+                        const filteredContent =
+                            node.content.size > 0
+                                ? filterFragment(
+                                      node.content,
+                                      allowedElements,
+                                      allowedMarks,
+                                      schema,
+                                      node
+                                  )
+                                : Fragment.empty
+                        nodes.push(paragraph.create(null, filteredContent))
+                    } else if (parentNode && parentNode.isTextblock) {
+                        // Parent is a text block but doesn't allow paragraphs
+                        // Extract text content and add as plain text
+                        const textContent = node.textContent
+                        if (textContent) {
+                            nodes.push(schema.text(textContent))
+                        }
+                    } else {
+                        // Can't convert to paragraph, extract and process children
+                        const filteredContent = filterFragment(
+                            node.content,
+                            allowedElements,
+                            allowedMarks,
+                            schema,
+                            parentNode
+                        )
+                        filteredContent.forEach(child => nodes.push(child))
+                    }
+                }
+            } else if (node.isBlock) {
+                // Extract content from disallowed block nodes
+                const filteredContent = filterFragment(
+                    node.content,
+                    allowedElements,
+                    allowedMarks,
+                    schema,
+                    parentNode
+                )
+                filteredContent.forEach(child => nodes.push(child))
+            } else {
+                // For inline nodes, just skip them
+            }
+            return
+        }
+
+        // Node type is allowed, but filter marks
+        let filteredNode = node
+        if (allowedMarks !== false && node.marks.length > 0) {
+            const filteredMarks = node.marks.filter(mark =>
+                allowedMarks.includes(mark.type.name)
+            )
+            if (filteredMarks.length !== node.marks.length) {
+                filteredNode = node.mark(filteredMarks)
+            }
+        }
+
+        // Recursively filter content
+        if (filteredNode.content.size > 0) {
+            const filteredContent = filterFragment(
+                filteredNode.content,
+                allowedElements,
+                allowedMarks,
+                schema,
+                filteredNode
+            )
+            filteredNode = filteredNode.copy(filteredContent)
+        }
+
+        nodes.push(filteredNode)
+    })
+
+    return Fragment.from(nodes)
+}
+
+export const clipboardPlugin = options => {
+    let shiftPressed = false
+    return new Plugin({
+        key,
+        state: {
+            init() {
+                return {
+                    pasteRange: null
+                }
+            },
+            apply(tr, _prev, oldState, _state) {
+                const meta = tr.getMeta(key)
+                if (meta) {
+                    // There has been an update, return values from meta instead
+                    // of previous values
+                    return meta
+                }
+                const uiEventMeta = tr.getMeta("uiEvent")
+                let pasteRange
+                if (uiEventMeta && ["paste", "drop"].includes(uiEventMeta)) {
+                    pasteRange = [
+                        oldState.selection.from,
+                        oldState.selection.to
+                    ]
+                    tr.steps.forEach(step => {
+                        if (step instanceof ReplaceStep) {
+                            // paste and drop TRs will usually just consist of a single ReplaceStep
+                            pasteRange = [step.from, step.to]
+                        }
+                        const stepMap = step.getMap()
+                        pasteRange = [
+                            stepMap.map(pasteRange[0], -1),
+                            stepMap.map(pasteRange[1], 1)
+                        ] // map through step
+                    })
+                } else {
+                    pasteRange = this.getState(oldState)?.pasteRange
+                    if (pasteRange && tr.docChanged) {
+                        const from = tr.mapping.mapResult(pasteRange[0], -1)
+                        const to = tr.mapping.mapResult(pasteRange[1], 1)
+                        if (from.deleted || to.deleted) {
+                            pasteRange = null
+                        } else {
+                            pasteRange = [from.pos, to.pos]
+                        }
+                    }
+                }
+
+                return {
+                    pasteRange
+                }
+            }
+        },
+        props: {
+            handleKeyDown: (_view, event) => {
+                shiftPressed = event.shiftKey
+                return false
+            },
+            handleDrop: (view, event, slice, moved) => {
+                shiftPressed = event.shiftKey
+                if (moved || (slice && slice.size)) {
+                    return false // Something other than en empty plain text string from outside. Handled by PM already.
+                }
+                const eventPos = view.posAtCoords({
+                    left: event.clientX,
+                    top: event.clientY
+                })
+                if (!eventPos) {
+                    return false
+                }
+                const $mouse = view.state.doc.resolve(eventPos.pos)
+                if (!$mouse) {
+                    return false
+                }
+                const tr = view.state.tr
+                tr.setSelection(new TextSelection($mouse))
+                view.dispatch(tr)
+                return true
+            },
+            transformPastedHTML: (inHTML, view) => {
+                const {pasteRange} = key.getState(view.state)
+
+                if (pasteRange) {
+                    // a previous paste operation has been interrupted by a new one. Cancel.
+                    return ""
+                }
+                if (shiftPressed) {
+                    return inHTML
+                }
+                const ph = new HTMLPaste(
+                    options.editor,
+                    inHTML,
+                    options.viewType,
+                    view
+                )
+                return ph.getOutput()
+            },
+            transformPastedText: (inText, _plain, view) => {
+                const {pasteRange} = key.getState(view.state)
+
+                if (pasteRange) {
+                    // a previous paste operation has been interrupted by a new one. Cancel.
+                    return ""
+                }
+                if (shiftPressed) {
+                    return inText
+                }
+                // Chrome on Linux has an encoding problem:
+                // it recognizes UTF as Windows 1252. Bug has been filed. This is a temp
+                // solution for western European languages.
+                // https://bugs.chromium.org/p/chromium/issues/detail?id=760613
+                const fixedText = fixUTF8(inText)
+                const ph = new TextPaste(
+                    options.editor,
+                    fixedText,
+                    options.editor.currentView
+                )
+                ph.init()
+                return fixedText // We need to analyze it asynchronously, so we always need to turn this into an empty string for now.
+            },
+            clipboardSerializer:
+                options.viewType === "main"
+                    ? docClipboardSerializer(options.editor)
+                    : fnClipboardSerializer(options.editor),
+            transformPasted: (slice, view, plain) => {
+                // Only filter if not plain text paste
+                if (plain) {
+                    return slice
+                }
+
+                // Get allowed elements and marks at the current selection position
+                const {elements, marks} = getAllowedElementsAndMarks(view.state)
+
+                // If no restrictions, return slice unchanged
+                if (elements === false && marks === false) {
+                    return slice
+                }
+
+                // Get the parent node at the selection position to check compatibility
+                const $pos = view.state.selection.$from
+                const parentNode = $pos.parent
+
+                // Filter the slice content
+                const filteredContent = filterFragment(
+                    slice.content,
+                    elements,
+                    marks,
+                    view.state.schema,
+                    parentNode
+                )
+
+                // Return new slice with filtered content
+                return new Slice(
+                    filteredContent,
+                    slice.openStart,
+                    slice.openEnd
+                )
+            }
+        }
+    })
+}