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

package/dist/es/transformer/builders.js

@@ -18,8 +18,6 @@ import serializeToXML from 'w3c-xmlserializer';
 import { schema } from '../schema';
 import { generateID } from './id';
 import { timestamp } from './timestamp';
-export const DEFAULT_BUNDLE = 'MPBundle:www-zotero-org-styles-nature';
-export const DEFAULT_PAGE_LAYOUT = 'MPPageLayout:defaultA4';
 export const buildProject = (owner) => ({
     _id: generateID(ObjectTypes.Project),
     objectType: ObjectTypes.Project,
@@ -45,30 +43,12 @@ export const buildContributor = (bibliographicName, role = 'author', priority =
 export const buildBibliographyItem = (data) => (Object.assign(Object.assign({}, data), { type: data.type || 'article-journal', _id: generateID(ObjectTypes.BibliographyItem), objectType: ObjectTypes.BibliographyItem }));
 export const buildBibliographicName = (data) => (Object.assign(Object.assign({}, data), { _id: generateID(ObjectTypes.BibliographicName), objectType: ObjectTypes.BibliographicName }));
 export const buildBibliographicDate = (data) => (Object.assign(Object.assign({}, data), { _id: generateID(ObjectTypes.BibliographicDate), objectType: ObjectTypes.BibliographicDate }));
-export const buildAuxiliaryObjectReference = (containingObject, rids) => {
-    const auxiliaryObjectReference = {
-        _id: generateID(ObjectTypes.AuxiliaryObjectReference),
-        objectType: ObjectTypes.AuxiliaryObjectReference,
-        containingObject: containingObject || undefined,
-    };
-    if (rids.length < 2) {
-        Object.assign(auxiliaryObjectReference, { referencedObject: rids[0] });
-    }
-    else {
-        Object.assign(auxiliaryObjectReference, { referencedObjects: rids });
-    }
-    return auxiliaryObjectReference;
-};
-export const buildEmbeddedCitationItem = (bibliographyItem) => ({
-    _id: generateID(ObjectTypes.CitationItem),
-    objectType: ObjectTypes.CitationItem,
-    bibliographyItem,
-});
-export const buildCitation = (containingObject, embeddedCitationItems) => ({
-    _id: generateID(ObjectTypes.Citation),
-    objectType: ObjectTypes.Citation,
-    containingObject: containingObject || undefined,
-    embeddedCitationItems: embeddedCitationItems.map(buildEmbeddedCitationItem),
+export const buildBibliographyElement = (bibliographyItems) => ({
+    _id: generateID(ObjectTypes.BibliographyElement),
+    objectType: ObjectTypes.BibliographyElement,
+    contents: '',
+    elementType: 'div',
+    containedObjectIDs: bibliographyItems.map((b) => b._id),
 });
 export const buildKeyword = (name) => ({
     _id: generateID(ObjectTypes.Keyword),
@@ -76,19 +56,6 @@ export const buildKeyword = (name) => ({
     name,
 });
 export const buildKeywordGroup = (attributes) => (Object.assign(Object.assign(Object.assign({ _id: generateID(ObjectTypes.KeywordGroup), objectType: ObjectTypes.KeywordGroup }, (attributes.type && { type: attributes.type })), (attributes.title && { title: attributes.title })), (attributes.label && { label: attributes.label })));
-export const buildManuscriptKeyword = (name) => ({
-    _id: generateID(ObjectTypes.ManuscriptKeyword),
-    objectType: ObjectTypes.ManuscriptKeyword,
-    name,
-});
-export const buildLibraryCollection = (owner, name) => ({
-    _id: generateID(ObjectTypes.LibraryCollection),
-    objectType: ObjectTypes.LibraryCollection,
-    owners: [owner],
-    writers: [],
-    viewers: [],
-    name,
-});
 export const buildFigure = (blob) => ({
     _id: generateID(ObjectTypes.Figure),
     objectType: ObjectTypes.Figure,
@@ -112,12 +79,6 @@ export const buildSupplementaryMaterial = (title, href) => ({
     title,
     href,
 });
-export const buildUserProfileAffiliation = (institution, priority = 0) => ({
-    _id: generateID(ObjectTypes.UserProfileAffiliation),
-    objectType: ObjectTypes.UserProfileAffiliation,
-    institution,
-    priority,
-});
 export const buildComment = (target, contents = '', selector, contributions, annotationColor) => ({
     _id: generateID(ObjectTypes.CommentAnnotation),
     objectType: ObjectTypes.CommentAnnotation,
@@ -134,11 +95,6 @@ export const buildNote = (target, source, contents = '') => ({
     source,
     contents,
 });
-export const buildValidation = (results) => ({
-    _id: generateID(ObjectTypes.RequirementsValidation),
-    objectType: ObjectTypes.RequirementsValidation,
-    results,
-});
 export const buildInlineMathFragment = (containingObject, TeXRepresentation) => ({
     _id: generateID(ObjectTypes.InlineMathFragment),
     objectType: ObjectTypes.InlineMathFragment,
@@ -194,18 +150,6 @@ export const buildColor = (value, priority) => ({
     priority,
     value,
 });
-export const buildHighlight = () => ({
-    _id: generateID(ObjectTypes.Highlight),
-    objectType: ObjectTypes.Highlight,
-});
-export const buildHighlightMarker = (highlightID, start, offset, field) => ({
-    highlightID,
-    objectType: ObjectTypes.HighlightMarker,
-    _id: generateID(ObjectTypes.HighlightMarker),
-    start,
-    offset,
-    field,
-});
 export const buildContribution = (profileID) => ({
     _id: generateID(ObjectTypes.Contribution),
     objectType: ObjectTypes.Contribution,
@@ -217,12 +161,6 @@ export const buildContributorRole = (name) => ({
     objectType: ObjectTypes.ContributorRole,
     name,
 });
-export const buildInlineStyle = (priority, title) => ({
-    _id: generateID(ObjectTypes.InlineStyle),
-    objectType: ObjectTypes.InlineStyle,
-    priority,
-    title,
-});
 export const buildAttribution = () => ({
     _id: generateID(ObjectTypes.Attribution),
     objectType: ObjectTypes.Attribution,
@@ -231,11 +169,6 @@ export const buildJournal = () => ({
     _id: generateID(ObjectTypes.Journal),
     objectType: ObjectTypes.Journal,
 });
-export const buildStatusLabel = (name) => ({
-    _id: generateID(ObjectTypes.StatusLabel),
-    objectType: ObjectTypes.StatusLabel,
-    name,
-});
 export const auxiliaryObjectTypes = new Set([
     schema.nodes.figure_element,
     schema.nodes.table_element,

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,17 +55,41 @@ 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);
+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];
 export const isManuscriptNode = (model) => model !== null;
-const isParagraphElement = hasObjectType(ObjectTypes.ParagraphElement);
 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 {
+    createTitleNode() {
+        const titles = getTitles(this.modelMap) || buildTitles();
+        return this.decode(titles);
+    }
+    createAffiliationsNode() {
+        const affiliations = getAffiliations(this.modelMap)
+            .map((a) => this.decode(a))
+            .filter(Boolean);
+        return schema.nodes.affiliations.createAndFill({}, affiliations);
+    }
+    createContributorsNode() {
+        const contributors = getContributors(this.modelMap)
+            .map((c) => this.decode(c))
+            .filter(Boolean);
+        return schema.nodes.contributors.createAndFill({}, contributors);
+    }
+    createKeywordsNode() {
+        const elements = getKeywordElements(this.modelMap)
+            .map((e) => this.decode(e))
+            .filter(Boolean);
+        return schema.nodes.keywords.createAndFill({}, [
+            schema.nodes.section_title.create({}, schema.text('Keywords')),
+            ...elements,
+        ]);
+    }
     createMetaSectionNode() {
         const commentListNode = this.createCommentListNode();
         return schema.nodes.meta_section.createAndFill({}, [
@@ -76,54 +101,51 @@ export class Decoder {
             ...this.comments.values(),
         ]);
     }
-    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);
-        }
-    }
-    createAffiliationSectionNode(rootSectionNodes) {
-        const affiliationNodes = getAffiliations(this.modelMap)
-            .map((affiliation) => this.decode(affiliation))
-            .filter(Boolean);
-        if (affiliationNodes.length) {
-            const node = schema.nodes.affiliations_section.createAndFill({
-                id: generateNodeID(schema.nodes.section),
-            }, affiliationNodes);
-            rootSectionNodes.unshift(node);
-        }
-    }
-    createContributorSectionNode(rootSectionNodes) {
-        const contributorNodes = getContributors(this.modelMap)
-            .map((contributor) => this.decode(contributor))
-            .filter(Boolean);
-        if (contributorNodes.length) {
-            const node = schema.nodes.contributors_section.createAndFill({
-                id: generateNodeID(schema.nodes.section),
-            }, contributorNodes);
-            rootSectionNodes.unshift(node);
-        }
-    }
-    createTitleNode() {
-        const titles = getModelsByType(this.modelMap, ObjectTypes.Titles)[0] ||
-            buildTitles();
-        return this.decode(titles);
-    }
     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
+        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(this.decode)
+            .filter(isManuscriptNode);
+        const bodySectionNodes = sectionGroups['MPSectionCategory:body']
+            .map(this.decode)
+            .filter(isManuscriptNode);
+        const backmatterSectionNodes = sectionGroups['MPSectionCategory:backmatter']
             .map(this.decode)
             .filter(isManuscriptNode);
-        this.handleMissingRootSectionNodes(rootSectionNodes);
-        if (!rootSectionNodes.length) {
-            rootSectionNodes.push(schema.nodes.section.createAndFill({
-                id: generateNodeID(schema.nodes.section),
-            }));
+        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'] = [];
         }
-        return rootSectionNodes;
+        if (!coreSections['MPSectionCategory:backmatter']) {
+            coreSections['MPSectionCategory:backmatter'] = [];
+        }
+    }
+    createAndFill(nodeType, content) {
+        return nodeType.createAndFill({
+            id: generateNodeID(nodeType),
+        }, content);
     }
     createCommentsNode(model) {
         const comments = [];
@@ -329,19 +351,34 @@ export class Decoder {
             },
             [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.createCommentsNode(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.createCommentsNode(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;
@@ -463,9 +500,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) {
@@ -506,17 +540,11 @@ export class Decoder {
                 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 content = (sectionLabelNode
+                    ? [sectionLabelNode, sectionTitleNode]
+                    : [sectionTitleNode])
+                    .concat(elementNodes)
+                    .concat(nestedSections);
                 const sectionNode = sectionNodeType.createAndFill({
                     id: model._id,
                     category: sectionCategory,
@@ -635,13 +663,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 meta = this.createMetaSectionNode();
             const contents = [
-                titlesNode,
-                ...rootSectionNodes,
-                metaSectionNode,
+                title,
+                contributors,
+                affiliations,
+                keywords,
+                abstracts,
+                body,
+                backmatter,
+                meta,
             ];
             return schema.nodes.manuscript.create({
                 id: manuscriptID || this.getManuscriptID(),
@@ -683,23 +719,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 +803,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

@@ -17,7 +17,7 @@ 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 { auxiliaryObjectTypes, buildAttribution, buildElementsOrder, } from './builders';
 import { extractHighlightMarkers, isHighlightableModel, } from './highlight-markers';
 import { nodeTypesMap } from './node-types';
 import { buildSectionCategory } from './section-category';
@@ -420,34 +420,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,6 +543,14 @@ export const modelFromNode = (node, parent, path, priority) => {
     const comments = [...commentAnnotationsMap.values()];
     return { model, comments };
 };
+function isCoreSection(child) {
+    return (child.type === schema.nodes.abstracts ||
+        child.type === schema.nodes.body ||
+        child.type === schema.nodes.backmatter ||
+        child.type === schema.nodes.affiliations ||
+        child.type === schema.nodes.contributors ||
+        child.type === schema.nodes.keywords);
+}
 export const encode = (node) => {
     const models = new Map();
     const priority = {
@@ -575,6 +558,10 @@ export const encode = (node) => {
     };
     const placeholders = ['placeholder', 'placeholder_element'];
     const addModel = (path, parent) => (child) => {
+        if (isCoreSection(child)) {
+            child.forEach(addModel([], child));
+            return;
+        }
         if (!child.attrs.id) {
             return;
         }
@@ -587,6 +574,9 @@ export const encode = (node) => {
         if (placeholders.includes(child.type.name)) {
             return;
         }
+        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}`);
@@ -602,12 +592,20 @@ export const encode = (node) => {
         models.set(model._id, model);
         child.forEach(addModel(path.concat(child.attrs.id), child));
     };
-    node.forEach((cNode) => {
-        if (cNode.type === schema.nodes.meta_section) {
-            processMetaSectionNode(cNode, models, priority);
+    node.forEach((child) => {
+        if (child.type === schema.nodes.meta_section) {
+            processMetaSectionNode(child, models, priority);
         }
     });
     node.forEach(addModel([], node));
+    if (node.type === schema.nodes.manuscript) {
+        auxiliaryObjectTypes.forEach((t) => {
+            const order = generateElementOrder(node, t);
+            if (order) {
+                models.set(order._id, order);
+            }
+        });
+    }
     return models;
 };
 const processMetaSectionNode = (node, models, priority) => {
@@ -619,3 +617,22 @@ const processMetaSectionNode = (node, models, priority) => {
         }
     });
 };
+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;
+};

package/dist/es/transformer/highlight-markers.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { buildComment } from './builders';
-const highlightableFields = [
+export const highlightableFields = [
     'caption',
     'contents',
     'title',

package/dist/es/transformer/html.js

@@ -194,11 +194,9 @@ export class HTMLTransformer {
                 const citationNode = node;
                 const element = this.document.createElement('span');
                 element.setAttribute('class', 'citation');
-                const citation = getModel(citationNode.attrs.rid);
-                if (citation) {
-                    element.setAttribute('data-reference-ids', citation.embeddedCitationItems
-                        .map((item) => item.bibliographyItem)
-                        .join(' '));
+                const rids = citationNode.attrs.rids;
+                if (rids.length) {
+                    element.setAttribute('data-reference-ids', rids.join(' '));
                 }
                 if (citationNode.attrs.contents) {
                     element.innerHTML = citationNode.attrs.contents;
@@ -209,20 +207,7 @@ export class HTMLTransformer {
                 const crossReferenceNode = node;
                 const element = this.document.createElement('a');
                 element.classList.add('cross-reference');
-                const auxiliaryObjectReference = getModel(crossReferenceNode.attrs.rid);
-                if (auxiliaryObjectReference &&
-                    auxiliaryObjectReference.referencedObject) {
-                    if (auxiliaryObjectReference.referencedObject.startsWith('MPFigureElement')) {
-                        const model = getModel(auxiliaryObjectReference.referencedObject);
-                        if (model && model.containedObjectIDs.length > 0) {
-                            element.setAttribute('href', `#${model.containedObjectIDs[0]}`);
-                        }
-                    }
-                    else {
-                        element.setAttribute('href', `#${auxiliaryObjectReference.referencedObject}`);
-                    }
-                    element.setAttribute('data-reference-ids', crossReferenceNode.attrs.rid);
-                }
+                element.setAttribute('data-reference-ids', crossReferenceNode.attrs.rids.join(' '));
                 element.textContent =
                     crossReferenceNode.attrs.customLabel || crossReferenceNode.attrs.label;
                 return element;

package/dist/es/transformer/node-names.js

@@ -35,6 +35,6 @@ export const nodeNames = new Map([
     [schema.nodes.table_element, 'Table'],
     [schema.nodes.blockquote_element, 'Block Quote'],
     [schema.nodes.pullquote_element, 'Pull Quote'],
-    [schema.nodes.keywords_section, 'Section'],
+    [schema.nodes.keywords, 'Section'],
     [schema.nodes.toc_section, 'Section'],
 ]);

package/dist/es/transformer/node-title.js

@@ -47,7 +47,7 @@ export const nodeTitle = (node) => {
         case nodes.section:
         case nodes.bibliography_section:
         case nodes.footnotes_section:
-        case nodes.keywords_section:
+        case nodes.keywords:
         case nodes.toc_section:
         case nodes.graphical_abstract_section:
             return snippetOfNodeType(node, nodes.section_title);

package/dist/es/transformer/node-types.js

@@ -16,6 +16,9 @@
 import { ObjectTypes } from '@manuscripts/json-schema';
 import { GROUP_ELEMENT, GROUP_EXECUTABLE, GROUP_SECTION, hasGroup, schema, } from '../schema';
 export const nodeTypesMap = new Map([
+    [schema.nodes.abstracts, ObjectTypes.Section],
+    [schema.nodes.body, ObjectTypes.Section],
+    [schema.nodes.backmatter, ObjectTypes.Section],
     [schema.nodes.comment, ObjectTypes.CommentAnnotation],
     [schema.nodes.bibliography_item, ObjectTypes.BibliographyItem],
     [schema.nodes.bibliography_element, ObjectTypes.BibliographyElement],
@@ -23,7 +26,6 @@ export const nodeTypesMap = new Map([
     [schema.nodes.blockquote_element, ObjectTypes.QuoteElement],
     [schema.nodes.bullet_list, ObjectTypes.ListElement],
     [schema.nodes.citation, ObjectTypes.Citation],
-    [schema.nodes.cross_reference, ObjectTypes.AuxiliaryObjectReference],
     [schema.nodes.equation, ObjectTypes.Equation],
     [schema.nodes.equation_element, ObjectTypes.EquationElement],
     [schema.nodes.figure, ObjectTypes.Figure],
@@ -37,8 +39,8 @@ export const nodeTypesMap = new Map([
     [schema.nodes.inline_equation, ObjectTypes.InlineMathFragment],
     [schema.nodes.keyword, ObjectTypes.Keyword],
     [schema.nodes.keywords_element, ObjectTypes.KeywordsElement],
-    [schema.nodes.keywords_section, ObjectTypes.Section],
-    [schema.nodes.keywords_group, ObjectTypes.KeywordGroup],
+    [schema.nodes.keywords, ObjectTypes.Section],
+    [schema.nodes.keyword_group, ObjectTypes.KeywordGroup],
     [schema.nodes.listing, ObjectTypes.Listing],
     [schema.nodes.listing_element, ObjectTypes.ListingElement],
     [schema.nodes.manuscript, ObjectTypes.Manuscript],
@@ -54,9 +56,9 @@ export const nodeTypesMap = new Map([
     [schema.nodes.affiliation, ObjectTypes.Affiliation],
     [schema.nodes.contributor, ObjectTypes.Contributor],
     [schema.nodes.table_element_footer, ObjectTypes.TableElementFooter],
+    [schema.nodes.contributors, ObjectTypes.Section],
+    [schema.nodes.affiliations, ObjectTypes.Section],
     [schema.nodes.title, ObjectTypes.Titles],
-    [schema.nodes.contributors_section, ObjectTypes.Section],
-    [schema.nodes.affiliations_section, ObjectTypes.Section],
 ]);
 export const isExecutableNodeType = (type) => hasGroup(type, GROUP_EXECUTABLE);
 export const isElementNodeType = (type) => hasGroup(type, GROUP_ELEMENT);