@manuscripts/body-editor 2.5.6-date-fix.0 → 2.5.7

package/dist/cjs/views/table_element_footer.js

@@ -15,7 +15,6 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableElementFooterView = void 0;
 const base_node_view_1 = require("./base_node_view");
 const creators_1 = require("./creators");
 class TableElementFooterView extends base_node_view_1.BaseNodeView {
@@ -28,10 +27,8 @@ class TableElementFooterView extends base_node_view_1.BaseNodeView {
             this.dom = document.createElement('div');
             this.dom.classList.add('table-footer');
             this.dom.setAttribute('id', this.node.attrs.id);
-            this.contentDOM = document.createElement('div');
-            this.dom.appendChild(this.contentDOM);
+            this.contentDOM = this.dom;
         };
     }
 }
-exports.TableElementFooterView = TableElementFooterView;
-exports.default = (0, creators_1.createNodeView)(TableElementFooterView);
+exports.default = (0, creators_1.createEditableNodeView)(TableElementFooterView);

package/dist/es/commands.js

@@ -15,23 +15,22 @@
  */
 import { buildContribution } from '@manuscripts/json-schema';
 import { skipTracking } from '@manuscripts/track-changes-plugin';
-import { generateNodeID, isElementNodeType, isFootnoteNode, isListNode, isParagraphNode, isSectionNodeType, schema, } from '@manuscripts/transform';
+import { generateNodeID, isElementNodeType, isListNode, isSectionNodeType, isTableElementNode, schema, } from '@manuscripts/transform';
 import { Fragment, NodeRange, } from 'prosemirror-model';
 import { wrapInList } from 'prosemirror-schema-list';
 import { NodeSelection, TextSelection, } from 'prosemirror-state';
 import { addColSpan, addColumnAfter, addColumnBefore, addRow, CellSelection, selectedRect, } from 'prosemirror-tables';
 import { findWrapping, liftTarget, ReplaceAroundStep, } from 'prosemirror-transform';
-import { findChildrenByType, findParentNodeOfType, hasParentNodeOfType, } from 'prosemirror-utils';
+import { findChildrenByType, findParentNodeOfType, findParentNodeOfTypeClosestToPos, hasParentNodeOfType, } from 'prosemirror-utils';
 import { getCommentKey, getCommentRange } from './lib/comments';
-import { findBackmatter, findBibliographySection, findBody, insertSupplementsNode, } from './lib/doc';
-import { getNewFootnotePos } from './lib/footnotes';
+import { findBackmatter, findBibliographySection, findBody, insertFootnotesSection, insertSupplementsNode, } from './lib/doc';
+import { createFootnote, findFootnotesContainerNode, getFootnotesElementState, } from './lib/footnotes';
 import { findWordBoundaries, isNodeOfType, nearestAncestor, } from './lib/helpers';
 import { sectionTitles } from './lib/section-titles';
 import { isDeleted } 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 addToStart = (state, dispatch) => {
     const { selection } = state;
@@ -152,45 +151,35 @@ export const createBlock = (nodeType, position, state, dispatch, attrs) => {
         dispatch(tr.setSelection(selection).scrollIntoView());
     }
 };
-export const undoFootnoteDelete = (tr, footnote, position) => {
-    const updatedAttrs = Object.assign(Object.assign({}, footnote.node.attrs), { dataTracked: null });
-    tr.setNodeMarkup(position, undefined, updatedAttrs, footnote.node.marks);
-};
-export const insertGeneralFootnote = (tableElementNode, position, view, tableElementFooter) => {
-    const { state, dispatch } = view;
-    const paragraph = state.schema.nodes.paragraph.create({
-        placeholder: 'Add general note here',
-    });
-    const generalNote = state.schema.nodes.general_table_footnote.create({}, [
-        paragraph,
-    ]);
-    const tableColGroup = findChildrenByType(tableElementNode, schema.nodes.table_colgroup)[0];
-    const table = findChildrenByType(tableElementNode, schema.nodes.table)[0];
-    const tr = state.tr;
-    const pos = (tableElementFooter === null || tableElementFooter === void 0 ? void 0 : tableElementFooter.length)
-        ? position + tableElementFooter[0].pos + 2
-        : position +
-            (!tableColGroup
-                ? table.pos + table.node.nodeSize
-                : tableColGroup.pos + tableColGroup.node.nodeSize);
-    if (tableElementFooter === null || tableElementFooter === void 0 ? void 0 : tableElementFooter.length) {
-        if (isDeleted(tableElementFooter[0].node)) {
-            const tableElementFooterPos = tr.mapping.map(position + tableElementFooter[0].pos + 1);
-            undoFootnoteDelete(tr, tableElementFooter[0], tableElementFooterPos);
-        }
-        tr.insert(pos, generalNote);
+export const insertInlineTableFootnote = (state, dispatch) => {
+    const $pos = state.selection.$to;
+    const table = findParentNodeOfTypeClosestToPos($pos, schema.nodes.table);
+    if (!table) {
+        return false;
     }
-    else {
-        const tableElementFooter = schema.nodes.table_element_footer.create({
-            id: generateNodeID(schema.nodes.table_element_footer),
-        }, [generalNote]);
-        tr.insert(pos, tableElementFooter);
+    if (!dispatch) {
+        return true;
     }
-    if (dispatch && pos) {
-        const selection = createSelection(state.schema.nodes.paragraph, pos, tr.doc);
-        view === null || view === void 0 ? void 0 : view.focus();
-        dispatch(tr.setSelection(selection).scrollIntoView());
+    return insertInlineFootnote(state, dispatch);
+};
+export const insertGeneralTableFootnote = (element, state, dispatch) => {
+    const existing = findChildrenByType(element[0], schema.nodes.general_table_footnote);
+    if (existing.length) {
+        return false;
+    }
+    if (!dispatch) {
+        return true;
     }
+    const tr = state.tr;
+    const footer = insertTableElementFooter(tr, element);
+    const pos = footer.pos + 1;
+    const node = schema.nodes.general_table_footnote.create({}, [
+        schema.nodes.paragraph.create(),
+    ]);
+    tr.insert(pos, node);
+    const selection = TextSelection.create(tr.doc, pos + 1);
+    tr.setSelection(selection).scrollIntoView();
+    dispatch(tr);
 };
 export const insertFigure = (file, state, dispatch) => {
     const position = findBlockInsertPosition(state);
@@ -380,81 +369,99 @@ export const insertInlineEquation = (state, dispatch) => {
     }
     return true;
 };
-export const createFootnote = (state, kind) => {
-    return schema.nodes.footnote.createAndFill({
-        id: generateNodeID(schema.nodes.footnote),
-        kind,
-    });
+export const insertTableElementFooter = (tr, table) => {
+    const footer = findChildrenByType(table[0], schema.nodes.table_element_footer)[0];
+    if (footer) {
+        const pos = tr.mapping.map(table[1] + footer.pos + 1);
+        if (isDeleted(footer.node)) {
+            reinstateNode(tr, footer.node, pos);
+        }
+        return {
+            node: footer.node,
+            pos,
+        };
+    }
+    const pos = tr.mapping.map(table[1] + table[0].nodeSize - 2);
+    const node = schema.nodes.table_element_footer.create();
+    tr.insert(pos, node);
+    return {
+        node,
+        pos,
+    };
 };
-export const insertFootnote = (state, tr, footnote) => {
-    const footnotesSection = findChildrenByType(tr.doc, schema.nodes.footnotes_section)[0];
-    let selectionPos = 0;
-    if (!footnotesSection) {
-        const section = state.schema.nodes.footnotes_section.create({}, [
-            state.schema.nodes.section_title.create({}, state.schema.text('Footnotes')),
-            state.schema.nodes.footnotes_element.create({}, footnote),
-        ]);
-        const backmatter = findChildrenByType(tr.doc, schema.nodes.backmatter)[0];
-        const sectionPos = backmatter.pos + 1;
-        tr.insert(sectionPos, section);
-        let footnotePos = 0;
-        section.descendants((n, pos) => {
-            if (isFootnoteNode(n)) {
-                footnotePos = pos;
-                n.descendants((childNode, childPos) => {
-                    if (isParagraphNode(childNode)) {
-                        footnotePos += childPos;
-                    }
-                });
-            }
-        });
-        selectionPos = sectionPos + footnotePos;
+export const insertFootnotesElement = (tr, container) => {
+    let pos;
+    if (isTableElementNode(container[0])) {
+        const footer = insertTableElementFooter(tr, container);
+        pos = footer.pos + footer.node.nodeSize - 1;
     }
     else {
-        const footnoteElement = findChildrenByType(footnotesSection.node, schema.nodes.footnotes_element).pop();
-        if (footnoteElement) {
-            if (isDeleted(footnoteElement.node)) {
-                const footnoteElementPos = footnotesSection.pos + footnoteElement.pos + 1;
-                undoFootnoteDelete(tr, footnoteElement, footnoteElementPos);
-                const updatedAttrs = Object.assign(Object.assign({}, footnoteElement.node.attrs), { dataTracked: null });
-                tr.setNodeMarkup(footnoteElementPos, undefined, updatedAttrs, footnoteElement.node.marks);
-            }
-            const pos = footnotesSection.pos +
-                footnoteElement.pos +
-                footnoteElement.node.nodeSize -
-                1;
-            tr.insert(pos, footnote);
-            selectionPos = pos + 2;
+        const section = insertFootnotesSection(tr);
+        pos = section.pos + section.node.nodeSize - 1;
+    }
+    const node = schema.nodes.footnotes_element.create();
+    tr.insert(pos, node);
+    return [node, pos];
+};
+export const insertInlineFootnote = (state, dispatch) => {
+    const pos = state.selection.to;
+    const tr = state.tr;
+    const container = findFootnotesContainerNode(state.doc, pos);
+    const fn = getFootnotesElementState(state, container.node.attrs.id);
+    const hasUnusedFootnotes = fn && fn.unusedFootnoteIDs.size > 0;
+    const footnote = !hasUnusedFootnotes && createFootnote();
+    const node = schema.nodes.inline_footnote.create({
+        rids: footnote ? [footnote.attrs.id] : [],
+    });
+    tr.insert(pos, node);
+    if (footnote) {
+        let element;
+        if (fn) {
+            element = [fn.element[0], tr.mapping.map(fn.element[1])];
         }
         else {
-            const footnoteElement = schema.nodes.footnotes_element.create({}, footnote);
-            const pos = footnotesSection.pos + footnotesSection.node.nodeSize - 1;
-            tr.insert(pos, footnoteElement);
-            selectionPos = pos + 2;
+            element = insertFootnotesElement(tr, [container.node, container.pos]);
+        }
+        if (isDeleted(element[0])) {
+            reinstateNode(tr, element[0], element[1]);
         }
+        const fnPos = element[1] + element[0].nodeSize - 1;
+        tr.insert(fnPos, footnote);
+        const selection = TextSelection.create(tr.doc, fnPos + 2);
+        tr.setSelection(selection).scrollIntoView();
     }
-    if (selectionPos) {
-        const selection = TextSelection.near(tr.doc.resolve(selectionPos));
+    else {
+        const selection = NodeSelection.create(tr.doc, pos);
         tr.setSelection(selection).scrollIntoView();
     }
-    return tr;
+    if (dispatch) {
+        dispatch(tr);
+    }
+    return true;
 };
-export const insertInlineFootnote = (kind) => (state, dispatch) => {
-    const fnState = footnotesKey.getState(state);
-    const hasUnusedNodes = fnState && fnState.unusedFootnotes.size > 0;
-    const footnote = !hasUnusedNodes
-        ? createFootnote(state, kind)
-        : null;
-    const insertedAt = state.selection.to;
-    let tr = state.tr;
-    const node = state.schema.nodes.inline_footnote.create({
-        rids: footnote ? [footnote.attrs.id] : [],
-    });
-    tr.insert(insertedAt, node);
-    if (footnote) {
-        tr = insertFootnote(state, tr, footnote);
+const reinstateNode = (tr, node, pos) => {
+    const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: null });
+    tr.setNodeMarkup(pos, null, attrs);
+};
+export const insertBoxElement = (state, dispatch) => {
+    const selection = state.selection;
+    const isBody = hasParentNodeOfType(schema.nodes.body)(selection);
+    const isBoxText = hasParentNodeOfType(schema.nodes.box_element)(selection);
+    if (!isBody || isBoxText) {
+        return false;
     }
-    if (dispatch) {
+    const position = findBlockInsertPosition(state);
+    const paragraph = schema.nodes.paragraph.create({});
+    const section = schema.nodes.section.createAndFill({}, [
+        schema.nodes.section_title.create(),
+        paragraph,
+    ]);
+    const node = schema.nodes.box_element.createAndFill({}, [
+        schema.nodes.figcaption.create({}, [schema.nodes.caption_title.create()]),
+        section,
+    ]);
+    if (position && dispatch) {
+        const tr = state.tr.insert(position, node);
         dispatch(tr);
     }
     return true;
@@ -930,6 +937,11 @@ export const addInlineComment = (state, dispatch) => {
     }
     let from = selection.from;
     let to = selection.to;
+    if (from === to) {
+        const result = findWordBoundaries(state, from);
+        from = result.from;
+        to = result.to;
+    }
     const props = getEditorProps(state);
     const contribution = buildContribution(props.userID);
     const attrs = {
@@ -937,7 +949,7 @@ export const addInlineComment = (state, dispatch) => {
         contents: '',
         target: node.attrs.id,
         contributions: [contribution],
-        originalText: selectedText(),
+        originalText: selectedText() || state.doc.textBetween(from, to),
         selector: {
             from,
             to,
@@ -948,11 +960,6 @@ export const addInlineComment = (state, dispatch) => {
     if (comments) {
         const pos = comments.pos + 1;
         const tr = state.tr.insert(pos, comment);
-        if (from === to) {
-            const result = findWordBoundaries(state, from);
-            from = result.from;
-            to = result.to;
-        }
         const start = schema.nodes.highlight_marker.create({
             id: comment.attrs.id,
             tid: node.attrs.id,
@@ -974,102 +981,6 @@ export const addInlineComment = (state, dispatch) => {
     }
     return false;
 };
-export const insertTableFootnote = (tableElementNode, position, view, inlineFootnote) => {
-    const { state, dispatch } = view;
-    const tr = state.tr;
-    const footnote = schema.nodes.footnote.createAndFill({
-        id: generateNodeID(schema.nodes.footnote),
-        kind: 'footnote',
-    });
-    const insertedAt = state.selection.to;
-    let footnoteIndex;
-    if (inlineFootnote) {
-        const contents = inlineFootnote.node.attrs.contents.split(',').map(Number);
-        footnoteIndex = Math.max(...contents) + 1;
-        tr.setNodeMarkup(inlineFootnote.pos, undefined, {
-            rids: [...inlineFootnote.node.attrs.rids, footnote.attrs.id],
-            contents: inlineFootnote.node.attrs.contents + ',' + footnoteIndex,
-        });
-    }
-    else {
-        const inlineFootnotes = findChildrenByType(tableElementNode, schema.nodes.inline_footnote);
-        footnoteIndex =
-            inlineFootnotes.filter(({ pos }) => position + pos <= insertedAt).length +
-                1;
-        const inlineFootnoteNode = state.schema.nodes.inline_footnote.create({
-            rids: [footnote.attrs.id],
-            contents: footnoteIndex === -1 ? inlineFootnotes.length : footnoteIndex,
-        });
-        tr.insert(insertedAt, inlineFootnoteNode);
-    }
-    let insertionPos = position;
-    const footnotesElement = findChildrenByType(tableElementNode, schema.nodes.footnotes_element).pop();
-    if (footnotesElement) {
-        if (isDeleted(footnotesElement.node)) {
-            const footnotesElementPos = tr.mapping.map(position + footnotesElement.pos + 1);
-            undoFootnoteDelete(tr, footnotesElement, footnotesElementPos);
-        }
-        const footnotePos = getNewFootnotePos(footnotesElement, footnoteIndex);
-        insertionPos = tr.mapping.map(position + footnotePos);
-        tr.insert(insertionPos, footnote);
-    }
-    else {
-        const footnoteElement = state.schema.nodes.footnotes_element.create({}, footnote);
-        const tableElementFooter = findChildrenByType(tableElementNode, schema.nodes.table_element_footer)[0];
-        if (tableElementFooter) {
-            if (isDeleted(tableElementFooter.node)) {
-                const tableElementFooterPos = tr.mapping.map(position + tableElementFooter.pos + 1);
-                undoFootnoteDelete(tr, tableElementFooter, tableElementFooterPos);
-            }
-            const pos = tableElementFooter.pos;
-            insertionPos = position + pos + tableElementFooter.node.nodeSize;
-            tr.insert(tr.mapping.map(insertionPos), footnoteElement);
-        }
-        else {
-            const tableElementFooter = schema.nodes.table_element_footer.create({
-                id: generateNodeID(schema.nodes.table_element_footer),
-            }, [footnoteElement]);
-            const tableColGroup = findChildrenByType(tableElementNode, schema.nodes.table_colgroup)[0];
-            const table = findChildrenByType(tableElementNode, schema.nodes.table)[0];
-            if (tableColGroup) {
-                insertionPos =
-                    position + tableColGroup.pos + tableColGroup.node.nodeSize;
-                tr.insert(tr.mapping.map(insertionPos), tableElementFooter);
-            }
-            else {
-                insertionPos = position + table.pos + table.node.nodeSize;
-                tr.insert(tr.mapping.map(insertionPos), tableElementFooter);
-            }
-        }
-    }
-    dispatch(tr);
-    const textSelection = TextSelection.near(view.state.tr.doc.resolve(insertionPos + 1));
-    view.focus();
-    dispatch(view.state.tr.setSelection(textSelection).scrollIntoView());
-};
-export const insertBoxElement = (state, dispatch) => {
-    const selection = state.selection;
-    const isBody = hasParentNodeOfType(schema.nodes.body)(selection);
-    const isBoxText = hasParentNodeOfType(schema.nodes.box_element)(selection);
-    if (!isBody || isBoxText) {
-        return false;
-    }
-    const position = findBlockInsertPosition(state);
-    const paragraph = schema.nodes.paragraph.create({});
-    const section = schema.nodes.section.createAndFill({}, [
-        schema.nodes.section_title.create(),
-        paragraph,
-    ]);
-    const BoxElementNode = schema.nodes.box_element.createAndFill({}, [
-        schema.nodes.figcaption.create({}, [schema.nodes.caption_title.create()]),
-        section,
-    ]);
-    if (position && dispatch) {
-        const tr = state.tr.insert(position, BoxElementNode);
-        dispatch(tr);
-    }
-    return true;
-};
 export const addRows = (direction) => (state, dispatch) => {
     if (dispatch) {
         const { tr } = state;

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

@@ -1,6 +1,6 @@
 import { Category, Dialog } from '@manuscripts/style-guide';
 import React, { useState } from 'react';
-export const DeleteFootnoteDialog = ({ footnoteType, footnoteMessage, handleDelete, }) => {
+export const DeleteFootnoteDialog = ({ header, message, handleDelete, }) => {
     const [isOpen, setOpen] = useState(true);
     return (React.createElement(Dialog, { className: "delete-footnote-dialog", isOpen: isOpen, actions: {
             primary: {
@@ -14,5 +14,5 @@ export const DeleteFootnoteDialog = ({ footnoteType, footnoteMessage, handleDele
                 action: () => setOpen(false),
                 title: 'Cancel',
             },
-        }, category: Category.confirmation, header: `Delete ${footnoteType}`, message: `${footnoteMessage}` }));
+        }, category: Category.confirmation, header: header, message: message }));
 };

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

@@ -47,12 +47,12 @@ const AddNewFootnote = styled(ButtonGroup) `
     }
   }
 `;
-export const FootnotesSelector = ({ notes, inlineFootnote, onAdd, onInsert, onCancel, addNewLabel }) => {
+export const FootnotesSelector = ({ footnotes, inlineFootnote, labels, onAdd, onInsert, onCancel, }) => {
     let selectedNotesMap;
     if (inlineFootnote) {
         const rids = inlineFootnote.attrs.rids;
-        const selectedNotes = notes.filter(({ node }) => rids.includes(node.attrs.id));
-        selectedNotesMap = new Map(selectedNotes.map(({ node }) => [node.attrs.id, node]));
+        const selectedNotes = footnotes.filter((node) => rids.includes(node.attrs.id));
+        selectedNotesMap = new Map(selectedNotes.map((node) => [node.attrs.id, node]));
     }
     const [selections, setSelections] = useState(new Map(selectedNotesMap));
     const toggleSelection = (item) => {
@@ -70,43 +70,42 @@ export const FootnotesSelector = ({ notes, inlineFootnote, onAdd, onInsert, onCa
         return selections.has(item.attrs.id);
     };
     const handleClick = () => {
-        return onInsert(notes.filter(({ node }) => selections.has(node.attrs.id)));
+        return onInsert(footnotes.filter((node) => selections.has(node.attrs.id)));
     };
     return (React.createElement(Container, null,
         React.createElement(NotesContainer, null,
-            React.createElement(FootnotesList, { notes: notes, inlineFootnote: inlineFootnote, isSelected: isSelected, onSelect: toggleSelection })),
+            React.createElement(FootnotesList, { footnotes: footnotes, inlineFootnote: inlineFootnote, labels: labels, isSelected: isSelected, onSelect: toggleSelection })),
         React.createElement(Actions, null,
             React.createElement(AddNewFootnote, null,
                 React.createElement(IconTextButton, { onClick: onAdd },
                     React.createElement(AddNewIcon, null),
-                    addNewLabel || 'Add new')),
+                    "Add new")),
             React.createElement(ButtonGroup, null,
                 React.createElement(SecondaryButton, { onClick: onCancel }, "Cancel"),
                 React.createElement(PrimaryButton, { onClick: handleClick, disabled: selections.size === 0 && !inlineFootnote }, inlineFootnote ? 'Update' : 'Insert')))));
 };
-const FootnotesList = ({ notes, isSelected, onSelect, inlineFootnote }) => {
+const FootnotesList = ({ footnotes, inlineFootnote, labels, isSelected, onSelect }) => {
+    const rids = inlineFootnote === null || inlineFootnote === void 0 ? void 0 : inlineFootnote.attrs.rids;
     const selectedNotes = [];
     const remainingNotes = [];
-    notes.forEach((note) => {
-        const isNoteSelected = inlineFootnote && inlineFootnote.attrs.rids.includes(note.node.attrs.id);
+    footnotes.forEach((footnote) => {
+        const isNoteSelected = rids === null || rids === void 0 ? void 0 : rids.includes(footnote.attrs.id);
         if (isNoteSelected) {
-            selectedNotes.push(note);
+            selectedNotes.push(footnote);
         }
         else {
-            remainingNotes.push(note);
+            remainingNotes.push(footnote);
         }
     });
     return (React.createElement(NotesListContainer, null,
-        selectedNotes.map((note) => (React.createElement(FootnoteItem, { key: note.node.attrs.id, note: note, isSelected: isSelected, onSelect: onSelect }))),
+        selectedNotes.map((footnote) => (React.createElement(FootnoteItem, { key: footnote.attrs.id, footnote: footnote, label: labels.get(footnote.attrs.id), isSelected: isSelected, onSelect: onSelect }))),
         selectedNotes.length > 0 && remainingNotes.length > 0 && React.createElement(Separator, null),
-        remainingNotes.map((note) => (React.createElement(FootnoteItem, { key: note.node.attrs.id, note: note, isSelected: isSelected, onSelect: onSelect })))));
+        remainingNotes.map((footnote) => (React.createElement(FootnoteItem, { key: footnote.attrs.id, footnote: footnote, label: labels.get(footnote.attrs.id), isSelected: isSelected, onSelect: onSelect })))));
 };
-const FootnoteItem = ({ note, isSelected, onSelect }) => {
-    var _a;
-    const { node, index } = note;
-    return (React.createElement(FootnoteItemContainer, { onClick: () => onSelect(node) },
-        React.createElement(StatusIcon, null, isSelected(node) ? (React.createElement(AddedIcon, { "data-cy": 'plus-icon-ok' })) : (React.createElement(AddIcon, { "data-cy": 'plus-icon' }))),
-        React.createElement(NoteText, null, (index ? index + '. ' : '') + ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.textContent))));
+const FootnoteItem = ({ footnote, label, isSelected, onSelect }) => {
+    return (React.createElement(FootnoteItemContainer, { onClick: () => onSelect(footnote) },
+        React.createElement(StatusIcon, null, isSelected(footnote) ? (React.createElement(AddedIcon, { "data-cy": 'plus-icon-ok' })) : (React.createElement(AddIcon, { "data-cy": 'plus-icon' }))),
+        React.createElement(NoteText, null, (label ? label + '. ' : '') + footnote.textContent)));
 };
 const Separator = styled.div `
   height: 0;

package/dist/es/configs/ManuscriptsEditor.js

@@ -20,6 +20,7 @@ import { EditorView } from 'prosemirror-view';
 import { clipboardParser } from '../clipboard';
 import { handleScrollToBibliographyItem } from '../lib/helpers';
 import { handlePaste, transformPasted } from '../lib/paste';
+import { INIT_META } from '../lib/plugins';
 import plugins from './editor-plugins';
 import views from './editor-views';
 export const createEditorState = (props) => EditorState.create({
@@ -51,7 +52,7 @@ export const createEditorView = (props, root, state, dispatch) => {
             }
         },
     });
-    const tr = view.state.tr.setMeta('INIT', true);
+    const tr = view.state.tr.setMeta(INIT_META, true);
     const nextState = view.state.apply(tr);
     view.updateState(nextState);
     return view;

package/dist/es/configs/editor-plugins.js

@@ -36,7 +36,6 @@ import section_title from '../plugins/section_title';
 import section_category from '../plugins/section-category';
 import sections from '../plugins/sections';
 import selected_suggestion from '../plugins/selected-suggestion';
-import table_footnote from '../plugins/table-footnote';
 import table_editing_fix from '../plugins/tables-cursor-fix';
 import toc from '../plugins/toc';
 import rules from '../rules';
@@ -68,7 +67,6 @@ export default (props) => {
         tableEditing(),
         selected_suggestion(),
         footnotes(props),
-        table_footnote(),
         editorProps(props),
         doi(),
         section_category(props),

package/dist/es/configs/editor-views.js

@@ -26,8 +26,9 @@ import equation from '../views/equation_editable';
 import equationElement from '../views/equation_element_editable';
 import figure from '../views/figure_editable';
 import figureElement from '../views/figure_element_editable';
-import footnote from '../views/footnote_editable';
+import footnote from '../views/footnote';
 import footnotesElement from '../views/footnotes_element';
+import generalTableFootnote from '../views/general_table_footnote';
 import inlineEquation from '../views/inline_equation_editable';
 import inlineFootnote from '../views/inline_footnote_editable';
 import keyword from '../views/keyword';
@@ -44,7 +45,7 @@ import sectionLabel from '../views/section_label';
 import sectionTitle from '../views/section_title_editable';
 import tableCell from '../views/table_cell';
 import tableElement from '../views/table_element_editable';
-import tableElementFooter from '../views/table_element_footer_editable';
+import tableElementFooter from '../views/table_element_footer';
 import title from '../views/title_editable';
 import tocElement from '../views/toc_element_editable';
 export default (props, dispatch) => {
@@ -63,6 +64,7 @@ export default (props, dispatch) => {
         figure_element: figureElement(props, dispatch),
         footnote: footnote(props),
         footnotes_element: footnotesElement(props),
+        general_table_footnote: generalTableFootnote(props, dispatch),
         inline_equation: inlineEquation(props),
         inline_footnote: inlineFootnote(props, dispatch),
         keyword: keyword(props, dispatch),

package/dist/es/icons.js

@@ -0,0 +1,5 @@
+import { AlertIcon, DeleteIcon } from '@manuscripts/style-guide';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+export const alertIcon = renderToStaticMarkup(createElement(AlertIcon));
+export const deleteIcon = renderToStaticMarkup(createElement(DeleteIcon));

package/dist/es/index.js

@@ -25,6 +25,7 @@ export { PopperManager } from './lib/popper';
 export * from './toolbar';
 export * from './lib/comments';
 export * from './lib/files';
+export * from './lib/footnotes';
 export * from './lib/doc';
 export * from './plugins/comments';
 export { selectedSuggestionKey } from './plugins/selected-suggestion';

package/dist/es/lib/comments.js

@@ -1,4 +1,7 @@
 export const isNodeComment = (c) => !c.range;
+export const isReply = (comment) => {
+    return comment.node.attrs.target.includes('MPCommentAnnotation');
+};
 export const getCommentKey = (comment, range, target) => {
     if (!range) {
         return target.attrs.id;