@fiduswriter/editor 0.1.20 → 0.1.21

package/src/state_plugins/marginboxes.js

@@ -1,14 +0,0 @@
-import {Plugin, PluginKey} from "prosemirror-state"
-
-const key = new PluginKey("marginboxes")
-export const marginboxesPlugin = options =>
-    new Plugin({
-        key,
-        view(_editorState) {
-            return {
-                update: (view, _prevState) => {
-                    options.editor.mod.marginboxes.view(view)
-                }
-            }
-        }
-    })

package/src/state_plugins/placeholders.js

@@ -1,123 +0,0 @@
-import {Plugin, PluginKey} from "prosemirror-state"
-import {Decoration, DecorationSet} from "prosemirror-view"
-
-const key = new PluginKey("placeholders")
-export const placeholdersPlugin = options => {
-    function calculatePlaceHolderDecorations(state) {
-        const anchor = state.selection.$anchor
-        const head = state.selection.$head
-        if (!anchor || !head) {
-            return
-        }
-        const anchorPart = anchor.node(1)
-        const headPart = head.node(1)
-        if (!anchorPart || !headPart) {
-            return
-        }
-        const currentPart = anchorPart === headPart ? anchorPart : false
-
-        const decorations = []
-
-        state.doc.forEach((partElement, offset) => {
-            if (
-                (partElement.isTextblock && partElement.childCount === 0) ||
-                (!partElement.isTextblock && partElement.nodeSize === 4)
-            ) {
-                if (
-                    [
-                        state.schema.nodes["tags_part"],
-                        state.schema.nodes["contributors_part"]
-                    ].includes(partElement.type) &&
-                    options.editor.docInfo.access_rights === "write"
-                ) {
-                    // We don't need to render placeholders for these kinds
-                    // of nodes in write mode as their nodeviews will take
-                    // care of that.
-                    return
-                }
-
-                const text =
-                    partElement.type === state.schema.nodes["title"]
-                        ? `${gettext("Title")}...`
-                        : `${partElement.attrs.title}...`
-                const placeHolder = document.createElement("span")
-                placeHolder.classList.add("fw-placeholder")
-                placeHolder.setAttribute("data-placeholder", text)
-                if (currentPart === partElement) {
-                    placeHolder.classList.add("fw-selected")
-                }
-                let position = 1 + offset
-                // position of decorator: 2 to get inside (doc (1))
-                if (!partElement.isTextblock) {
-                    // In block nodes that are not text blocks (body + abstract)
-                    // place inside the first child node (a paragraph).
-                    position += 1
-                }
-                decorations.push(
-                    Decoration.widget(position, placeHolder, {
-                        side: 1
-                    })
-                )
-            } else if (
-                ["richtext_part", "table_part"].includes(partElement.type.name)
-            ) {
-                partElement.descendants((node, pos) => {
-                    if (
-                        ["figure", "table"].includes(node.type.name) &&
-                        !node.attrs.caption
-                    ) {
-                        return false
-                    }
-                    if (
-                        ["figure_caption", "table_caption"].includes(
-                            node.type.name
-                        ) &&
-                        node.childCount === 0 &&
-                        state.selection.$anchor.parent !== node
-                    ) {
-                        decorations.push(
-                            Decoration.node(
-                                1 + offset + pos,
-                                1 + offset + pos + node.nodeSize,
-                                {
-                                    class: "empty",
-                                    "data-placeholder": `${gettext("Caption")}...`
-                                }
-                            )
-                        )
-                    }
-                })
-            }
-        })
-
-        return decorations.length
-            ? DecorationSet.create(state.doc, decorations)
-            : false
-    }
-
-    return new Plugin({
-        key,
-        state: {
-            init(_config, state) {
-                return {
-                    decos: calculatePlaceHolderDecorations(state)
-                }
-            },
-            apply(tr, _prev, oldState, state) {
-                let {decos} = this.getState(oldState)
-                if (tr.docChanged || tr.selectionSet) {
-                    decos = calculatePlaceHolderDecorations(state)
-                }
-                return {
-                    decos
-                }
-            }
-        },
-        props: {
-            decorations(state) {
-                const {decos} = this.getState(state)
-                return decos
-            }
-        }
-    })
-}

package/src/state_plugins/table.js

@@ -1,127 +0,0 @@
-import {ContentMenu} from "fwtoolkit"
-import {Plugin, PluginKey, Selection} from "prosemirror-state"
-import {WRITE_ROLES} from "..//index.js"
-
-const key = new PluginKey("table")
-
-class TableView {
-    constructor(node, view, getPos, options) {
-        this.node = node
-        this.view = view
-        this.getPos = getPos
-        this.options = options
-        this.dom = document.createElement("div")
-        this.dom.classList.add(
-            `table-${node.attrs.width}`,
-            `table-${node.attrs.aligned}`,
-            "content-container"
-        )
-        this.dom.id = node.attrs.id
-        this.menuButton = document.createElement("button")
-        this.menuButton.classList.add("fw-content-menu-btn")
-        this.menuButton.innerHTML =
-            '<span class="dot-menu-icon"><i class="fa-solid fa-ellipsis-v"></i></span>'
-        this.dom.appendChild(this.menuButton)
-        const dom = document.createElement("table")
-        if (node.attrs.track.length) {
-            dom.dataset.track = JSON.stringify(node.attrs.track)
-        }
-        dom.id = node.attrs.id
-        dom.dataset.width = node.attrs.width
-        dom.dataset.aligned = node.attrs.aligned
-        dom.dataset.layout = node.attrs.layout
-        dom.class = `table-${node.attrs.width} table-${node.attrs.aligned} table-${node.attrs.layout}`
-        dom.dataset.category = node.attrs.category
-        if (!node.attrs.caption) {
-            dom.dataset.captionHidden = true
-        }
-        this.contentDOM = dom
-        this.dom.appendChild(this.contentDOM)
-    }
-
-    stopEvent(event) {
-        let stopped = false
-        if (
-            event.type === "mousedown" &&
-            event.composedPath().includes(this.menuButton)
-        ) {
-            stopped = true
-            if (!isSelectedTableClicked(this.view.state, this.getPos())) {
-                const tr = this.view.state.tr
-                const $pos = this.view.state.doc.resolve(this.getPos())
-                tr.setSelection(Selection.findFrom($pos, 1, true))
-                this.view.dispatch(tr)
-            }
-            const contentMenu = new ContentMenu({
-                menu: this.options.editor.menu.tableMenuModel,
-                width: 280,
-                page: this.options.editor,
-                menuPos: {
-                    X: Number.parseInt(event.pageX) + 20,
-                    Y: Number.parseInt(event.pageY) - 100
-                },
-                onClose: () => {
-                    this.view.focus()
-                }
-            })
-            contentMenu.open()
-        }
-        return stopped
-    }
-}
-
-class TableCaptionView {
-    constructor(node, view, getPos, options) {
-        this.node = node
-        this.view = view
-        this.getPos = getPos
-        this.options = options
-
-        this.dom = document.createElement("caption")
-        this.dom.innerHTML = '<span class="text"></span>'
-        this.contentDOM = this.dom.lastElementChild
-    }
-}
-
-const isSelectedTableClicked = (state, $pos) => {
-    const pathArr = state.selection.$head.path
-    for (let i = 0; i < pathArr.length; i++) {
-        if (
-            pathArr[i].type &&
-            pathArr[i].type.name &&
-            pathArr[i].type.name === "table" &&
-            pathArr[i - 1] === $pos
-        ) {
-            return true
-        }
-    }
-    return false
-}
-
-export const tablePlugin = options =>
-    new Plugin({
-        key,
-        state: {
-            init(_config, _state) {
-                if (
-                    WRITE_ROLES.includes(options.editor.docInfo.access_rights)
-                ) {
-                    this.spec.props.nodeViews["table"] = (node, view, getPos) =>
-                        new TableView(node, view, getPos, options)
-                }
-                this.spec.props.nodeViews["table_caption"] = (
-                    node,
-                    view,
-                    getPos
-                ) => new TableCaptionView(node, view, getPos, options)
-
-                return {}
-            },
-            apply(_tr, prev) {
-                return prev
-            }
-        },
-        props: {
-            nodeViews: {}
-        }
-    })

package/src/state_plugins/tag_input/plugin.js

@@ -1,278 +0,0 @@
-import {GapCursor} from "prosemirror-gapcursor"
-import {
-    NodeSelection,
-    Plugin,
-    PluginKey,
-    TextSelection
-} from "prosemirror-state"
-
-import {nextSelection, submitTag, tagInputReferences} from "@fiduswriter/common/state_plugins/tag_input"
-
-import {TagsPartView} from "./node_view.js"
-
-const key = new PluginKey("tagInput")
-
-// Track mouse click state across transactions using closure variable
-let mouseClickActive = false
-let mouseClickTimer = null
-// Track when we've explicitly blurred the tag input to prevent refocus
-let tagInputJustBlurred = false
-
-// Export function to check if we should prevent tag input focus
-export const shouldPreventTagInputFocus = () => tagInputJustBlurred
-
-export const tagInputPlugin = options =>
-    new Plugin({
-        key,
-        state: {
-            init(_config, state) {
-                if (options.editor.docInfo.access_rights === "write") {
-                    this.spec.props.nodeViews["tags_part"] = (
-                        node,
-                        view,
-                        getPos
-                    ) => new TagsPartView(node, view, getPos)
-                }
-
-                // Find all tags_part nodes in the document
-                const tagsPartPositions = []
-                state.doc.descendants((node, pos) => {
-                    if (node.type.name === "tags_part") {
-                        tagsPartPositions.push({
-                            start: pos,
-                            end: pos + node.nodeSize
-                        })
-                    }
-                })
-
-                return {tagsPartPositions}
-            },
-            apply(tr, prev) {
-                // If the document was modified, update all positions
-                if (tr.docChanged) {
-                    const newPositions = prev.tagsPartPositions.map(range => ({
-                        start: tr.mapping.map(range.start),
-                        end: tr.mapping.map(range.end)
-                    }))
-
-                    return {tagsPartPositions: newPositions}
-                }
-                return prev
-            }
-        },
-        props: {
-            nodeViews: {},
-            handleDOMEvents: {
-                mousedown(view, event) {
-                    // Mark that this selection change came from a mouse click
-                    // Set the closure variable to indicate a mouse click is happening
-                    mouseClickActive = true
-
-                    // Clear any existing timer
-                    if (mouseClickTimer) {
-                        clearTimeout(mouseClickTimer)
-                    }
-
-                    // Reset after a delay to allow all related transactions to process
-                    // Including blur handlers and any delayed events
-                    mouseClickTimer = setTimeout(() => {
-                        mouseClickActive = false
-                        mouseClickTimer = null
-                    }, 100)
-
-                    // Check if we're clicking outside a focused tag input
-                    const activeElement = document.activeElement
-                    // Check if active element is inside a tag-input container
-                    const tagInputContainer =
-                        activeElement?.closest(".tag-input")
-                    const clickedInsideTagInput =
-                        event.target.closest(".tag-input")
-                    // Check if clicking on a tag within the tags_part (but not the tag input)
-                    const clickedOnTag =
-                        event.target.closest(".tag") ||
-                        event.target.closest(".doc-tags_part")
-
-                    // If a tag input has focus and we're clicking outside it (including on existing tags), submit and blur it
-                    if (
-                        tagInputContainer &&
-                        (!clickedInsideTagInput || clickedOnTag)
-                    ) {
-                        // Get the stored references from WeakMap
-                        const refs = tagInputReferences.get(tagInputContainer)
-                        if (refs) {
-                            const {tagInputView, mainView, getPos} = refs
-
-                            // Submit the tag immediately with the valid position
-                            submitTag(tagInputView, mainView, getPos)
-
-                            // If we clicked outside the tags_part entirely, set selection to clicked position
-                            // If we clicked on a tag, let the normal click handling select it
-                            if (!clickedOnTag) {
-                                // Now set the selection based on where the user clicked
-                                // We need to do this synchronously before appendTransaction runs
-                                const clickPos = view.posAtCoords({
-                                    left: event.clientX,
-                                    top: event.clientY
-                                })
-                                if (clickPos) {
-                                    const tr = view.state.tr.setSelection(
-                                        TextSelection.create(
-                                            view.state.doc,
-                                            clickPos.pos
-                                        )
-                                    )
-                                    view.dispatch(tr)
-                                    view.focus()
-                                }
-                            } else {
-                                // Blur the tag input first, then focus the main view
-
-                                // Set flag to prevent tag input from being refocused
-                                tagInputJustBlurred = true
-
-                                // Blur the tag input
-                                tagInputView.dom.blur()
-
-                                // Find the position of the clicked tag and select it
-                                const clickPos = view.posAtCoords({
-                                    left: event.clientX,
-                                    top: event.clientY
-                                })
-                                if (clickPos) {
-                                    // Try to create a NodeSelection on the tag
-                                    try {
-                                        const node = view.state.doc.nodeAt(
-                                            clickPos.pos
-                                        )
-                                        if (node && node.type.name === "tag") {
-                                            const tr =
-                                                view.state.tr.setSelection(
-                                                    NodeSelection.create(
-                                                        view.state.doc,
-                                                        clickPos.pos
-                                                    )
-                                                )
-                                            view.dispatch(tr)
-                                        } else {
-                                            // If not directly on a tag, try the position before
-                                            const nodeBefore =
-                                                view.state.doc.nodeAt(
-                                                    clickPos.pos - 1
-                                                )
-                                            if (
-                                                nodeBefore &&
-                                                nodeBefore.type.name === "tag"
-                                            ) {
-                                                const tr =
-                                                    view.state.tr.setSelection(
-                                                        NodeSelection.create(
-                                                            view.state.doc,
-                                                            clickPos.pos - 1
-                                                        )
-                                                    )
-                                                view.dispatch(tr)
-                                            }
-                                        }
-                                    } catch {
-                                        // Silently ignore selection errors
-                                    }
-                                }
-
-                                view.focus()
-
-                                // Reset the flag after a short delay
-                                setTimeout(() => {
-                                    tagInputJustBlurred = false
-                                }, 150)
-                            }
-                        }
-                    }
-
-                    return false
-                }
-            }
-        },
-        appendTransaction: (trs, oldState, newState) => {
-            // If selection is not collapsed or not changed, don't do anything
-            if (
-                newState.selection.from !== newState.selection.to ||
-                !trs.some(tr => tr.selectionSet)
-            ) {
-                return
-            }
-
-            const selectionPos = newState.selection.from
-            const pluginState = key.getState(newState)
-
-            // If this selection change came from a mouse click, don't interfere
-            if (mouseClickActive) {
-                return
-            }
-
-            // If selection is already a NodeSelection on a tag, don't interfere
-            if (newState.selection instanceof NodeSelection) {
-                const selectedNode = newState.selection.node
-                if (selectedNode && selectedNode.type.name === "tag") {
-                    return
-                }
-            }
-
-            // Check if selection is within any tags_part node
-            const tagsPartRange = pluginState.tagsPartPositions.find(
-                range => selectionPos > range.start && selectionPos < range.end
-            )
-
-            if (tagsPartRange) {
-                const oldSelectionPos = oldState.selection.from
-
-                if (selectionPos + 1 === tagsPartRange.end) {
-                    // Selection is at end of tags_part.
-                    // Put caret into tag editor if write access is present.
-                    // Otherwise, move caret beyond tags_part.
-                    if (options.editor.docInfo.access_rights === "write") {
-                        // tag editor will be activated by node view.
-                        return
-                    }
-                    if (oldSelectionPos < selectionPos) {
-                        const newSelection = nextSelection(
-                            newState,
-                            tagsPartRange.end,
-                            1
-                        )
-                        if (!newSelection) {
-                            // Cannot find a location. Give up.
-                            return
-                        }
-
-                        return newState.tr.setSelection(newSelection)
-                    }
-                }
-
-                const selectedNodePos =
-                    oldSelectionPos < selectionPos
-                        ? selectionPos
-                        : selectionPos - 1
-
-                if (selectedNodePos === tagsPartRange.start) {
-                    // selection is at start of tags node. Find previous possible selection location.
-                    const newSelection = nextSelection(
-                        newState,
-                        selectedNodePos,
-                        -1
-                    )
-                    if (!newSelection) {
-                        // Cannot find a location. Give up.
-                        return
-                    }
-                    return newState.tr.setSelection(newSelection)
-                } else {
-                    // Select an entire tag node
-                    return newState.tr.setSelection(
-                        NodeSelection.create(newState.doc, selectedNodePos)
-                    )
-                }
-            }
-
-            return null
-        }
-    })