@fiduswriter/editor 0.1.20 → 0.1.22

package/src/state_plugins/footnote_markers.js

@@ -1,238 +0,0 @@
-import {Plugin, PluginKey} from "prosemirror-state"
-
-const key = new PluginKey("footnoteMarkers")
-
-export const findFootnoteMarkers = (fromPos, toPos, doc) => {
-    const footnoteMarkers = []
-    doc.nodesBetween(fromPos, toPos, (node, pos) => {
-        if (!node.isInline) {
-            return
-        }
-        if (node.type.name === "footnote") {
-            const from = pos
-            const to = pos + node.nodeSize
-            const footnoteMarker = {from, to}
-            footnoteMarkers.push(footnoteMarker)
-        }
-    })
-    return footnoteMarkers
-}
-
-const getAddedRanges = tr => {
-    /* find ranges of the current document that have been added by means of
-     * a transaction.
-     */
-    let ranges = []
-    tr.steps.forEach((step, index) => {
-        if (step.jsonID === "replace" || step.jsonID === "replaceWrap") {
-            ranges.push({from: step.from, to: step.to})
-        }
-        const map = tr.mapping.maps[index]
-        ranges = ranges.map(range => ({
-            from: map.map(range.from, -1),
-            to: map.map(range.to, 1)
-        }))
-    })
-
-    const nonOverlappingRanges = []
-
-    ranges.forEach(range => {
-        let addedRange = false
-        nonOverlappingRanges.forEach(noRange => {
-            if (
-                !addedRange &&
-                range.from <= noRange.from &&
-                range.to >= noRange.from
-            ) {
-                noRange.from = range.from
-                noRange.to = noRange.to > range.to ? noRange.to : range.to
-                addedRange = true
-            } else if (
-                !addedRange &&
-                range.from <= noRange.to &&
-                range.to >= noRange.to
-            ) {
-                noRange.from =
-                    noRange.from < range.from ? noRange.from : range.from
-                noRange.to = range.to
-                addedRange = true
-            }
-        })
-        if (!addedRange) {
-            nonOverlappingRanges.push(range)
-        }
-    })
-
-    return nonOverlappingRanges
-}
-
-export const getFootnoteMarkerContents = state => {
-    const fnState = key.getState(state)
-    if (!fnState || !fnState.fnMarkers) {
-        return []
-    }
-    const fnMarkers = fnState.fnMarkers
-    return fnMarkers.map(
-        fnMarker => state.doc.nodeAt(fnMarker.from).attrs.footnote
-    )
-}
-
-export const updateFootnoteMarker = (state, tr, index, content) => {
-    const {fnMarkers} = key.getState(state)
-
-    const footnote = fnMarkers[index]
-    const node = state.doc.nodeAt(footnote.from)
-    if (node.attrs.footnote === content) {
-        return
-    }
-    tr.setNodeMarkup(footnote.from, node.type, {
-        footnote: content
-    })
-    tr.setMeta("fromFootnote", true)
-    return
-}
-
-export const getFootnoteMarkers = state => {
-    const {fnMarkers} = key.getState(state)
-    return fnMarkers
-}
-
-export const footnoteMarkersPlugin = options =>
-    new Plugin({
-        key,
-        state: {
-            init(_config, state) {
-                const fnMarkers = []
-                state.doc.descendants((node, pos) => {
-                    if (node.type.name === "footnote") {
-                        fnMarkers.push({
-                            from: pos,
-                            to: pos + node.nodeSize
-                        })
-                    }
-                })
-
-                return {
-                    fnMarkers
-                }
-            },
-            apply(tr, _prev, oldState, state) {
-                const meta = tr.getMeta(key)
-                if (meta) {
-                    // There has been an update of a footnote marker,
-                    // return values from meta instead of previous values
-                    // to prevent deletion of decoration
-                    return meta
-                }
-
-                let {fnMarkers} = this.getState(oldState)
-
-                if (!tr.docChanged) {
-                    return {
-                        fnMarkers
-                    }
-                }
-
-                const remote = tr.getMeta("remote"),
-                    fromFootnote = tr.getMeta("fromFootnote"),
-                    ranges = getAddedRanges(tr),
-                    deletedFootnotesIndexes = []
-                fnMarkers = fnMarkers
-                    .map(marker => ({
-                        from: tr.mapping.map(marker.from, 1),
-                        to: tr.mapping.map(marker.to, -1)
-                    }))
-                    .filter((marker, index) => {
-                        if (marker.from !== marker.to - 1) {
-                            // Add in reverse order as highest numbers need to be deleted
-                            // first so that index numbers of lower numbers continue
-                            // to be valid when these are deleted. Only relevant when
-                            // several footnotes are deleted simultaneously.
-                            deletedFootnotesIndexes.unshift(index)
-                            return false
-                        }
-                        return true
-                    })
-                if (fromFootnote) {
-                    return {fnMarkers}
-                }
-                const footTr =
-                    options.editor.mod.footnotes.fnEditor.view.state.tr
-
-                footTr.setMeta("fromMain", true)
-
-                deletedFootnotesIndexes.forEach(index =>
-                    options.editor.mod.footnotes.fnEditor.removeFootnote(
-                        index,
-                        footTr
-                    )
-                )
-                ranges.forEach(range => {
-                    let newFootnotes = findFootnoteMarkers(
-                        range.from,
-                        range.to,
-                        tr.doc
-                    )
-                    if (newFootnotes.length) {
-                        const firstFn = newFootnotes[0]
-                        let offset = fnMarkers.findIndex(
-                            marker => marker.from > firstFn.from
-                        )
-                        if (offset < 0) {
-                            offset = fnMarkers.length
-                        }
-                        if (remote) {
-                            newFootnotes = newFootnotes.filter(
-                                // In case of remote trasnactions, we cannot mark them as coming from footnote, so we
-                                // will need to remove duplicates instead.
-                                newMarker =>
-                                    fnMarkers.find(
-                                        oldMarker =>
-                                            oldMarker.from === newMarker.from
-                                    )
-                                        ? false
-                                        : true
-                            )
-                        } else {
-                            newFootnotes.forEach((footnote, index) => {
-                                const fnContent = state.doc.nodeAt(
-                                    footnote.from
-                                ).attrs.footnote
-                                options.editor.mod.footnotes.fnEditor.renderFootnote(
-                                    fnContent,
-                                    offset + index,
-                                    footTr
-                                )
-                            })
-                        }
-                        fnMarkers = fnMarkers
-                            .concat(newFootnotes)
-                            .sort((a, b) => (a.from > b.from ? 1 : -1))
-                    }
-                })
-
-                const footMeta = tr.getMeta("toFoot")
-
-                if (footMeta) {
-                    Object.entries(footMeta).forEach(([key, value]) => {
-                        footTr.setMeta(key, value)
-                    })
-                }
-
-                if (footTr.docChanged || footMeta) {
-                    tr.setMeta("footTr", footTr)
-                }
-
-                return {
-                    fnMarkers
-                }
-            }
-        },
-        view(_editorView) {
-            return {
-                update: (_view, _prevState) => {
-                    options.editor.mod.footnotes.layout.updateDOM()
-                }
-            }
-        }
-    })

package/src/state_plugins/jump_hidden_nodes.js

@@ -1,58 +0,0 @@
-import {GapCursor} from "prosemirror-gapcursor"
-import {Plugin, PluginKey, TextSelection} from "prosemirror-state"
-
-// A plugin that makes sure that the selecion is not put into a node that has been
-// hidden.
-
-const posHidden = $pos => {
-    let hidden = false
-    for (let i = $pos.depth; i > 0; i--) {
-        const node = $pos.node(i)
-        if (
-            node.attrs.hidden ||
-            (["table_caption", "figure_caption"].includes(node.type.name) &&
-                $pos.node(i - 1).attrs.caption === false)
-        ) {
-            hidden = true
-        }
-    }
-    return hidden
-}
-
-const key = new PluginKey("jump-hidden-nodes")
-export const jumpHiddenNodesPlugin = _options =>
-    new Plugin({
-        key,
-        appendTransaction: (trs, oldState, state) => {
-            if (state.selection.from !== state.selection.to) {
-                // Only applies to collapsed selection
-                return
-            }
-            const selectionSet = trs.find(tr => tr.selectionSet)
-
-            if (selectionSet && posHidden(state.selection.$from)) {
-                const dir =
-                    state.selection.from > oldState.selection.from ? 1 : -1
-                let newPos = state.selection.from,
-                    hidden = true,
-                    validTextSelection = false,
-                    validGapCursor = false,
-                    $pos
-                while (hidden || (!validGapCursor && !validTextSelection)) {
-                    newPos += dir
-                    if (newPos === 0 || newPos === state.doc.nodeSize) {
-                        // Could not find any valid position
-                        return
-                    }
-                    $pos = state.doc.resolve(newPos)
-                    validTextSelection = $pos.parent.inlineContent
-                    validGapCursor = GapCursor.valid($pos)
-                    hidden = posHidden($pos)
-                }
-                const selection = validTextSelection
-                    ? new TextSelection($pos)
-                    : new GapCursor($pos)
-                return state.tr.setSelection(selection)
-            }
-        }
-    })

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: {}
-        }
-    })