@manuscripts/transform 1.5.7 → 1.5.8-LEAN-3030-1

package/dist/es/transformer/decode.js

@@ -28,12 +28,12 @@ import { ObjectTypes, } from '@manuscripts/json-schema';
 import debug from 'debug';
 import { DOMParser } from 'prosemirror-model';
 import { MissingElement } from '../errors';
+import { abstractsType, backmatterType, bodyType, } from '../lib/section-group-type';
 import { schema, } from '../schema';
 import { buildTitles } from './builders';
 import { insertHighlightMarkers } from './highlight-markers';
-import { generateNodeID } from './id';
 import { ExtraObjectTypes, hasObjectType, isCommentAnnotation, isManuscript, } from './object-types';
-import { chooseSectionLableName, chooseSectionNodeType, chooseSecType, guessSectionCategory, } from './section-category';
+import { chooseSectionLableName, chooseSectionNodeType, chooseSecType, getSectionGroupType, guessSectionCategory, } from './section-category';
 import { timestamp } from './timestamp';
 const warn = debug('manuscripts-transform');
 const parser = DOMParser.fromSchema(schema);
@@ -54,78 +54,70 @@ export const sortSectionsByPriority = (a, b) => a.priority === b.priority ? 0 :
 const getSections = (modelMap) => getModelsByType(modelMap, ObjectTypes.Section).sort(sortSectionsByPriority);
 const getAffiliations = (modelMap) => getModelsByType(modelMap, ObjectTypes.Affiliation);
 const getContributors = (modelMap) => getModelsByType(modelMap, ObjectTypes.Contributor);
-export const isManuscriptNode = (model) => model !== null;
-const isParagraphElement = hasObjectType(ObjectTypes.ParagraphElement);
+const getKeywordElements = (modelMap) => getModelsByType(modelMap, ObjectTypes.KeywordsElement);
+const getKeywordGroups = (modelMap) => getModelsByType(modelMap, ObjectTypes.KeywordGroup);
+const getKeywords = (modelMap) => getModelsByType(modelMap, ObjectTypes.Keyword);
+const getTitles = (modelMap) => getModelsByType(modelMap, ObjectTypes.Titles)[0];
 const isFootnote = hasObjectType(ObjectTypes.Footnote);
-const isKeyword = hasObjectType(ObjectTypes.Keyword);
-const isKeywordsSection = (model) => model.category === 'MPSectionCategory:keywords';
-const isAffiliationsSection = (model) => model.category === 'MPSectionCategory:affiliations';
-const isContributorsSection = (model) => model.category === 'MPSectionCategory:contributors';
 const hasParentSection = (id) => (section) => section.path &&
     section.path.length > 1 &&
     section.path[section.path.length - 2] === id;
 export class Decoder {
-    createMetaSectionNode() {
-        const commentListNode = this.createCommentListNode();
-        return schema.nodes.meta_section.createAndFill({}, [
-            commentListNode,
-        ]);
-    }
-    createCommentListNode() {
-        return schema.nodes.comment_list.createAndFill({}, [
-            ...this.comments.values(),
-        ]);
+    createTitleNode() {
+        const titles = getTitles(this.modelMap) || buildTitles();
+        return this.decode(titles);
     }
-    handleMissingRootSectionNodes(rootSectionNodes) {
-        if (!rootSectionNodes.find((node) => node.type.name === 'affiliations_section')) {
-            this.createAffiliationSectionNode(rootSectionNodes);
-        }
-        if (!rootSectionNodes.find((node) => node.type.name === 'contributors_section')) {
-            this.createContributorSectionNode(rootSectionNodes);
-        }
+    createAffiliationsNode() {
+        const affiliations = getAffiliations(this.modelMap)
+            .map((a) => this.decode(a))
+            .filter(Boolean);
+        return schema.nodes.affiliations.createAndFill({}, affiliations);
     }
-    createAffiliationSectionNode(rootSectionNodes) {
-        const affiliationNodes = getAffiliations(this.modelMap)
-            .map((affiliation) => this.decode(affiliation))
+    createContributorsNode() {
+        const contributors = getContributors(this.modelMap)
+            .map((c) => this.decode(c))
             .filter(Boolean);
-        if (affiliationNodes.length) {
-            const node = schema.nodes.affiliations_section.createAndFill({
-                id: generateNodeID(schema.nodes.section),
-            }, affiliationNodes);
-            rootSectionNodes.unshift(node);
-        }
+        return schema.nodes.contributors.createAndFill({}, contributors);
     }
-    createContributorSectionNode(rootSectionNodes) {
-        const contributorNodes = getContributors(this.modelMap)
-            .map((contributor) => this.decode(contributor))
+    createKeywordsNode() {
+        const elements = getKeywordElements(this.modelMap)
+            .map((e) => this.decode(e))
             .filter(Boolean);
-        if (contributorNodes.length) {
-            const node = schema.nodes.contributors_section.createAndFill({
-                id: generateNodeID(schema.nodes.section),
-            }, contributorNodes);
-            rootSectionNodes.unshift(node);
-        }
+        return schema.nodes.keywords.createAndFill({}, [
+            schema.nodes.section_title.create({}, schema.text('Keywords')),
+            ...elements,
+        ]);
     }
-    createTitleNode() {
-        const titles = getModelsByType(this.modelMap, ObjectTypes.Titles)[0] ||
-            buildTitles();
-        return this.decode(titles);
+    createCommentsNode() {
+        return schema.nodes.comments.createAndFill({}, [
+            ...this.comments.values(),
+        ]);
     }
-    createRootSectionNodes() {
-        let rootSections = getSections(this.modelMap).filter((section) => !section.path || section.path.length <= 1);
-        rootSections = this.addGeneratedLabels(rootSections);
-        const rootSectionNodes = rootSections
-            .map(this.decode)
-            .filter(isManuscriptNode);
-        this.handleMissingRootSectionNodes(rootSectionNodes);
-        if (!rootSectionNodes.length) {
-            rootSectionNodes.push(schema.nodes.section.createAndFill({
-                id: generateNodeID(schema.nodes.section),
-            }));
+    createContentSections() {
+        let sections = getSections(this.modelMap);
+        sections = this.addGeneratedLabels(sections);
+        const groups = {
+            abstracts: [],
+            body: [],
+            backmatter: [],
+        };
+        for (const section of sections) {
+            const category = section.category;
+            const group = category
+                ? getSectionGroupType(category)
+                : bodyType;
+            groups[group._id].push(this.decode(section));
         }
-        return rootSectionNodes;
+        const abstracts = schema.nodes.abstracts.createAndFill({}, groups[abstractsType._id]);
+        const body = schema.nodes.body.createAndFill({}, groups[bodyType._id]);
+        const backmatter = schema.nodes.backmatter.createAndFill({}, groups[backmatterType._id]);
+        return {
+            abstracts,
+            body,
+            backmatter,
+        };
     }
-    createCommentsNode(model) {
+    createCommentNodes(model) {
         const comments = [];
         for (const comment of this.getComments(model)) {
             comments.push(this.decode(comment));
@@ -170,8 +162,8 @@ export class Decoder {
             },
             [ObjectTypes.BibliographyItem]: (data) => {
                 const model = data;
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return schema.nodes.bibliography_item.create({
                     id: model._id,
                     type: model.type,
@@ -185,7 +177,7 @@ export class Decoder {
                     page: model.page,
                     title: model.title,
                     literal: model.literal,
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 });
             },
             [ExtraObjectTypes.PlaceholderElement]: (data) => {
@@ -196,14 +188,14 @@ export class Decoder {
             },
             [ObjectTypes.Figure]: (data) => {
                 const model = data;
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return schema.nodes.figure.create({
                     id: model._id,
                     contentType: model.contentType,
                     src: model.src,
                     position: model.position,
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 });
             },
             [ObjectTypes.FigureElement]: (data) => {
@@ -232,8 +224,8 @@ export class Decoder {
                     figures.push(schema.nodes.figure.createAndFill());
                 }
                 const figcaption = this.getFigcaption(model);
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 const content = [...paragraphs, ...figures, figcaption];
                 const listing = this.extractListing(model);
                 if (listing) {
@@ -254,7 +246,7 @@ export class Decoder {
                     suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
                     attribution: model.attribution,
                     alternatives: model.alternatives,
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 }, content);
             },
             [ObjectTypes.Equation]: (data) => {
@@ -297,13 +289,13 @@ export class Decoder {
                     if (isFootnote(model) &&
                         model.kind === collateByKind &&
                         model.containingObject === foonotesElementModel._id) {
-                        const commentNodes = this.createCommentsNode(model);
-                        commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                        const comments = this.createCommentNodes(model);
+                        comments.forEach((c) => this.comments.set(c.attrs.id, c));
                         const footnote = this.parseContents(model.contents || '<div></div>', undefined, this.getComments(model), {
                             topNode: schema.nodes.footnote.create({
                                 id: model._id,
                                 kind: model.kind,
-                                comments: commentNodes.map((c) => c.attrs.id),
+                                comments: comments.map((c) => c.attrs.id),
                             }),
                         });
                         footnotesOfKind.push(footnote);
@@ -317,36 +309,51 @@ export class Decoder {
             },
             [ObjectTypes.Footnote]: (data) => {
                 const footnoteModel = data;
-                const commentNodes = this.createCommentsNode(footnoteModel);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(footnoteModel);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return this.parseContents(footnoteModel.contents || '<div></div>', undefined, this.getComments(footnoteModel), {
                     topNode: schema.nodes.footnote.create({
                         id: footnoteModel._id,
                         kind: footnoteModel.kind,
-                        comments: commentNodes.map((c) => c.attrs.id),
+                        comments: comments.map((c) => c.attrs.id),
                     }),
                 });
             },
             [ObjectTypes.KeywordsElement]: (data) => {
                 const model = data;
-                const keywordGroups = this.getKeywordGroups();
+                const keywordGroups = getKeywordGroups(this.modelMap).map((k) => this.decode(k));
                 return schema.nodes.keywords_element.create({
                     id: model._id,
                     paragraphStyle: model.paragraphStyle,
                 }, keywordGroups);
             },
+            [ObjectTypes.KeywordGroup]: (data) => {
+                const keywordGroup = data;
+                const keywords = getKeywords(this.modelMap)
+                    .filter((k) => k.containedGroup === keywordGroup._id)
+                    .map((k) => this.decode(k));
+                const comments = this.createCommentNodes(keywordGroup);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return schema.nodes.keyword_group.create({
+                    id: keywordGroup._id,
+                    type: keywordGroup.type,
+                    comments: comments.map((c) => c.attrs.id),
+                }, keywords);
+            },
             [ObjectTypes.Keyword]: (data) => {
-                const model = data;
+                const keyword = data;
+                const comments = this.createCommentNodes(keyword);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return schema.nodes.keyword.create({
-                    id: model._id,
-                    contents: model.name,
-                    comments: this.createCommentsNode(model),
-                }, schema.text(model.name));
+                    id: keyword._id,
+                    contents: keyword.name,
+                    comments: comments.map((c) => c.attrs.id),
+                }, schema.text(keyword.name));
             },
             [ObjectTypes.ListElement]: (data) => {
                 const model = data;
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 switch (model.elementType) {
                     case 'ol':
                         return this.parseContents(model.contents || '<ol></ol>', undefined, this.getComments(model), {
@@ -354,7 +361,7 @@ export class Decoder {
                                 id: model._id,
                                 listStyleType: model.listStyleType,
                                 paragraphStyle: model.paragraphStyle,
-                                comments: commentNodes.map((c) => c.attrs.id),
+                                comments: comments.map((c) => c.attrs.id),
                             }),
                         });
                     case 'ul':
@@ -370,14 +377,14 @@ export class Decoder {
             },
             [ObjectTypes.Listing]: (data) => {
                 const model = data;
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return schema.nodes.listing.createChecked({
                     id: model._id,
                     contents: model.contents,
                     language: model.language,
                     languageKey: model.languageKey,
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 });
             },
             [ObjectTypes.ListingElement]: (data) => {
@@ -397,13 +404,13 @@ export class Decoder {
                     throw new MissingElement(model.containedObjectID);
                 }
                 const figcaption = this.getFigcaption(model);
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return schema.nodes.listing_element.createChecked({
                     id: model._id,
                     suppressCaption: model.suppressCaption,
                     suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 }, [listing, figcaption]);
             },
             [ObjectTypes.MissingFigure]: (data) => {
@@ -415,14 +422,14 @@ export class Decoder {
             },
             [ObjectTypes.ParagraphElement]: (data) => {
                 const model = data;
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return this.parseContents(model.contents || '<p></p>', undefined, this.getComments(model), {
                     topNode: schema.nodes.paragraph.create({
                         id: model._id,
                         paragraphStyle: model.paragraphStyle,
                         placeholder: model.placeholderInnerHTML,
-                        comments: commentNodes.map((c) => c.attrs.id),
+                        comments: comments.map((c) => c.attrs.id),
                     }),
                 });
             },
@@ -463,9 +470,6 @@ export class Decoder {
                     for (const id of model.elementIDs) {
                         const element = this.getModel(id);
                         if (element) {
-                            if (isKeywordsSection(model) && isParagraphElement(element)) {
-                                continue;
-                            }
                             elements.push(element);
                         }
                         else if (this.allowMissingElements) {
@@ -484,9 +488,7 @@ export class Decoder {
                         }
                     }
                 }
-                const elementNodes = elements
-                    .map(this.decode)
-                    .filter(isManuscriptNode);
+                const elementNodes = elements.map((e) => this.decode(e));
                 const sectionTitle = 'section_title';
                 const sectionTitleNode = model.title
                     ? this.parseContents(model.title, 'h1', this.getComments(model), {
@@ -504,26 +506,20 @@ export class Decoder {
                     .map(this.creators[ObjectTypes.Section]);
                 const sectionCategory = model.category || guessSectionCategory(elements);
                 const sectionNodeType = chooseSectionNodeType(sectionCategory);
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
-                let content;
-                if (isAffiliationsSection(model) || isContributorsSection(model)) {
-                    content = elementNodes.concat(nestedSections);
-                }
-                else {
-                    content = (sectionLabelNode
-                        ? [sectionLabelNode, sectionTitleNode]
-                        : [sectionTitleNode])
-                        .concat(elementNodes)
-                        .concat(nestedSections);
-                }
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                const content = (sectionLabelNode
+                    ? [sectionLabelNode, sectionTitleNode]
+                    : [sectionTitleNode])
+                    .concat(elementNodes)
+                    .concat(nestedSections);
                 const sectionNode = sectionNodeType.createAndFill({
                     id: model._id,
                     category: sectionCategory,
                     titleSuppressed: model.titleSuppressed,
                     pageBreakStyle: model.pageBreakStyle,
                     generatedLabel: model.generatedLabel,
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 }, content);
                 if (!sectionNode) {
                     console.error(model);
@@ -533,12 +529,12 @@ export class Decoder {
             },
             [ObjectTypes.Table]: (data) => {
                 const model = data;
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 return this.parseContents(model.contents, undefined, this.getComments(model), {
                     topNode: schema.nodes.table.create({
                         id: model._id,
-                        comments: commentNodes.map((c) => c.attrs.id),
+                        comments: comments.map((c) => c.attrs.id),
                     }),
                 });
             },
@@ -547,8 +543,8 @@ export class Decoder {
                 const table = this.createTable(model);
                 const tableElementFooter = this.createTableElementFooter(model);
                 const figcaption = this.getFigcaption(model);
-                const commentNodes = this.createCommentsNode(model);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
                 const content = tableElementFooter
                     ? [table, figcaption, tableElementFooter]
                     : [table, figcaption];
@@ -569,7 +565,7 @@ export class Decoder {
                     suppressHeader: model.suppressHeader,
                     tableStyle: model.tableStyle,
                     paragraphStyle: model.paragraphStyle,
-                    comments: commentNodes.map((c) => c.attrs.id),
+                    comments: comments.map((c) => c.attrs.id),
                 }, content);
             },
             [ObjectTypes.TOCElement]: (data) => {
@@ -635,13 +631,21 @@ export class Decoder {
         };
         this.getModel = (id) => this.modelMap.get(id);
         this.createArticleNode = (manuscriptID) => {
-            const titlesNode = this.createTitleNode();
-            const rootSectionNodes = this.createRootSectionNodes();
-            const metaSectionNode = this.createMetaSectionNode();
+            const title = this.createTitleNode();
+            const contributors = this.createContributorsNode();
+            const affiliations = this.createAffiliationsNode();
+            const keywords = this.createKeywordsNode();
+            const { abstracts, body, backmatter } = this.createContentSections();
+            const comments = this.createCommentsNode();
             const contents = [
-                titlesNode,
-                ...rootSectionNodes,
-                metaSectionNode,
+                title,
+                contributors,
+                affiliations,
+                keywords,
+                abstracts,
+                body,
+                backmatter,
+                comments,
             ];
             return schema.nodes.manuscript.create({
                 id: manuscriptID || this.getManuscriptID(),
@@ -683,23 +687,6 @@ export class Decoder {
             }
             return parser.parse(template.content.firstElementChild, options);
         };
-        this.getKeywords = (id) => {
-            const keywordsOfKind = [];
-            const keywordsByGroup = [...this.modelMap.values()].filter((m) => m.objectType === ObjectTypes.Keyword &&
-                m.containedGroup === id);
-            for (const model of keywordsByGroup) {
-                if (isKeyword(model)) {
-                    const keyword = this.parseContents(model.name || '', 'div', this.getComments(model), {
-                        topNode: schema.nodes.keyword.create({
-                            id: model._id,
-                            contents: model.name,
-                        }),
-                    });
-                    keywordsOfKind.push(keyword);
-                }
-            }
-            return keywordsOfKind;
-        };
         this.getManuscriptID = () => {
             for (const item of this.modelMap.values()) {
                 if (isManuscript(item)) {
@@ -784,26 +771,4 @@ export class Decoder {
         }
         return listing;
     }
-    getKeywordGroups() {
-        const kwdGroupNodes = [];
-        const kwdGroupsModels = [
-            ...this.modelMap.values(),
-        ].filter((model) => model.objectType === ObjectTypes.KeywordGroup);
-        if (kwdGroupsModels.length > 0) {
-            for (const kwdGroupModel of kwdGroupsModels) {
-                const keywords = this.getKeywords(kwdGroupModel._id);
-                const commentNodes = this.createCommentsNode(kwdGroupModel);
-                commentNodes.forEach((c) => this.comments.set(c.attrs.id, c));
-                const contents = [];
-                contents.push(...keywords);
-                const kwdGroupNode = schema.nodes.keywords_group.create({
-                    id: kwdGroupModel._id,
-                    type: kwdGroupModel.type,
-                    comments: commentNodes.map((c) => c.attrs.id),
-                }, contents);
-                kwdGroupNodes.push(kwdGroupNode);
-            }
-        }
-        return kwdGroupNodes;
-    }
 }

package/dist/es/transformer/encode.js

@@ -15,10 +15,11 @@
  */
 import { DOMSerializer } from 'prosemirror-model';
 import serializeToXML from 'w3c-xmlserializer';
-import { iterateChildren } from '../lib/utils';
-import { hasGroup, isHighlightMarkerNode, isSectionNode, schema, } from '../schema';
-import { buildAttribution } from './builders';
+import { iterateChildren, modelsEqual } from '../lib/utils';
+import { hasGroup, isHighlightMarkerNode, isManuscriptNode, isSectionNode, schema, } from '../schema';
+import { auxiliaryObjectTypes, buildAttribution, buildElementsOrder, } from './builders';
 import { extractHighlightMarkers, isHighlightableModel, } from './highlight-markers';
+import { generateID } from './id';
 import { nodeTypesMap } from './node-types';
 import { buildSectionCategory } from './section-category';
 const serializer = DOMSerializer.fromSchema(schema);
@@ -420,34 +421,9 @@ const encoders = {
         elementType: 'div',
         paragraphStyle: node.attrs.paragraphStyle || undefined,
     }),
-    keywords_group: (node) => ({
+    keyword_group: (node) => ({
         type: node.attrs.type,
     }),
-    keywords_section: (node, parent, path, priority) => ({
-        category: buildSectionCategory(node),
-        priority: priority.value++,
-        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
-        path: path.concat([node.attrs.id]),
-        elementIDs: childElements(node)
-            .map((childNode) => childNode.attrs.id)
-            .filter((id) => id),
-    }),
-    affiliations_section: (node, parent, path, priority) => ({
-        category: buildSectionCategory(node),
-        priority: priority.value++,
-        path: path.concat([node.attrs.id]),
-        elementIDs: childElements(node)
-            .map((childNode) => childNode.attrs.id)
-            .filter((id) => id),
-    }),
-    contributors_section: (node, parent, path, priority) => ({
-        category: buildSectionCategory(node),
-        priority: priority.value++,
-        path: path.concat([node.attrs.id]),
-        elementIDs: childElements(node)
-            .map((childNode) => childNode.attrs.id)
-            .filter((id) => id),
-    }),
     missing_figure: (node) => ({
         position: node.attrs.position || undefined,
     }),
@@ -568,28 +544,48 @@ export const modelFromNode = (node, parent, path, priority) => {
     const comments = [...commentAnnotationsMap.values()];
     return { model, comments };
 };
-export const encode = (node) => {
+const containerTypes = [
+    schema.nodes.affiliations,
+    schema.nodes.contributors,
+    schema.nodes.affiliations,
+    schema.nodes.keywords,
+    schema.nodes.abstracts,
+    schema.nodes.body,
+    schema.nodes.backmatter,
+    schema.nodes.comments,
+];
+export const encode = (node, preserveWithRepeatedID = false) => {
     const models = new Map();
     const priority = {
         value: 1,
     };
     const placeholders = ['placeholder', 'placeholder_element'];
-    const addModel = (path, parent) => (child) => {
+    const processNode = (path, parent) => (child) => {
+        if (containerTypes.includes(child.type)) {
+            child.forEach(processNode([], child));
+            return;
+        }
         if (!child.attrs.id) {
             return;
         }
         if (isHighlightMarkerNode(child)) {
             return;
         }
-        if (child.type === schema.nodes.meta_section) {
+        if (placeholders.includes(child.type.name)) {
             return;
         }
-        if (placeholders.includes(child.type.name)) {
+        if (parent.type === schema.nodes.paragraph) {
             return;
         }
         const { model, comments } = modelFromNode(child, parent, path, priority);
-        if (models.has(model._id)) {
-            throw Error(`Encountered duplicate ids in models map while encoding: ${model._id}`);
+        const existingModel = models.get(model._id);
+        if (existingModel) {
+            if (preserveWithRepeatedID && !modelsEqual(model, existingModel)) {
+                model._id = generateID(model.objectType);
+            }
+            else {
+                throw Error(`Encountered duplicate ids in models map while encoding: ${model._id}`);
+            }
         }
         comments.forEach((comment) => {
             const proseMirrorComment = models.get(comment._id);
@@ -600,22 +596,35 @@ export const encode = (node) => {
             }
         });
         models.set(model._id, model);
-        child.forEach(addModel(path.concat(child.attrs.id), child));
+        child.forEach(processNode(path.concat(child.attrs.id), child));
     };
-    node.forEach((cNode) => {
-        if (cNode.type === schema.nodes.meta_section) {
-            processMetaSectionNode(cNode, models, priority);
-        }
-    });
-    node.forEach(addModel([], node));
+    node.forEach(processNode([], node));
+    if (isManuscriptNode(node)) {
+        auxiliaryObjectTypes.forEach((t) => {
+            const order = generateElementOrder(node, t);
+            if (order) {
+                models.set(order._id, order);
+            }
+        });
+    }
     return models;
 };
-const processMetaSectionNode = (node, models, priority) => {
-    node.descendants((child) => {
-        if ((!child.content || child.content.size === 0) &&
-            nodeTypesMap.get(child.type)) {
-            const { model } = modelFromNode(child, node, [], priority);
-            models.set(model._id, model);
+const generateElementOrder = (node, nodeType) => {
+    const ids = [];
+    node.descendants((n) => {
+        if (n.type === nodeType) {
+            ids.push(n.attrs.id);
         }
+        return true;
     });
+    if (!ids.length) {
+        return undefined;
+    }
+    const type = nodeTypesMap.get(nodeType);
+    if (!type) {
+        return undefined;
+    }
+    const order = buildElementsOrder(type);
+    order.elements = ids;
+    return order;
 };