@manuscripts/transform 1.5.7 → 1.5.8-LEAN-3030

package/dist/es/transformer/decode.js

@@ -28,12 +28,13 @@ import { ObjectTypes, } from '@manuscripts/json-schema';
 import debug from 'debug';
 import { DOMParser } from 'prosemirror-model';
 import { MissingElement } from '../errors';
+import { groupBy } from '../lib/utils';
 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 { chooseCoreSectionBySection, chooseSectionLableName, chooseSectionNodeType, chooseSecType, guessSectionCategory, } from './section-category';
 import { timestamp } from './timestamp';
 const warn = debug('manuscripts-transform');
 const parser = DOMParser.fromSchema(schema);
@@ -54,78 +55,86 @@ 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);
+        let rootSections = getSections(this.modelMap)
+            .filter((section) => !section.path || section.path.length <= 1)
+            .filter((section) => section.category !== 'MPSectionCategory:contributors' &&
+            section.category !== 'MPSectionCategory:affiliations' &&
+            section.category !== 'MPSectionCategory:keywords');
         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),
-            }));
+        const sectionGroups = groupBy(rootSections, (sec) => {
+            var _a;
+            return chooseCoreSectionBySection((_a = sec.category) !== null && _a !== void 0 ? _a : '');
+        });
+        this.ensureCoreSectionsExist(sectionGroups);
+        const absSectionNode = sectionGroups['MPSectionCategory:abstracts'].map((e) => this.decode(e));
+        const bodySectionNodes = sectionGroups['MPSectionCategory:body'].map((e) => this.decode(e));
+        const backmatterSectionNodes = sectionGroups['MPSectionCategory:backmatter'].map(e => this.decode(e));
+        const abstractCoreSectionNodes = this.createAndFill(schema.nodes.abstracts, absSectionNode);
+        const bodyCoreSectionNodes = this.createAndFill(schema.nodes.body, bodySectionNodes);
+        const backmatterCoreSectionNodes = this.createAndFill(schema.nodes.backmatter, backmatterSectionNodes);
+        return {
+            abstracts: abstractCoreSectionNodes,
+            body: bodyCoreSectionNodes,
+            backmatter: backmatterCoreSectionNodes,
+        };
+    }
+    ensureCoreSectionsExist(coreSections) {
+        if (!coreSections['MPSectionCategory:abstracts']) {
+            coreSections['MPSectionCategory:abstracts'] = [];
+        }
+        if (!coreSections['MPSectionCategory:body']) {
+            coreSections['MPSectionCategory:body'] = [];
+        }
+        if (!coreSections['MPSectionCategory:backmatter']) {
+            coreSections['MPSectionCategory:backmatter'] = [];
         }
-        return rootSectionNodes;
     }
-    createCommentsNode(model) {
+    createAndFill(nodeType, content) {
+        return nodeType.createAndFill({
+            id: generateNodeID(nodeType),
+        }, content);
+    }
+    createCommentNodes(model) {
         const comments = [];
         for (const comment of this.getComments(model)) {
             comments.push(this.decode(comment));
@@ -170,8 +179,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 +194,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 +205,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 +241,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 +263,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 +306,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 +326,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 +378,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 +394,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 +421,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 +439,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 +487,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 +505,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 +523,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 +546,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 +560,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 +582,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 +648,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.createRootSectionNodes();
+            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 +704,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 +788,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;
-    }
 }