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

package/dist/es/lib/context-menu.js

@@ -14,14 +14,10 @@
  * limitations under the License.
  */
 import { getListType, isInBibliographySection, isSectionTitleNode, nodeNames, schema, } from '@manuscripts/transform';
-import { findChildrenByType, hasParentNodeOfType } from 'prosemirror-utils';
-import { addNodeComment, createBlock, findPosBeforeFirstSubsection, insertGeneralFootnote, insertTableFootnote, } from '../commands';
-import { FootnotesSelector } from '../components/views/FootnotesSelector';
-import ReactSubView from '../views/ReactSubView';
-import { buildTableFootnoteLabels } from './footnotes';
+import { findChildrenByType } from 'prosemirror-utils';
+import { addNodeComment, createBlock, findPosBeforeFirstSubsection, insertGeneralTableFootnote, insertInlineTableFootnote, } from '../commands';
 import { PopperManager } from './popper';
-import { isDeleted } from './track-changes-utils';
-import { getChildOfType, isChildOfNodeTypes, isSelectionInNode } from './utils';
+import { isChildOfNodeTypes, isSelectionInNode } from './utils';
 const popper = new PopperManager();
 const readonlyTypes = [schema.nodes.keywords, schema.nodes.bibliography_element];
 const isBoxElementSectionTitle = ($pos, node) => isSectionTitleNode(node) &&
@@ -39,7 +35,7 @@ const hasAny = (set, ...items) => {
 };
 export const contextMenuBtnClass = 'btn-context-menu';
 export class ContextMenu {
-    constructor(node, view, getPos, actions = {}, props) {
+    constructor(node, view, getPos, actions = {}) {
         this.showAddMenu = (target, after) => {
             const menu = document.createElement('div');
             menu.className = 'menu';
@@ -143,7 +139,6 @@ export class ContextMenu {
             this.addPopperEventListeners();
         };
         this.showEditMenu = (target) => {
-            var _a;
             const menu = document.createElement('div');
             menu.className = 'menu';
             const $pos = this.resolvePos();
@@ -178,89 +173,23 @@ export class ContextMenu {
                 }));
             }
             if (type === schema.nodes.table_element) {
-                const isInTable = hasParentNodeOfType(schema.nodes.table)(this.view.state.selection);
-                const tableElementFooter = findChildrenByType(this.node, schema.nodes.table_element_footer);
-                let isDeletedInsert = false;
-                const hasGeneralNote = tableElementFooter.length &&
-                    getChildOfType(tableElementFooter[0].node, schema.nodes.general_table_footnote, true);
-                if (hasGeneralNote) {
-                    const generalFootnote = (_a = tableElementFooter[0]) === null || _a === void 0 ? void 0 : _a.node.firstChild;
-                    if (generalFootnote) {
-                        isDeletedInsert = isDeleted(generalFootnote);
-                    }
+                const items = [];
+                const isInsideNode = isSelectionInNode(this.view.state, this.node);
+                if (isInsideNode && insertInlineTableFootnote(this.view.state)) {
+                    const item = this.createMenuItem('Add Reference Note', () => {
+                        insertInlineTableFootnote(this.view.state, this.view.dispatch);
+                    });
+                    items.push(item);
                 }
-                if (!hasGeneralNote || isDeletedInsert) {
-                    menu.appendChild(this.createMenuSection((section) => {
-                        section.appendChild(this.createMenuItem('Add General Note', () => {
-                            insertGeneralFootnote(this.node, this.getPos(), this.view, tableElementFooter);
-                        }));
-                    }));
+                const pos = this.getPos();
+                if (insertGeneralTableFootnote([this.node, pos], this.view.state)) {
+                    const item = this.createMenuItem('Add General Note', () => {
+                        insertGeneralTableFootnote([this.node, pos], this.view.state, this.view.dispatch);
+                    });
+                    items.push(item);
                 }
-                if (isInTable) {
-                    const isInsideNode = isSelectionInNode(this.view.state, this.node);
-                    menu.appendChild(this.createMenuSection((section) => {
-                        section.appendChild(this.createMenuItem('Add Reference Note', () => {
-                            var _a;
-                            const footnotesElementWithPos = findChildrenByType(this.node, schema.nodes.footnotes_element).pop();
-                            if (!footnotesElementWithPos ||
-                                !(footnotesElementWithPos === null || footnotesElementWithPos === void 0 ? void 0 : footnotesElementWithPos.node.content.childCount) ||
-                                isDeleted(footnotesElementWithPos.node)) {
-                                insertTableFootnote(this.node, this.getPos(), this.view);
-                            }
-                            else {
-                                const tablesFootnoteLabels = buildTableFootnoteLabels(this.node);
-                                const footnotesWithPos = findChildrenByType(footnotesElementWithPos.node, schema.nodes.footnote);
-                                const footnotes = footnotesWithPos
-                                    .filter(({ node }) => !isDeleted(node))
-                                    .map(({ node }) => ({
-                                    node: node,
-                                    index: tablesFootnoteLabels.get(node.attrs.id),
-                                }));
-                                const targetDom = this.view.domAtPos(this.view.state.selection.from);
-                                const targetNode = targetDom.node.nodeType === Node.TEXT_NODE
-                                    ? targetDom.node.parentNode
-                                    : targetDom.node;
-                                if (targetNode instanceof Element && this.props) {
-                                    const popperContainer = ReactSubView(Object.assign(Object.assign({}, this.props), { dispatch: this.view.dispatch }), FootnotesSelector, {
-                                        notes: footnotes,
-                                        onAdd: () => {
-                                            var _a;
-                                            insertTableFootnote(this.node, this.getPos(), this.view);
-                                            (_a = this.props) === null || _a === void 0 ? void 0 : _a.popper.destroy();
-                                        },
-                                        onInsert: (notes) => {
-                                            var _a;
-                                            const insertedAt = this.view.state.selection.to;
-                                            let inlineFootnoteIndex = 1;
-                                            this.view.state.doc
-                                                .slice(this.getPos(), insertedAt)
-                                                .content.descendants((node) => {
-                                                if (node.type === schema.nodes.inline_footnote) {
-                                                    inlineFootnoteIndex++;
-                                                    return false;
-                                                }
-                                            });
-                                            const node = this.view.state.schema.nodes.inline_footnote.create({
-                                                rids: notes.map(({ node }) => node.attrs.id),
-                                                contents: notes
-                                                    .map(({ index }) => index ? index : inlineFootnoteIndex)
-                                                    .join(),
-                                            });
-                                            const tr = this.view.state.tr;
-                                            tr.insert(insertedAt, node);
-                                            this.view.dispatch(tr);
-                                            (_a = this.props) === null || _a === void 0 ? void 0 : _a.popper.destroy();
-                                        },
-                                        onCancel: () => {
-                                            var _a;
-                                            (_a = this.props) === null || _a === void 0 ? void 0 : _a.popper.destroy();
-                                        },
-                                    }, this.node, this.getPos, this.view, 'footnote-editor');
-                                    (_a = this.props) === null || _a === void 0 ? void 0 : _a.popper.show(targetNode, popperContainer, 'bottom-end');
-                                }
-                            }
-                        }, !isInsideNode));
-                    }));
+                if (items.length) {
+                    menu.append(this.createMenuSection((e) => e.append(...items)));
                 }
             }
             if (!readonlyTypes.includes(type) &&
@@ -279,19 +208,14 @@ export class ContextMenu {
             popper.show(target, menu, 'right', true);
             this.addPopperEventListeners();
         };
-        this.createMenuItem = (contents, handler, isDisabled = false) => {
+        this.createMenuItem = (contents, handler) => {
             const item = document.createElement('div');
             item.className = 'menu-item';
             item.textContent = contents;
-            if (isDisabled) {
-                item.setAttribute('disabled', 'true');
-            }
-            else {
-                item.addEventListener('mousedown', (event) => {
-                    event.preventDefault();
-                    handler(event);
-                });
-            }
+            item.addEventListener('mousedown', (event) => {
+                event.preventDefault();
+                handler(event);
+            });
             return item;
         };
         this.createMenuSection = (createMenuItems) => {
@@ -397,6 +321,5 @@ export class ContextMenu {
         this.view = view;
         this.getPos = getPos;
         this.actions = actions;
-        this.props = props;
     }
 }

package/dist/es/lib/doc.js

@@ -1,5 +1,5 @@
 import { schema, } from '@manuscripts/transform';
-import { findChildrenByType } from 'prosemirror-utils';
+import { findChildren, findChildrenByType } from 'prosemirror-utils';
 export const insertSupplementsNode = (tr) => {
     const doc = tr.doc;
     const supplements = findChildrenByType(doc, schema.nodes.supplements)[0];
@@ -8,10 +8,27 @@ export const insertSupplementsNode = (tr) => {
     }
     const abstracts = findAbstractsNode(doc);
     const pos = abstracts.pos - 1;
-    const supplementsNode = schema.nodes.supplements.createAndFill();
-    tr.insert(pos, supplementsNode);
+    const node = schema.nodes.supplements.createAndFill();
+    tr.insert(pos, node);
     return {
-        node: supplementsNode,
+        node,
+        pos,
+    };
+};
+export const insertFootnotesSection = (tr) => {
+    const doc = tr.doc;
+    const section = findChildrenByType(doc, schema.nodes.footnotes_section)[0];
+    if (section) {
+        return section;
+    }
+    const backmatter = findBackmatter(doc);
+    const pos = backmatter.pos + 1;
+    const node = schema.nodes.footnotes_section.create({}, [
+        schema.nodes.section_title.create({}, schema.text('Footnotes')),
+    ]);
+    tr.insert(pos, node);
+    return {
+        node,
         pos,
     };
 };
@@ -41,3 +58,7 @@ export const findGraphicalAbstractFigureElement = (doc) => {
         pos: ga.pos + element.pos + 1,
     };
 };
+export const findNodeByID = (doc, id) => {
+    const children = findChildren(doc, (n) => n.attrs.id === id);
+    return children[0];
+};

package/dist/es/lib/footnotes.js

@@ -13,127 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { skipTracking } from '@manuscripts/track-changes-plugin';
-import { isFootnoteNode, schema, } from '@manuscripts/transform';
-import { Fragment } from 'prosemirror-model';
-import { findChildren, findChildrenByType, findParentNodeClosestToPos, } from 'prosemirror-utils';
-export const findTableInlineFootnoteIds = ($pos) => {
-    var _a;
-    const tableElement = (_a = findParentNodeClosestToPos($pos, (node) => node.type === schema.nodes.table_element)) === null || _a === void 0 ? void 0 : _a.node;
-    return new Set(tableElement
-        ? findChildren(tableElement, (node) => node.type === schema.nodes.inline_footnote)
-            .map(({ node }) => node.attrs.rids)
-            .flat()
-        : []);
-};
-export const getNewFootnotePos = (footnotesElement, footnoteIndex) => {
-    let newFootnotePos = footnotesElement.pos + footnotesElement.node.nodeSize - 1;
-    footnotesElement.node.descendants((node, pos, parent, index) => {
-        if (isFootnoteNode(node)) {
-            if (footnoteIndex === ++index) {
-                newFootnotePos = footnotesElement.pos + pos + (index === 1 ? 2 : 1);
-            }
-        }
-    });
-    return newFootnotePos;
-};
-export const buildTableFootnoteLabels = (node) => {
-    const labels = new Map(findChildrenByType(node, schema.nodes.footnote).map((node) => [
-        node.node.attrs.id,
-        undefined,
-    ]));
-    let index = 0;
-    findChildrenByType(node, schema.nodes.inline_footnote)
-        .map(({ node }) => node.attrs.rids)
-        .flat()
-        .map((rid) => {
-        if (!labels.get(rid)) {
-            labels.set(rid, String(++index));
-        }
+import { generateNodeID, schema, } from '@manuscripts/transform';
+import { findParentNodeOfType, findParentNodeOfTypeClosestToPos, } from 'prosemirror-utils';
+import { footnotesKey } from '../plugins/footnotes';
+export const findFootnotesContainerNode = (doc, pos) => {
+    const $pos = doc.resolve(pos);
+    return (findParentNodeOfTypeClosestToPos($pos, schema.nodes.table_element) || {
+        node: doc,
+        pos: 0,
     });
-    return labels;
 };
-export const orderTableFootnotes = (tr, footnotesElementWithPos, position) => {
-    const tablesFootnoteLabels = buildTableFootnoteLabels(tr.doc.nodeAt(tr.mapping.map(position)));
-    const footnotes = findChildrenByType(footnotesElementWithPos.node, schema.nodes.footnote).map((nodeWithPos) => ({
-        node: nodeWithPos.node,
-        index: tablesFootnoteLabels.get(nodeWithPos.node.attrs.id),
-    }));
-    const orderedFootnotes = [...footnotes]
-        .sort((a, b) => {
-        if (a.index !== undefined && b.index !== undefined) {
-            return Number.parseInt(a.index) - Number.parseInt(b.index);
-        }
-        else {
-            return a.index === undefined ? 1 : -1;
-        }
-    })
-        .map(({ node }) => node);
-    const { node: footnotesElement, pos } = footnotesElementWithPos;
-    const footnoteElementPos = position + pos + 1;
-    if (orderedFootnotes.length === 0) {
+export const findParentFootnote = findParentNodeOfType([
+    schema.nodes.footnote,
+    schema.nodes.general_table_footnote,
+]);
+export const getFootnotesElementState = (state, id) => {
+    const fns = footnotesKey.getState(state);
+    if (!fns) {
         return;
     }
-    const oldDataTracked = footnotesElement.attrs.dataTracked;
-    skipTracking(tr.replaceWith(tr.mapping.map(footnoteElementPos), tr.mapping.map(footnoteElementPos + footnotesElement.nodeSize), Fragment.fromArray(orderedFootnotes)));
-    if (oldDataTracked) {
-        tr.setNodeMarkup(footnoteElementPos, schema.nodes.footnotes_element, Object.assign(Object.assign({}, footnotesElement.attrs), { dataTracked: oldDataTracked }));
+    const elementID = fns.footnotesElementIDs.get(id);
+    if (!elementID) {
+        return;
     }
+    return fns.footnotesElements.get(elementID);
 };
-export const updateTableInlineFootnoteLabels = (tr, table) => {
-    const labels = buildTableFootnoteLabels(table.node);
-    findChildrenByType(table.node, schema.nodes.inline_footnote).map(({ node, pos }) => {
-        const contents = node.attrs.rids
-            .map((rid) => labels.get(rid))
-            .join(',');
-        if (contents !== node.attrs.contents &&
-            tr.doc.nodeAt(tr.mapping.map(table.pos + pos + 1))) {
-            tr.setNodeMarkup(tr.mapping.map(table.pos + pos + 1), undefined, Object.assign(Object.assign({}, node.attrs), { rids: node.attrs.rids, contents }));
-        }
-    });
-    return tr;
+export const getFootnoteLabel = (state, footnote) => {
+    const id = footnote.attrs.id;
+    const fns = getFootnotesElementState(state, id);
+    return (fns === null || fns === void 0 ? void 0 : fns.labels.get(id)) || '';
 };
-export const getInlineFootnotes = (id, targetNode) => {
-    const inlineFootnotes = [];
-    targetNode.descendants((node, pos) => {
-        var _a;
-        if (node.type === schema.nodes.inline_footnote) {
-            const footnote = node;
-            if ((_a = footnote.attrs.rids) === null || _a === void 0 ? void 0 : _a.includes(id)) {
-                inlineFootnotes.push({ node: footnote, pos });
-            }
-        }
-    });
-    return inlineFootnotes;
+export const createFootnote = () => {
+    return schema.nodes.footnote.createAndFill({
+        id: generateNodeID(schema.nodes.footnote),
+        kind: 'footnote',
+    }, [schema.nodes.paragraph.create({})]);
 };
-export function getAlphaOrderIndices(index) {
-    const unicodeInterval = [97, 123];
-    const places = unicodeInterval[1] - unicodeInterval[0];
-    function getClassCount(n, order) {
-        return n * Math.pow(places, order - 1);
-    }
-    let indices = null;
-    for (;;) {
-        let current = index;
-        let position = 1;
-        while (current >= places) {
-            current = current / places;
-            position++;
-        }
-        const newIndex = Math.floor(current);
-        indices = indices ? indices : new Array(position).fill(0);
-        indices.splice(indices.length - position, 1, newIndex);
-        index -= getClassCount(newIndex, position);
-        if (position === 1) {
-            break;
-        }
-    }
-    return (indices || [])
-        .map((v, i, array) => {
-        if (array.length > 1 && i !== array.length - 1) {
-            return String.fromCodePoint(v + unicodeInterval[0] - 1);
-        }
-        return String.fromCodePoint(v + unicodeInterval[0]);
-    })
-        .join('');
-}

package/dist/es/lib/plugins.js

@@ -0,0 +1,4 @@
+export const INIT_META = 'INIT';
+export const isInit = (tr) => {
+    return tr.getMeta(INIT_META);
+};

package/dist/es/menus.js

@@ -298,7 +298,7 @@ export const getEditorMenus = (editor) => {
                     pc: 'CommandOrControl+Option+F',
                 },
                 isEnabled: isCommandValid(canInsert(schema.nodes.inline_footnote)),
-                run: doCommand(insertInlineFootnote('footnote')),
+                run: doCommand(insertInlineFootnote),
             },
             {
                 id: 'insert-comment',

package/dist/es/plugins/affiliations.js

@@ -18,6 +18,7 @@ import { isEqual } from 'lodash';
 import { Plugin, PluginKey } from 'prosemirror-state';
 import { Decoration, DecorationSet } from 'prosemirror-view';
 import { authorComparator, } from '../lib/authors';
+import { isInit } from '../lib/plugins';
 import { isDeleted, isPendingInsert } from '../lib/track-changes-utils';
 export const affiliationsKey = new PluginKey('affiliations');
 let id = 1;
@@ -84,7 +85,7 @@ export default () => {
         },
         appendTransaction(transactions, oldState, newState) {
             const affs = affiliationsKey.getState(newState);
-            if (!affs || !transactions.find((tr) => tr.docChanged)) {
+            if (!affs || !transactions.find((tr) => tr.docChanged || isInit(tr))) {
                 return;
             }
             const $old = affiliationsKey.getState(oldState);

package/dist/es/plugins/footnotes.js

@@ -0,0 +1,185 @@
+/*!
+ * © 2024 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 { skipTracking } from '@manuscripts/track-changes-plugin';
+import { generateAlphaFootnoteLabel, isTableElementNode, schema, } from '@manuscripts/transform';
+import { isEqual } from 'lodash';
+import { Plugin, PluginKey, TextSelection } from 'prosemirror-state';
+import { findChildrenByType } from 'prosemirror-utils';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { findNodeByID } from '../lib/doc';
+import { findFootnotesContainerNode, findParentFootnote, } from '../lib/footnotes';
+import { isInit } from '../lib/plugins';
+export const footnotesKey = new PluginKey('footnotes');
+const buildPluginState = (doc) => {
+    const states = new Map();
+    const ids = new Map();
+    const elements = findChildrenByType(doc, schema.nodes.footnotes_element);
+    elements.map(({ node, pos }) => {
+        const container = findFootnotesContainerNode(doc, pos);
+        const newState = buildFootnotesElementState([container.node, container.pos], [node, pos]);
+        const elementID = node.attrs.id;
+        states.set(elementID, newState);
+        newState.footnotes.forEach(([n]) => ids.set(n.attrs.id, elementID));
+        newState.inlineFootnotes.forEach(([n]) => ids.set(n.attrs.id, elementID));
+        ids.set(container.node.attrs.id, elementID);
+    });
+    return {
+        footnotesElements: states,
+        footnotesElementIDs: ids,
+    };
+};
+const buildFootnotesElementState = (container, element) => {
+    const fn = {
+        element,
+        inlineFootnotes: [],
+        unusedFootnoteIDs: new Set(),
+        footnotes: [],
+        labels: new Map(),
+    };
+    const footnotes = findChildrenByType(element[0], schema.nodes.footnote);
+    const footnoteIDs = new Set();
+    footnotes.forEach(({ node, pos }) => {
+        fn.footnotes.push([node, element[1] + pos + 1]);
+        fn.unusedFootnoteIDs.add(node.attrs.id);
+        footnoteIDs.add(node.attrs.id);
+    });
+    let index = 0;
+    const inlineFootnotes = findChildrenByType(container[0], schema.nodes.inline_footnote);
+    inlineFootnotes.sort((a, b) => a.pos - b.pos);
+    const orderedFootnoteIDs = [];
+    inlineFootnotes.forEach(({ node, pos }) => {
+        const inlineFootnote = node;
+        const rids = inlineFootnote.attrs.rids;
+        if (rids.some((rid) => !footnoteIDs.has(rid))) {
+            return;
+        }
+        if (container[1]) {
+            pos += container[1] + 1;
+        }
+        fn.inlineFootnotes.push([node, pos]);
+        const label = rids
+            .map((rid) => {
+            if (fn.labels.has(rid)) {
+                return fn.labels.get(rid);
+            }
+            else {
+                const label = isTableElementNode(container[0])
+                    ? String(++index)
+                    : generateAlphaFootnoteLabel(index++);
+                fn.labels.set(rid, label);
+                fn.unusedFootnoteIDs.delete(rid);
+                orderedFootnoteIDs.push(rid);
+                return label;
+            }
+        })
+            .join(', ');
+        fn.labels.set(node.attrs.id, label);
+    });
+    fn.unusedFootnoteIDs.forEach((id) => orderedFootnoteIDs.push(id));
+    fn.footnotes.sort(([a], [b]) => orderedFootnoteIDs.indexOf(a.attrs.id) -
+        orderedFootnoteIDs.indexOf(b.attrs.id));
+    return fn;
+};
+const hasChanged = ($new, $old) => {
+    const nids = $new.footnotes.map(([node]) => node.attrs.id);
+    const oids = $old === null || $old === void 0 ? void 0 : $old.footnotes.map(([node]) => node.attrs.id);
+    return !(isEqual(nids, oids) &&
+        isEqual($new.unusedFootnoteIDs, $old === null || $old === void 0 ? void 0 : $old.unusedFootnoteIDs));
+};
+export default (props) => {
+    return new Plugin({
+        key: footnotesKey,
+        state: {
+            init(config, instance) {
+                return buildPluginState(instance.doc);
+            },
+            apply(tr, value, oldState, newState) {
+                const $old = footnotesKey.getState(oldState);
+                if (!tr.docChanged && $old) {
+                    return $old;
+                }
+                return buildPluginState(newState.doc);
+            },
+        },
+        appendTransaction(transactions, oldState, newState) {
+            var _a;
+            if (!transactions.find((tr) => tr.docChanged || isInit(tr))) {
+                return;
+            }
+            const $old = footnotesKey.getState(oldState);
+            const $new = footnotesKey.getState(newState);
+            if (!$new) {
+                return;
+            }
+            const tr = newState.tr;
+            $new.footnotesElements.forEach((newState, key) => {
+                const element = newState.element[0];
+                const pos = newState.element[1];
+                const oldState = $old === null || $old === void 0 ? void 0 : $old.footnotesElements.get(key);
+                const footnotes = newState.footnotes.map(([node]) => node);
+                if (hasChanged(newState, oldState)) {
+                    const newElement = schema.nodes.footnotes_element.create(element.attrs, footnotes);
+                    tr.replaceWith(pos, pos + element.nodeSize, newElement);
+                }
+            });
+            if (!tr.steps.length) {
+                return;
+            }
+            const selection = newState.selection;
+            const selectedFootnote = findParentFootnote(selection);
+            if (selectedFootnote) {
+                const pos = (_a = findNodeByID(tr.doc, selectedFootnote.node.attrs.id)) === null || _a === void 0 ? void 0 : _a.pos;
+                if (pos) {
+                    tr.setSelection(TextSelection.create(tr.doc, pos + 2));
+                }
+            }
+            skipTracking(tr);
+            return tr;
+        },
+        props: {
+            decorations: (state) => {
+                const fns = footnotesKey.getState(state);
+                if (!fns) {
+                    return DecorationSet.empty;
+                }
+                const decorations = [];
+                fns.footnotesElements.forEach((fn) => {
+                    fn.footnotes.forEach(([node, pos]) => {
+                        const to = pos + node.nodeSize;
+                        const label = fn.labels.get(node.attrs.id);
+                        decorations.push(Decoration.node(pos, to, {}, { label }));
+                    });
+                    fn.inlineFootnotes.forEach(([node, pos]) => {
+                        const to = pos + node.nodeSize;
+                        const label = fn.labels.get(node.attrs.id);
+                        decorations.push(Decoration.node(pos, to, {}, { label }));
+                    });
+                });
+                if (props.getCapabilities().editArticle) {
+                    const footnote = findParentFootnote(state.selection);
+                    if (footnote) {
+                        const pos = footnote.pos;
+                        const to = pos + footnote.node.nodeSize;
+                        decorations.push(Decoration.node(pos, to, {
+                            class: 'footnote-selected',
+                        }));
+                    }
+                }
+                return DecorationSet.create(state.doc, decorations);
+            },
+        },
+    });
+};

package/dist/es/plugins/persist.js

@@ -1,20 +1,20 @@
 import { skipTracking } from '@manuscripts/track-changes-plugin';
 import { generateNodeID, schema } from '@manuscripts/transform';
 import { Plugin } from 'prosemirror-state';
+import { isInit } from '../lib/plugins';
 const isManuscriptNode = (node) => {
     return node && node.type === schema.nodes.manuscript;
 };
 export default () => {
     return new Plugin({
         appendTransaction(transactions, oldState, newState) {
-            if (!transactions.some((tr) => tr.docChanged)) {
+            if (!transactions.some((tr) => tr.docChanged || isInit(tr))) {
                 return null;
             }
             const ids = new Set();
             const tr = newState.tr;
             newState.doc.descendants((node, pos, parent) => {
-                if (node.isInline ||
-                    isManuscriptNode(node) ||
+                if (isManuscriptNode(node) ||
                     isManuscriptNode(parent) ||
                     !node.type.spec.attrs ||
                     !('id' in node.type.spec.attrs)) {
@@ -23,7 +23,7 @@ export default () => {
                 let id = node.attrs.id;
                 if (!id || ids.has(id)) {
                     id = generateNodeID(node.type);
-                    tr.setNodeMarkup(pos, undefined, Object.assign(Object.assign({}, node.attrs), { id }), node.marks);
+                    tr.setNodeAttribute(pos, 'id', id);
                 }
                 ids.add(id);
             });