@manuscripts/body-editor 2.0.46-LEAN-3883.1 → 2.0.46

package/dist/cjs/views/inline_footnote.js

@@ -88,12 +88,18 @@ class InlineFootnoteView extends base_node_view_1.BaseNodeView {
             const fnState = footnotes_2.footnotesKey.getState(this.view.state);
             if (fnState) {
                 this.activateModal({
-                    notes: Array.from(fnState.unusedFootnotes.values()).map((n) => ({
-                        node: n[0],
-                    })),
+                    notes: Array.from(fnState.unusedFootnotes.values()).reduce((acc, n) => {
+                        const node = n[0];
+                        if (!(0, track_changes_utils_1.isDeleted)(node) && !(0, track_changes_utils_1.isRejectedInsert)(node)) {
+                            acc.push({
+                                node,
+                            });
+                        }
+                        return acc;
+                    }, []),
                     onCancel: () => {
                         const { tr } = this.view.state;
-                        if (!this.node.attrs.rids.length) {
+                        if (!(0, track_changes_utils_1.getActualAttrs)(this.node).rids.length) {
                             this.view.dispatch(tr.delete(this.getPos(), this.getPos() + this.node.nodeSize));
                         }
                         this.destroy();
@@ -120,7 +126,7 @@ class InlineFootnoteView extends base_node_view_1.BaseNodeView {
             this.dom.setAttribute('contents', attrs.contents);
             this.dom.className = [
                 'footnote',
-                ...(0, track_changes_utils_1.getChangeClasses)(attrs.dataTracked),
+                ...(0, track_changes_utils_1.getChangeClasses)(this.node.attrs.dataTracked),
             ].join(' ');
             if (this.isSelected() &&
                 (!attrs.rids || !attrs.rids.length) &&
@@ -170,8 +176,8 @@ class InlineFootnoteView extends base_node_view_1.BaseNodeView {
         };
         this.onInsert = (notes) => {
             if (notes.length) {
-                const contents = this.node.attrs.contents
-                    .split(',')
+                const contents = (0, track_changes_utils_1.getActualAttrs)(this.node)
+                    .contents.split(',')
                     .map((n) => parseInt(n));
                 const rids = notes.map((note) => note.node.attrs.id);
                 const { tr } = this.view.state;

package/dist/es/commands.js

@@ -26,13 +26,11 @@ import { getCommentKey, getCommentRange } from './lib/comments';
 import { findBackmatter, findBibliographySection, findBody, insertSupplementsNode, } from './lib/doc';
 import { getNewFootnotePos } from './lib/footnotes';
 import { findWordBoundaries, isNodeOfType, nearestAncestor, } from './lib/helpers';
-import { sectionTitles } from './lib/section-titles';
 import { isDeleted, isRejectedInsert } from './lib/track-changes-utils';
 import { findParentNodeWithId, getChildOfType, getMatchingChild, } from './lib/utils';
 import { setCommentSelection } from './plugins/comments';
 import { getEditorProps } from './plugins/editor-props';
 import { footnotesKey } from './plugins/footnotes';
-import { checkForCompletion } from './plugins/section_title/autocompletion';
 export const markActive = (type) => (state) => {
     const { from, $from, to, empty } = state.selection;
     return empty
@@ -456,6 +454,16 @@ export const insertSection = (subsection = false) => (state, dispatch, view) =>
     }
     return true;
 };
+const sectionTitles = new Map([
+    ['MPSectionCategory:acknowledgement', 'Acknowledgments'],
+    ['MPSectionCategory:availability', 'Availability'],
+    ['MPSectionCategory:competing-interests', 'COI Statement'],
+    ['MPSectionCategory:con', 'Contributed-by information'],
+    ['MPSectionCategory:ethics-statement', 'Ethics Statement'],
+    ['MPSectionCategory:financial-disclosure', 'Financial Disclosure'],
+    ['MPSectionCategory:supplementary-material', 'Supplementary Material'],
+    ['MPSectionCategory:supported-by', 'Supported By'],
+]);
 export const insertBackMatterSection = (category) => (state, dispatch, view) => {
     const backmatter = findBackmatter(state.doc);
     const sections = findChildrenByType(backmatter.node, schema.nodes.section);
@@ -1083,18 +1091,3 @@ export function mergeCellsWithSpace(state, dispatch) {
     }
     return true;
 }
-export const autoComplete = (state, dispatch) => {
-    const complete = checkForCompletion(state);
-    if (complete) {
-        const tr = state.tr.insertText(complete.suggestion, state.selection.from);
-        const inserted = complete.title.substring(0, complete.title.length - complete.suggestion.length);
-        console.log(inserted);
-        console.log(complete);
-        if (inserted) {
-            tr.replaceWith(state.selection.from - inserted.length, state.selection.from, schema.text(inserted));
-        }
-        dispatch && dispatch(tr);
-        return true;
-    }
-    return false;
-};

package/dist/es/components/views/FootnotesSelector.js

@@ -16,6 +16,7 @@
 import { AddedIcon, AddIcon, AddNewIcon, ButtonGroup, IconTextButton, PrimaryButton, SecondaryButton, } from '@manuscripts/style-guide';
 import React, { useState } from 'react';
 import styled from 'styled-components';
+import { getActualAttrs } from '../../lib/track-changes-utils';
 const NotesContainer = styled.div `
   height: 90vh;
   max-height: 400px;
@@ -50,7 +51,7 @@ const AddNewFootnote = styled(ButtonGroup) `
 export const FootnotesSelector = ({ notes, inlineFootnote, onAdd, onInsert, onCancel, addNewLabel }) => {
     let selectedNotesMap;
     if (inlineFootnote) {
-        const rids = inlineFootnote.attrs.rids;
+        const rids = getActualAttrs(inlineFootnote).rids;
         const selectedNotes = notes.filter(({ node }) => rids.includes(node.attrs.id));
         selectedNotesMap = new Map(selectedNotes.map(({ node }) => [node.attrs.id, node]));
     }
@@ -88,7 +89,8 @@ const FootnotesList = ({ notes, isSelected, onSelect, inlineFootnote }) => {
     const selectedNotes = [];
     const remainingNotes = [];
     notes.forEach((note) => {
-        const isNoteSelected = inlineFootnote && inlineFootnote.attrs.rids.includes(note.node.attrs.id);
+        const isNoteSelected = inlineFootnote &&
+            getActualAttrs(inlineFootnote).rids.includes(note.node.attrs.id);
         if (isNoteSelected) {
             selectedNotes.push(note);
         }

package/dist/es/keys/misc.js

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 import { schema } from '@manuscripts/transform';
-import { chainCommands, createParagraphNear, exitCode, joinDown, joinUp, lift, liftEmptyBlock, newlineInCode, splitBlock, toggleMark, wrapIn, } from 'prosemirror-commands';
+import { chainCommands, exitCode, joinDown, joinUp, lift, toggleMark, wrapIn, } from 'prosemirror-commands';
 import { redo, undo } from 'prosemirror-history';
 import { undoInputRule } from 'prosemirror-inputrules';
 import { goToNextCell } from 'prosemirror-tables';
-import { autoComplete, ignoreAtomBlockNodeBackward, ignoreAtomBlockNodeForward, ignoreMetaNodeBackspaceCommand, insertBlock, insertBreak, insertCrossReference, insertInlineCitation, insertInlineEquation, insertSection, selectAllIsolating, } from '../commands';
+import { ignoreAtomBlockNodeBackward, ignoreAtomBlockNodeForward, ignoreMetaNodeBackspaceCommand, insertBlock, insertBreak, insertCrossReference, insertInlineCitation, insertInlineEquation, insertSection, selectAllIsolating, } from '../commands';
 const customKeymap = {
     Backspace: chainCommands(undoInputRule, ignoreAtomBlockNodeBackward, ignoreMetaNodeBackspaceCommand),
     Delete: ignoreAtomBlockNodeForward,
@@ -37,7 +37,6 @@ const customKeymap = {
     'Mod-Alt-=': toggleMark(schema.marks.superscript),
     'Mod-Alt--': toggleMark(schema.marks.subscript),
     'Ctrl->': wrapIn(schema.nodes.blockquote),
-    Enter: chainCommands(autoComplete, newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock),
     'Shift-Mod-Enter': insertSection(true),
     'Mod-Enter': chainCommands(exitCode, insertSection()),
     'Shift-Enter': chainCommands(exitCode, insertBreak),

package/dist/es/lib/track-changes-utils.js

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 import { EditAttrsTrackingIcon } from '@manuscripts/style-guide';
-import { schema } from '@manuscripts/transform';
 import { createElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 export function isRejectedInsert(node) {
@@ -75,11 +74,20 @@ export function isTracked(node) {
     return false;
 }
 export function getActualAttrs(node) {
+    var _a;
     const attrs = node.attrs;
-    if (attrs.dataTracked &&
-        attrs.dataTracked[0].status === 'rejected' &&
-        attrs.dataTracked[0].operation === 'set_attrs') {
-        return attrs.dataTracked[0].oldAttrs;
+    if ((_a = attrs.dataTracked) === null || _a === void 0 ? void 0 : _a.length) {
+        const changes = attrs.dataTracked.filter((c) => c.operation === 'set_attrs');
+        const hasPendingAttrs = changes.some((c) => c.status === 'pending');
+        if (hasPendingAttrs) {
+            return attrs;
+        }
+        const rejected = changes
+            .filter((c) => c.status === 'rejected')
+            .sort((a, b) => b.statusUpdateAt - a.statusUpdateAt)[0];
+        if (rejected && rejected.status === 'rejected') {
+            return rejected.oldAttrs;
+        }
     }
     return attrs;
 }
@@ -93,43 +101,6 @@ export const getAttrsTrackingButton = (changeID) => {
 export function isHidden(node) {
     return isDeleted(node) || isRejectedInsert(node);
 }
-export function isDeletedText(node) {
-    var _a, _b, _c, _d;
-    if (node.type === schema.nodes.text && node.marks.length) {
-        const deleteMark = node.marks.find((mark) => mark.type === schema.marks.tracked_delete);
-        if (deleteMark &&
-            ((_b = (_a = deleteMark.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) === null || _b === void 0 ? void 0 : _b.status) &&
-            ['pending', 'approved'].includes((_d = (_c = deleteMark.attrs) === null || _c === void 0 ? void 0 : _c.dataTracked) === null || _d === void 0 ? void 0 : _d.status)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function isRejectedText(node) {
-    var _a, _b;
-    if (node.type === schema.nodes.text) {
-        const insertMark = node.marks.find((mark) => mark.type === schema.marks.tracked_insert);
-        if (insertMark && ((_b = (_a = insertMark.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) === null || _b === void 0 ? void 0 : _b.status) === 'rejected') {
-            return true;
-        }
-    }
-    return false;
-}
-export function getActualTextContent(fragment) {
-    let finalContent = '';
-    function getContent(fragment) {
-        fragment.forEach((node) => {
-            if (node.type !== schema.nodes.text) {
-                finalContent += getContent(node.content);
-            }
-            if (!isDeletedText(node) && !isRejectedText(node)) {
-                finalContent += node.textContent;
-            }
-        });
-    }
-    getContent(fragment);
-    return finalContent;
-}
 export function sanitizeAttrsChange(newAttr, currentAttrs) {
     return Object.keys(newAttr).reduce((acc, attr) => {
         const key = attr;

package/dist/es/plugins/footnotes/index.js

@@ -13,117 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { AlertIcon, DeleteIcon } from '@manuscripts/style-guide';
 import { skipTracking } from '@manuscripts/track-changes-plugin';
 import { isFootnoteNode, isFootnotesElementNode, isFootnotesSectionNode, isInlineFootnoteNode, schema, } from '@manuscripts/transform';
 import { isEqual } from 'lodash';
-import { NodeSelection, Plugin, PluginKey, TextSelection, } from 'prosemirror-state';
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
 import { findParentNodeClosestToPos, findParentNodeOfType, } from 'prosemirror-utils';
 import { Decoration, DecorationSet } from 'prosemirror-view';
-import { createElement } from 'react';
-import { renderToStaticMarkup } from 'react-dom/server';
 import { isTextSelection } from '../../commands';
-import { DeleteFootnoteDialog, } from '../../components/views/DeleteFootnoteDialog';
-import { findTableInlineFootnoteIds, getAlphaOrderIndices, getInlineFootnotes, } from '../../lib/footnotes';
-import { getChildOfType } from '../../lib/utils';
-import ReactSubView from '../../views/ReactSubView';
+import { findTableInlineFootnoteIds, getAlphaOrderIndices, } from '../../lib/footnotes';
 import { placeholderWidget } from '../placeholder';
+import { getActualAttrs } from '../../lib/track-changes-utils';
+import { deleteFootnoteWidget, labelWidget, uncitedFootnoteWidget, } from './widgets';
 export const footnotesKey = new PluginKey('footnotes');
-const scrollToInlineFootnote = (rid, view) => {
-    view.state.doc.descendants((node, pos) => {
-        const footnote = node;
-        if (isInlineFootnoteNode(node) && footnote.attrs.rids.includes(rid)) {
-            const selection = NodeSelection.create(view.state.doc, pos);
-            view.dispatch(view.state.tr.setSelection(selection).scrollIntoView());
-        }
-    });
-};
-const labelWidget = (label, id) => (view) => {
-    const element = document.createElement('span');
-    element.className = 'footnote-label';
-    element.textContent = label;
-    element.addEventListener('mousedown', () => {
-        scrollToInlineFootnote(id, view);
-    });
-    return element;
-};
-export const uncitedFootnoteWidget = () => () => {
-    const element = document.createElement('span');
-    element.className = 'uncited-footnote';
-    element.innerHTML = renderToStaticMarkup(createElement(AlertIcon));
-    return element;
-};
-const deleteFootnoteWidget = (node, props, id, tableElement, tableElementFooter) => (view, getPos) => {
-    const deleteBtn = document.createElement('span');
-    deleteBtn.className = 'delete-icon';
-    deleteBtn.innerHTML = renderToStaticMarkup(createElement(DeleteIcon));
-    const parentType = tableElement ? 'table ' : '';
-    const footnote = {
-        type: node.type === schema.nodes.footnote
-            ? `${parentType}footnote`
-            : 'table general note',
-        message: node.type === schema.nodes.footnote
-            ? `This action will entirely remove the ${parentType}footnote from the list because it will no longer be used.`
-            : 'This action will entirely remove the table general note.',
-    };
-    deleteBtn.addEventListener('mousedown', () => {
-        const handleDelete = () => {
-            const tr = view.state.tr;
-            const pos = getPos();
-            if (node.type === schema.nodes.general_table_footnote && pos) {
-                if (tableElementFooter &&
-                    !getChildOfType(tableElementFooter.node, schema.nodes.footnotes_element, true) &&
-                    tableElementFooter.pos) {
-                    tr.delete(tableElementFooter.pos - 1, tableElementFooter.pos + tableElementFooter.node.nodeSize);
-                }
-                else {
-                    tr.delete(pos - 1, pos + node.nodeSize + 1);
-                }
-            }
-            if (node.type === schema.nodes.footnote && pos) {
-                const targetNode = tableElement ? tableElement.node : view.state.doc;
-                const inlineFootnotes = getInlineFootnotes(id, targetNode);
-                const footnotesElement = findParentNodeClosestToPos(tr.doc.resolve(pos), (node) => node.type === schema.nodes.footnotes_element);
-                if ((footnotesElement === null || footnotesElement === void 0 ? void 0 : footnotesElement.node.childCount) === 1 &&
-                    (tableElementFooter === null || tableElementFooter === void 0 ? void 0 : tableElementFooter.node.childCount) === 1) {
-                    const { pos: fnPos, node: fnNode } = tableElementFooter;
-                    tr.delete(fnPos, fnPos + fnNode.nodeSize + 1);
-                }
-                else if ((footnotesElement === null || footnotesElement === void 0 ? void 0 : footnotesElement.node.childCount) === 1) {
-                    const { pos: fnPos, node: fnNode } = footnotesElement;
-                    tr.delete(fnPos, fnPos + fnNode.nodeSize + 1);
-                }
-                else {
-                    const footnote = findParentNodeClosestToPos(tr.doc.resolve(pos), (node) => node.type === schema.nodes.footnote);
-                    if (footnote) {
-                        const { pos: fnPos, node: fnNode } = footnote;
-                        tr.delete(fnPos, fnPos + fnNode.nodeSize + 1);
-                    }
-                }
-                if (inlineFootnotes) {
-                    inlineFootnotes.forEach((footnote) => {
-                        const pos = footnote.pos + (tableElement ? tableElement.pos + 1 : 0);
-                        if (footnote.node.attrs.rids.length > 1) {
-                            const updatedRids = footnote.node.attrs.rids.filter((rid) => rid !== id);
-                            tr.setNodeMarkup(tr.mapping.map(pos), undefined, Object.assign(Object.assign({}, node.attrs), { rids: updatedRids }));
-                        }
-                        else {
-                            tr.delete(tr.mapping.map(pos), tr.mapping.map(pos + footnote.node.nodeSize));
-                        }
-                    });
-                }
-            }
-            view.dispatch(tr);
-        };
-        const componentProps = {
-            footnoteType: footnote.type,
-            footnoteMessage: footnote.message,
-            handleDelete: handleDelete,
-        };
-        ReactSubView(Object.assign(Object.assign({}, props), { dispatch: view.dispatch }), DeleteFootnoteDialog, componentProps, node, () => getPos(), view);
-    });
-    return deleteBtn;
-};
 export const buildPluginState = (doc) => {
     const inlineFootnotes = [];
     const footnotes = new Map();
@@ -150,25 +51,25 @@ export const buildPluginState = (doc) => {
     const labels = new Map();
     inlineFootnotes.sort((a, b) => a[1] - b[1]);
     inlineFootnotes.forEach(([node]) => {
-        node.attrs.rids.forEach((rid) => {
+        getActualAttrs(node).rids.forEach((rid) => {
             labels.set(rid, getAlphaOrderIndices(index++));
         });
     });
     const footnotesReordered = [];
-    const footnotesRest = new Map(footnotes);
+    const unusedFootnotes = new Map(footnotes);
     inlineFootnotes.forEach(([node]) => {
         const footnote = node;
-        footnote.attrs.rids.forEach((rid) => {
-            const currentfNode = footnotesRest.get(rid);
-            if (currentfNode) {
-                footnotesReordered.push(currentfNode[0]);
-                footnotesRest.delete(rid);
+        getActualAttrs(footnote).rids.forEach((rid) => {
+            const currentFnNode = unusedFootnotes.get(rid);
+            if (currentFnNode) {
+                footnotesReordered.push(currentFnNode[0]);
+                unusedFootnotes.delete(rid);
             }
         });
     });
     return {
         inlineFootnotes,
-        unusedFootnotes: footnotesRest,
+        unusedFootnotes,
         footnotes,
         footnoteElement,
         labels,
@@ -192,8 +93,8 @@ export default (props) => {
         appendTransaction(transactions, oldState, newState) {
             const { inlineFootnotes: oldInlineFootnoteNodes } = footnotesKey.getState(oldState);
             const { inlineFootnotes: inlineFootnoteNodes, footnotes, labels, footnoteElement, unusedFootnotes, } = footnotesKey.getState(newState);
-            const prevIds = oldInlineFootnoteNodes.map(([node]) => node.attrs.rids);
-            const newIds = inlineFootnoteNodes.map(([node]) => node.attrs.rids);
+            const prevIds = oldInlineFootnoteNodes.map(([node]) => getActualAttrs(node).rids);
+            const newIds = inlineFootnoteNodes.map(([node]) => getActualAttrs(node).rids);
             const initTransaction = transactions.find((t) => t.getMeta('INIT'));
             if (!footnoteElement || (!initTransaction && isEqual(prevIds, newIds))) {
                 return null;
@@ -202,23 +103,24 @@ export default (props) => {
             const footnotesReordered = [];
             inlineFootnoteNodes.forEach(([node, pos]) => {
                 const footnote = node;
-                const contents = footnote.attrs.rids
+                const attrs = getActualAttrs(footnote);
+                const contents = attrs.rids
                     .map((rid) => {
-                    const currentfNode = footnotes.get(rid);
-                    if (currentfNode) {
-                        footnotesReordered.push(currentfNode[0]);
+                    const currentFnNode = footnotes.get(rid);
+                    if (currentFnNode) {
+                        footnotesReordered.push(currentFnNode[0]);
                     }
                     return labels.get(rid);
                 })
                     .join('');
-                if (footnote.attrs.contents !== contents) {
+                if (attrs.contents !== contents) {
                     tr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, footnote.attrs), { rids: footnote.attrs.rids, contents }));
                 }
             });
             unusedFootnotes.forEach(([node]) => footnotesReordered.push(node));
-            const newFElement = schema.nodes.footnotes_element.create(footnoteElement[0].attrs, footnotesReordered);
-            if (newFElement && footnotes.size > 0) {
-                tr.replaceWith(footnoteElement[1], footnoteElement[1] + footnoteElement[0].nodeSize, newFElement);
+            const newFnElement = schema.nodes.footnotes_element.create(footnoteElement[0].attrs, footnotesReordered);
+            if (newFnElement && footnotes.size > 0) {
+                tr.replaceWith(footnoteElement[1], footnoteElement[1] + footnoteElement[0].nodeSize, newFnElement);
             }
             const prevSelection = newState.selection;
             const selectedFootnote = findParentNodeClosestToPos(prevSelection.$anchor, (node) => isFootnoteNode(node));

package/dist/es/plugins/footnotes/widgets.js

@@ -0,0 +1,122 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AlertIcon, DeleteIcon } from '@manuscripts/style-guide';
+import { isInlineFootnoteNode, schema, } from '@manuscripts/transform';
+import { NodeSelection } from 'prosemirror-state';
+import { findParentNodeClosestToPos } from 'prosemirror-utils';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { DeleteFootnoteDialog, } from '../../components/views/DeleteFootnoteDialog';
+import { getInlineFootnotes } from '../../lib/footnotes';
+import { getChildOfType } from '../../lib/utils';
+import ReactSubView from '../../views/ReactSubView';
+import { getActualAttrs } from '../../lib/track-changes-utils';
+export const deleteFootnoteWidget = (node, props, id, tableElement, tableElementFooter) => (view, getPos) => {
+    const deleteBtn = document.createElement('span');
+    deleteBtn.className = 'delete-icon';
+    deleteBtn.innerHTML = renderToStaticMarkup(createElement(DeleteIcon));
+    const parentType = tableElement ? 'table ' : '';
+    const footnote = {
+        type: node.type === schema.nodes.footnote
+            ? `${parentType}footnote`
+            : 'table general note',
+        message: node.type === schema.nodes.footnote
+            ? `This action will entirely remove the ${parentType}footnote from the list because it will no longer be used.`
+            : 'This action will entirely remove the table general note.',
+    };
+    deleteBtn.addEventListener('mousedown', () => {
+        const handleDelete = () => {
+            const tr = view.state.tr;
+            const pos = getPos();
+            if (node.type === schema.nodes.general_table_footnote && pos) {
+                if (tableElementFooter &&
+                    !getChildOfType(tableElementFooter.node, schema.nodes.footnotes_element, true) &&
+                    tableElementFooter.pos) {
+                    tr.delete(tableElementFooter.pos - 1, tableElementFooter.pos + tableElementFooter.node.nodeSize);
+                }
+                else {
+                    tr.delete(pos - 1, pos + node.nodeSize + 1);
+                }
+            }
+            if (node.type === schema.nodes.footnote && pos) {
+                const targetNode = tableElement ? tableElement.node : view.state.doc;
+                const inlineFootnotes = getInlineFootnotes(id, targetNode);
+                const footnotesElement = findParentNodeClosestToPos(tr.doc.resolve(pos), (node) => node.type === schema.nodes.footnotes_element);
+                if ((footnotesElement === null || footnotesElement === void 0 ? void 0 : footnotesElement.node.childCount) === 1 &&
+                    (tableElementFooter === null || tableElementFooter === void 0 ? void 0 : tableElementFooter.node.childCount) === 1) {
+                    const { pos: fnPos, node: fnNode } = tableElementFooter;
+                    tr.delete(fnPos, fnPos + fnNode.nodeSize + 1);
+                }
+                else if ((footnotesElement === null || footnotesElement === void 0 ? void 0 : footnotesElement.node.childCount) === 1) {
+                    const { pos: fnPos, node: fnNode } = footnotesElement;
+                    tr.delete(fnPos, fnPos + fnNode.nodeSize + 1);
+                }
+                else {
+                    const footnote = findParentNodeClosestToPos(tr.doc.resolve(pos), (node) => node.type === schema.nodes.footnote);
+                    if (footnote) {
+                        const { pos: fnPos, node: fnNode } = footnote;
+                        tr.delete(fnPos, fnPos + fnNode.nodeSize + 1);
+                    }
+                }
+                if (inlineFootnotes) {
+                    inlineFootnotes.forEach((footnote) => {
+                        const pos = footnote.pos + (tableElement ? tableElement.pos + 1 : 0);
+                        if (footnote.node.attrs.rids.length > 1) {
+                            const updatedRids = footnote.node.attrs.rids.filter((rid) => rid !== id);
+                            tr.setNodeMarkup(tr.mapping.map(pos), undefined, Object.assign(Object.assign({}, node.attrs), { rids: updatedRids }));
+                        }
+                        else {
+                            tr.delete(tr.mapping.map(pos), tr.mapping.map(pos + footnote.node.nodeSize));
+                        }
+                    });
+                }
+            }
+            view.dispatch(tr);
+        };
+        const componentProps = {
+            footnoteType: footnote.type,
+            footnoteMessage: footnote.message,
+            handleDelete: handleDelete,
+        };
+        ReactSubView(Object.assign(Object.assign({}, props), { dispatch: view.dispatch }), DeleteFootnoteDialog, componentProps, node, () => getPos(), view);
+    });
+    return deleteBtn;
+};
+const scrollToInlineFootnote = (rid, view) => {
+    view.state.doc.descendants((node, pos) => {
+        const footnote = node;
+        if (isInlineFootnoteNode(node) &&
+            getActualAttrs(footnote).rids.includes(rid)) {
+            const selection = NodeSelection.create(view.state.doc, pos);
+            view.dispatch(view.state.tr.setSelection(selection).scrollIntoView());
+        }
+    });
+};
+export const labelWidget = (label, id) => (view) => {
+    const element = document.createElement('span');
+    element.className = 'footnote-label';
+    element.textContent = label;
+    element.addEventListener('mousedown', () => {
+        scrollToInlineFootnote(id, view);
+    });
+    return element;
+};
+export const uncitedFootnoteWidget = () => () => {
+    const element = document.createElement('span');
+    element.className = 'uncited-footnote';
+    element.innerHTML = renderToStaticMarkup(createElement(AlertIcon));
+    return element;
+};

package/dist/es/plugins/{section_title/index.js → section_title.js}

@@ -1,9 +1,7 @@
 import { schema } from '@manuscripts/transform';
 import { Plugin, PluginKey } from 'prosemirror-state';
 import { findChildrenByType } from 'prosemirror-utils';
-import { Decoration, DecorationSet } from 'prosemirror-view';
-import { isRejectedInsert } from '../../lib/track-changes-utils';
-import { checkForCompletion } from './autocompletion';
+import { isRejectedInsert } from '../lib/track-changes-utils';
 export const sectionTitleKey = new PluginKey('sectionNumbering');
 const calculateSectionLevels = (node, startPos, sectionNumberMap, numbering = [0]) => {
     node.forEach((childNode, offset) => {
@@ -34,21 +32,6 @@ const getPluginState = (doc) => {
 export default () => {
     return new Plugin({
         key: sectionTitleKey,
-        props: {
-            decorations(state) {
-                const text = checkForCompletion(state);
-                if (text) {
-                    const decoration = Decoration.widget(state.selection.from, () => {
-                        const node = document.createElement('span');
-                        node.classList.add('completion-bearer');
-                        node.dataset.suggest = text.suggestion;
-                        return node;
-                    });
-                    return DecorationSet.create(state.doc, [decoration]);
-                }
-                return DecorationSet.empty;
-            },
-        },
         state: {
             init: (_, state) => {
                 return getPluginState(state.doc);

package/dist/es/versions.js

@@ -1,2 +1,2 @@
-export const VERSION = '2.0.46-LEAN-3883.1';
+export const VERSION = '2.0.46';
 export const MATHJAX_VERSION = '3.2.2';

package/dist/es/views/footnote.js

@@ -29,5 +29,6 @@ export const setTCClasses = (node, dom) => {
         const changeClasses = getChangeClasses([lastChange]);
         dom.classList.add(...changeClasses);
     }
+    dom.setAttribute('id', node.attrs.id);
 };
 export default createNodeOrElementView(FootnoteView, 'div', setTCClasses);

package/dist/es/views/inline_footnote.js

@@ -20,7 +20,7 @@ import { findChildrenByType, findParentNodeClosestToPos, } from 'prosemirror-uti
 import { createFootnote, insertFootnote, insertTableFootnote, } from '../commands';
 import { FootnotesSelector } from '../components/views/FootnotesSelector';
 import { buildTableFootnoteLabels } from '../lib/footnotes';
-import { getChangeClasses, isDeleted, isPendingInsert, isRejectedInsert, } from '../lib/track-changes-utils';
+import { getActualAttrs, getChangeClasses, isDeleted, isPendingInsert, isRejectedInsert, } from '../lib/track-changes-utils';
 import { footnotesKey } from '../plugins/footnotes';
 import { BaseNodeView } from './base_node_view';
 import { createNodeView } from './creators';
@@ -82,12 +82,18 @@ export class InlineFootnoteView extends BaseNodeView {
             const fnState = footnotesKey.getState(this.view.state);
             if (fnState) {
                 this.activateModal({
-                    notes: Array.from(fnState.unusedFootnotes.values()).map((n) => ({
-                        node: n[0],
-                    })),
+                    notes: Array.from(fnState.unusedFootnotes.values()).reduce((acc, n) => {
+                        const node = n[0];
+                        if (!isDeleted(node) && !isRejectedInsert(node)) {
+                            acc.push({
+                                node,
+                            });
+                        }
+                        return acc;
+                    }, []),
                     onCancel: () => {
                         const { tr } = this.view.state;
-                        if (!this.node.attrs.rids.length) {
+                        if (!getActualAttrs(this.node).rids.length) {
                             this.view.dispatch(tr.delete(this.getPos(), this.getPos() + this.node.nodeSize));
                         }
                         this.destroy();
@@ -114,7 +120,7 @@ export class InlineFootnoteView extends BaseNodeView {
             this.dom.setAttribute('contents', attrs.contents);
             this.dom.className = [
                 'footnote',
-                ...getChangeClasses(attrs.dataTracked),
+                ...getChangeClasses(this.node.attrs.dataTracked),
             ].join(' ');
             if (this.isSelected() &&
                 (!attrs.rids || !attrs.rids.length) &&
@@ -164,8 +170,8 @@ export class InlineFootnoteView extends BaseNodeView {
         };
         this.onInsert = (notes) => {
             if (notes.length) {
-                const contents = this.node.attrs.contents
-                    .split(',')
+                const contents = getActualAttrs(this.node)
+                    .contents.split(',')
                     .map((n) => parseInt(n));
                 const rids = notes.map((note) => note.node.attrs.id);
                 const { tr } = this.view.state;

package/dist/types/commands.d.ts

@@ -75,5 +75,4 @@ export declare const insertTableFootnote: (tableElementNode: ManuscriptNode, pos
 export declare const addRows: (direction: 'top' | 'bottom') => (state: EditorState, dispatch?: ((tr: Transaction) => void) | undefined) => boolean;
 export declare const addColumns: (direction: 'right' | 'left') => (state: EditorState, dispatch?: ((tr: Transaction) => void) | undefined) => boolean;
 export declare function mergeCellsWithSpace(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
-export declare const autoComplete: (state: ManuscriptEditorState, dispatch?: Dispatch) => boolean;
 export {};