@manuscripts/transform 1.5.8 → 2.0.0

package/dist/es/jats/importer/jats-parser-utils.js

@@ -13,30 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes, } from '@manuscripts/json-schema';
-import { generateID, hasObjectType, nodeTypesMap } from '../../transformer';
-const isAuxiliaryObjectReference = hasObjectType(ObjectTypes.AuxiliaryObjectReference);
-const excludedObjectTypes = [ObjectTypes.Contributor, ObjectTypes.Affiliation];
-export function flatten(arrays) {
-    return [].concat(...arrays);
-}
-export const fixBodyPMNode = (output, models, referenceIdsMap = new Map()) => {
-    const replacements = referenceIdsMap;
+import { generateID, nodeTypesMap } from '../../transformer';
+export const updateDocumentIDs = (node, replacements) => {
     const warnings = [];
-    recurseDoc(output, (n) => addMissingID(n, replacements, warnings));
-    recurseDoc(output, (n) => addMissingRID(n, replacements, warnings));
-    return {
-        warnings: [...warnings, ...fixReferences(models, replacements)],
-        replacements,
-    };
+    recurseDoc(node, (n) => updateNodeID(n, replacements, warnings));
+    recurseDoc(node, (n) => updateNodeRID(n, replacements, warnings));
+    recurseDoc(node, (n) => updateNodeRIDS(n, replacements, warnings));
+    return warnings;
 };
 function recurseDoc(node, fn) {
     fn(node);
-    if (node.content) {
-        node.content.forEach((n) => recurseDoc(n, fn));
-    }
+    node.descendants((n) => fn(n));
 }
-const addMissingID = (node, replacements, warnings) => {
+const updateNodeID = (node, replacements, warnings) => {
     if (!('id' in node.attrs)) {
         return;
     }
@@ -45,9 +34,6 @@ const addMissingID = (node, replacements, warnings) => {
         warnings.push(`Unknown object type for node type ${node.type.name}`);
         return;
     }
-    if (excludedObjectTypes.includes(objectType)) {
-        return;
-    }
     const previousID = node.attrs.id;
     const nextID = generateID(objectType);
     if (previousID) {
@@ -60,7 +46,7 @@ const addMissingID = (node, replacements, warnings) => {
     }
     node.attrs = Object.assign(Object.assign({}, node.attrs), { id: nextID });
 };
-const addMissingRID = (node, replacements, warnings) => {
+const updateNodeRID = (node, replacements, warnings) => {
     const previousRID = node.attrs.rid;
     if (!('rid' in node.attrs) || !previousRID) {
         return;
@@ -71,36 +57,12 @@ const addMissingRID = (node, replacements, warnings) => {
         node.attrs = Object.assign(Object.assign({}, node.attrs), { rid: replacements.get(previousRID) });
     }
 };
-const fixReferences = (models, replacements) => {
-    const warnings = [];
-    const getReferenceId = (referencedObject) => {
-        const newReferencedId = replacements.get(referencedObject);
-        if (newReferencedId) {
-            return newReferencedId;
-        }
-        else {
-            warnings.push(`Missing replacement for model.referencedObject ${referencedObject}`);
-        }
-    };
-    models.forEach((model) => {
-        var _a;
-        if (isAuxiliaryObjectReference(model)) {
-            if (model.referencedObject) {
-                model.referencedObject = getReferenceId(model.referencedObject);
-            }
-            else {
-                const referencedObjects = [];
-                (_a = model.referencedObjects) === null || _a === void 0 ? void 0 : _a.map((reference) => {
-                    const referenceId = getReferenceId(reference);
-                    if (referenceId) {
-                        referencedObjects.push(referenceId);
-                    }
-                });
-                model.referencedObjects = referencedObjects;
-            }
-        }
-    });
-    return warnings;
+const updateNodeRIDS = (node, replacements, warnings) => {
+    const previousRIDs = node.attrs.rids;
+    if (!('rids' in node.attrs) || !previousRIDs.length) {
+        return;
+    }
+    node.attrs = Object.assign(Object.assign({}, node.attrs), { rids: previousRIDs.map((r) => replacements.get(r) || r) });
 };
 const JATS_TO_HTML_MAPPING = new Map([
     ['bold', 'b'],
@@ -138,6 +100,6 @@ export const htmlFromJatsNode = (element, createElement) => {
         return undefined;
     }
     const temp = createElement('template');
-    renameJatsNodesToHTML(element, temp.content, createElement);
+    renameJatsNodesToHTML(element, temp, createElement);
     return temp.innerHTML;
 };

package/dist/es/jats/importer/jats-reference-parser.js

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 import { getTrimmedTextContent } from '../../lib/utils';
-import { buildAuxiliaryObjectReference, buildBibliographicDate, buildBibliographicName, buildBibliographyItem, buildCitation, } from '../../transformer/builders';
-import { parseProcessingInstruction } from './jats-comments';
-import { flatten, htmlFromJatsNode } from './jats-parser-utils';
+import { buildBibliographicDate, buildBibliographicName, buildBibliographyItem, } from '../../transformer/builders';
+import { isJATSComment, parseJATSComment } from './jats-comments';
+import { htmlFromJatsNode } from './jats-parser-utils';
+import { References } from './jats-references';
 const chooseBibliographyItemType = (publicationType) => {
     switch (publicationType) {
         case 'book':
@@ -28,37 +29,31 @@ const chooseBibliographyItemType = (publicationType) => {
     }
 };
 export const jatsReferenceParser = {
-    parseReferences(referenceNodes, createElement) {
-        const referenceIDs = new Map();
-        const referenceQueries = new Map();
-        const references = referenceNodes.map((referenceNode) => {
+    parseReferences(elements, createElement) {
+        const references = new References();
+        elements.forEach((element) => {
             var _a;
-            const publicationType = referenceNode.getAttribute('publication-type');
+            const publicationType = element.getAttribute('publication-type');
             const authorNodes = [
-                ...referenceNode.querySelectorAll('person-group[person-group-type="author"] > *'),
+                ...element.querySelectorAll('person-group[person-group-type="author"] > *'),
             ];
             const bibliographyItem = buildBibliographyItem({
                 type: chooseBibliographyItemType(publicationType),
             });
-            const titleNode = referenceNode.querySelector('article-title');
+            const titleNode = element.querySelector('article-title');
             if (titleNode) {
                 bibliographyItem.title = (_a = htmlFromJatsNode(titleNode, createElement)) === null || _a === void 0 ? void 0 : _a.trim();
             }
-            const queriesText = [];
-            const mixedCitation = referenceNode.querySelector('mixed-citation');
+            const comments = [];
+            const mixedCitation = element.querySelector('mixed-citation');
             mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes.forEach((item) => {
-                if (item.nodeType === item.PROCESSING_INSTRUCTION_NODE &&
-                    item.nodeName === 'AuthorQuery') {
-                    const instruction = parseProcessingInstruction(item);
-                    if (instruction) {
-                        const { queryText } = instruction;
-                        queriesText.push(queryText);
+                if (isJATSComment(item)) {
+                    const comment = parseJATSComment(item);
+                    if (comment) {
+                        comments.push(comment);
                     }
                 }
             });
-            if (queriesText.length) {
-                referenceQueries.set(bibliographyItem._id, queriesText);
-            }
             if (authorNodes.length <= 0) {
                 mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes.forEach((item) => {
                     var _a, _b, _c;
@@ -69,34 +64,34 @@ export const jatsReferenceParser = {
                     }
                 });
             }
-            const source = getTrimmedTextContent(referenceNode, 'source');
+            const source = getTrimmedTextContent(element, 'source');
             if (source) {
                 bibliographyItem['container-title'] = source;
             }
-            const volume = getTrimmedTextContent(referenceNode, 'volume');
+            const volume = getTrimmedTextContent(element, 'volume');
             if (volume) {
                 bibliographyItem.volume = volume;
             }
-            const issue = getTrimmedTextContent(referenceNode, 'issue');
+            const issue = getTrimmedTextContent(element, 'issue');
             if (issue) {
                 bibliographyItem.issue = issue;
             }
-            const supplement = getTrimmedTextContent(referenceNode, 'supplement');
+            const supplement = getTrimmedTextContent(element, 'supplement');
             if (supplement) {
                 bibliographyItem.supplement = supplement;
             }
-            const fpage = getTrimmedTextContent(referenceNode, 'fpage');
-            const lpage = getTrimmedTextContent(referenceNode, 'lpage');
+            const fpage = getTrimmedTextContent(element, 'fpage');
+            const lpage = getTrimmedTextContent(element, 'lpage');
             if (fpage) {
                 bibliographyItem.page = lpage ? `${fpage}-${lpage}` : fpage;
             }
-            const year = getTrimmedTextContent(referenceNode, 'year');
+            const year = getTrimmedTextContent(element, 'year');
             if (year) {
                 bibliographyItem.issued = buildBibliographicDate({
                     'date-parts': [[year]],
                 });
             }
-            const doi = getTrimmedTextContent(referenceNode, 'pub-id[pub-id-type="doi"]');
+            const doi = getTrimmedTextContent(element, 'pub-id[pub-id-type="doi"]');
             if (doi) {
                 bibliographyItem.DOI = doi;
             }
@@ -124,59 +119,9 @@ export const jatsReferenceParser = {
             if (authors.length) {
                 bibliographyItem.author = authors;
             }
-            const id = referenceNode.getAttribute('id');
-            if (id) {
-                referenceIDs.set(id, bibliographyItem._id);
-            }
-            return bibliographyItem;
+            const id = element.getAttribute('id');
+            references.add(bibliographyItem, id, comments);
         });
-        return {
-            references,
-            referenceIDs,
-            referenceQueries,
-        };
-    },
-    parseCrossReferences(crossReferenceNodes, referenceIDs) {
-        return flatten(crossReferenceNodes.map((crossReferenceNode) => {
-            const rid = crossReferenceNode.getAttribute('rid');
-            if (!rid) {
-                return [];
-            }
-            const modelNodes = [];
-            const refType = crossReferenceNode.getAttribute('ref-type');
-            switch (refType) {
-                case 'bibr':
-                    {
-                        const rids = rid
-                            .split(/\s+/)
-                            .filter((id) => referenceIDs.has(id))
-                            .map((id) => referenceIDs.get(id));
-                        if (rids.length) {
-                            const citation = buildCitation('', rids);
-                            modelNodes.push(citation);
-                            crossReferenceNode.setAttribute('rid', citation._id);
-                            crossReferenceNode.setAttribute('data-reference-embedded-citation', JSON.stringify(citation.embeddedCitationItems.map(({ _id: id, bibliographyItem }) => ({
-                                id,
-                                bibliographyItem,
-                            }))));
-                        }
-                        else {
-                            crossReferenceNode.removeAttribute('rid');
-                        }
-                    }
-                    break;
-                case 'fn':
-                    break;
-                default:
-                    {
-                        const rids = rid.trim().split(/\s+/);
-                        const auxiliaryObjectReference = buildAuxiliaryObjectReference('', rids);
-                        modelNodes.push(auxiliaryObjectReference);
-                        crossReferenceNode.setAttribute('rid', auxiliaryObjectReference._id);
-                    }
-                    break;
-            }
-            return modelNodes;
-        }));
+        return references;
     },
 };

package/dist/es/jats/importer/jats-references.js

@@ -0,0 +1,30 @@
+export class References {
+    constructor() {
+        this.items = new Map();
+        this.IDs = new Map();
+        this.comments = new Map();
+    }
+    add(item, id, comments) {
+        this.items.set(item._id, item);
+        this.comments.set(item._id, comments);
+        if (id) {
+            this.IDs.set(id, item._id);
+        }
+    }
+    getBibliographyItems() {
+        return [...this.items.values()];
+    }
+    getComments(id) {
+        return this.getValue(id, this.comments) || [];
+    }
+    getValue(id, map) {
+        const value = map.get(id);
+        if (value) {
+            return value;
+        }
+        const id2 = this.IDs.get(id);
+        if (id2) {
+            return map.get(id2);
+        }
+    }
+}

package/dist/es/jats/importer/parse-jats-article.js

@@ -13,220 +13,116 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes, } from '@manuscripts/json-schema';
-import { DOMParser } from 'prosemirror-model';
 import { InvalidInput } from '../../errors';
-import { nodeFromHTML } from '../../lib/html';
-import { schema } from '../../schema';
-import { auxiliaryObjectTypes, nodeTypesMap } from '../../transformer';
-import { buildElementsOrder, buildJournal, buildManuscript, } from '../../transformer/builders';
-import { encode, inlineContents } from '../../transformer/encode';
-import { createEmptyFootnotesOrder, createOrderedFootnotesIDs, handleFootnotesOrder, } from '../../transformer/footnotes-order';
+import { buildBibliographyElement, buildSection, encode, } from '../../transformer';
+import { buildManuscript } from '../../transformer/builders';
 import { generateID } from '../../transformer/id';
 import { findManuscript } from '../../transformer/project-bundle';
 import { jatsBodyDOMParser } from './jats-body-dom-parser';
 import { jatsBodyTransformations } from './jats-body-transformations';
-import { createComments, createReferenceComments, markProcessingInstructions, } from './jats-comments';
+import { createComments, createReferenceComments, markComments, } from './jats-comments';
 import { jatsFrontParser } from './jats-front-parser';
-import { fixBodyPMNode } from './jats-parser-utils';
+import { updateDocumentIDs } from './jats-parser-utils';
 import { jatsReferenceParser } from './jats-reference-parser';
-const parser = DOMParser.fromSchema(schema);
-const inlineContentsFromJATSTitle = (htmlTitle) => {
-    const node = nodeFromHTML(`<h1>${htmlTitle}</h1>`);
-    if (node) {
-        const titleNode = parser.parse(node, {
-            topNode: schema.nodes.section_title.create(),
-        });
-        return inlineContents(titleNode);
-    }
-    throw new InvalidInput('Invalid title content for: ' + htmlTitle);
-};
-export const parseJATSFront = async (front) => {
-    var _a, _b, _c;
-    const journalMeta = jatsFrontParser.parseJournal(front.querySelector('journal-meta'));
-    const journal = Object.assign(Object.assign({}, buildJournal()), journalMeta);
-    const articleMeta = front.querySelector('article-meta');
-    const title = (_a = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('title-group > article-title')) === null || _a === void 0 ? void 0 : _a.innerHTML;
-    const subtitle = (_b = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('title-group > subtitle')) === null || _b === void 0 ? void 0 : _b.innerHTML;
-    const runningTitle = (_c = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('title-group > alt-title[alt-title-type="right-running"]')) === null || _c === void 0 ? void 0 : _c.innerHTML;
-    const manuscriptMeta = Object.assign({}, jatsFrontParser.parseCounts(articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('counts')));
-    const titles = {
-        objectType: ObjectTypes.Titles,
-        _id: generateID(ObjectTypes.Titles),
-        title: title ? inlineContentsFromJATSTitle(title) : undefined,
-        subtitle: subtitle ? inlineContentsFromJATSTitle(subtitle) : undefined,
-        runningTitle: runningTitle
-            ? inlineContentsFromJATSTitle(runningTitle)
-            : undefined,
-    };
-    const { affiliations, affiliationIDs } = jatsFrontParser.parseAffiliationNodes([
+export const parseJATSFront = (doc, front) => {
+    const createElement = createElementFn(doc);
+    const journal = jatsFrontParser.parseJournal(front.querySelector('journal-meta'));
+    const titles = jatsFrontParser.parseTitles(front.querySelector('article-meta > title-group'), createElement);
+    const { affiliations, affiliationIDs } = jatsFrontParser.parseAffiliations([
         ...front.querySelectorAll('article-meta > contrib-group > aff'),
     ]);
-    const { footnotes, footnoteIDs } = jatsFrontParser.parseFootnoteNodes([
+    const { footnotes, footnoteIDs } = jatsFrontParser.parseAuthorNotes([
         ...front.querySelectorAll('article-meta > author-notes > fn:not([fn-type])'),
     ]);
-    const { correspondingList, correspondingIDs } = jatsFrontParser.parseCorrespNodes([
+    const { correspondingList, correspondingIDs } = jatsFrontParser.parseCorresp([
         ...front.querySelectorAll('article-meta > author-notes > corresp'),
     ]);
-    const authors = jatsFrontParser.parseAuthorNodes([
+    const authors = jatsFrontParser.parseContributors([
         ...front.querySelectorAll('article-meta > contrib-group > contrib[contrib-type="author"]'),
     ], affiliationIDs, footnoteIDs, correspondingIDs);
-    const history = jatsFrontParser.parseDates(front.querySelector('article-meta > history'));
     const supplements = jatsFrontParser.parseSupplements([
         ...front.querySelectorAll('article-meta > supplementary-material'),
     ]);
-    const manuscript = Object.assign(Object.assign(Object.assign({}, buildManuscript()), manuscriptMeta), history);
-    return {
-        models: generateModelIDs([
-            titles,
-            manuscript,
-            ...footnotes,
-            ...correspondingList,
-            journal,
-            ...supplements,
-        ]),
-        authors: [...authors],
-        affiliations: [...affiliations],
-    };
-};
-export const parseJATSReferences = (back, body, createElement) => {
-    const bibliographyItems = [];
-    const crossReferences = [];
-    let referenceQueriesMap;
-    let referenceIdsMap;
-    if (back) {
-        const { references, referenceIDs, referenceQueries } = jatsReferenceParser.parseReferences([...back.querySelectorAll('ref-list > ref')], createElement);
-        bibliographyItems.push(...references);
-        referenceQueriesMap = new Map([...referenceQueries]);
-        referenceIdsMap = new Map([...referenceIDs]);
-        if (body) {
-            crossReferences.push(...jatsReferenceParser.parseCrossReferences([...body.querySelectorAll('xref'), ...back.querySelectorAll('xref')], referenceIDs));
-        }
-    }
-    return {
-        references: generateModelIDs(bibliographyItems),
-        crossReferences: generateModelIDs(crossReferences),
-        referenceQueriesMap,
-        referenceIdsMap,
-    };
+    const history = jatsFrontParser.parseDates(front.querySelector('article-meta > history'));
+    const counts = jatsFrontParser.parseCounts(front.querySelector('article-meta counts'));
+    const manuscript = Object.assign(Object.assign(Object.assign({}, buildManuscript()), counts), history);
+    return generateIDs([
+        manuscript,
+        titles,
+        journal,
+        ...footnotes,
+        ...authors,
+        ...affiliations,
+        ...correspondingList,
+        ...supplements,
+    ]);
 };
-export const parseJATSBody = (document, body, bibliographyItems, authors, affiliations, refModels, referenceIdsMap, footnotesOrder) => {
-    const createElement = createElementFn(document);
-    const orderedFootnotesIDs = createOrderedFootnotesIDs(document);
-    jatsBodyTransformations.moveFloatsGroupToBody(document, body, createElement);
+export const parseJATSBody = (doc, body, references) => {
+    const createElement = createElementFn(doc);
     jatsBodyTransformations.ensureSection(body, createElement);
-    jatsBodyTransformations.moveSectionsToBody(document, body, bibliographyItems, createElement);
     jatsBodyTransformations.moveCaptionsToEnd(body);
+    jatsBodyTransformations.fixTables(body, createElement);
     jatsBodyTransformations.moveTableFooterToEnd(body);
-    jatsBodyTransformations.moveBlockNodesFromParagraph(document, body, createElement);
-    jatsBodyTransformations.moveKeywordsToBody(document, body, createElement);
-    jatsBodyTransformations.moveAffiliationsToBody(document, affiliations, body, createElement);
-    jatsBodyTransformations.moveAuthorsToBody(document, authors, body, createElement);
-    const node = jatsBodyDOMParser.parse(body);
-    if (!node.firstChild) {
+    jatsBodyTransformations.createBody(doc, body, createElement);
+    jatsBodyTransformations.createAbstracts(doc, body, createElement);
+    jatsBodyTransformations.createBackmatter(doc, body, createElement);
+    jatsBodyTransformations.createKeywords(doc, body, createElement);
+    const node = jatsBodyDOMParser.parse(body).firstChild;
+    if (!node) {
         throw new Error('No content was parsed from the JATS article body');
     }
-    const { replacements } = fixBodyPMNode(node.firstChild, refModels, referenceIdsMap);
-    if (footnotesOrder) {
-        handleFootnotesOrder(orderedFootnotesIDs, replacements, footnotesOrder);
-    }
-    return node.firstChild;
+    const replacements = new Map(references === null || references === void 0 ? void 0 : references.IDs);
+    updateDocumentIDs(node, replacements);
+    return encode(node).values();
 };
-const transformTables = (tables, createElement) => {
-    tables.forEach((table) => {
-        const colgroup = table.querySelector('colgroup');
-        const cols = table.querySelectorAll('col');
-        if (!colgroup && table.firstChild && cols.length > 0) {
-            const colgroup = createElement('colgroup');
-            for (const col of cols) {
-                colgroup.appendChild(col);
-            }
-            table.insertBefore(colgroup, table.firstChild);
-        }
-        const tbody = table.querySelector('tbody');
-        if (tbody) {
-            const headerRow = table.querySelector('thead > tr');
-            if (!headerRow) {
-                const tr = createElement('tr');
-                tbody.insertBefore(tr, tbody.firstElementChild);
-            }
-            const footerRow = table.querySelector('tfoot > tr');
-            if (!footerRow) {
-                const tr = createElement('tr');
-                tbody.appendChild(tr);
-            }
-        }
-    });
+const createBibliographyModels = (references) => {
+    const models = [];
+    const bibliographyItems = references.getBibliographyItems();
+    const bibliographyElement = buildBibliographyElement(bibliographyItems);
+    const bibliographySection = Object.assign(Object.assign({}, buildSection(99)), { category: 'MPSectionCategory:bibliography', elementIDs: [bibliographyElement._id], title: 'References' });
+    const comments = createReferenceComments(references);
+    models.push(bibliographySection);
+    models.push(bibliographyElement);
+    models.push(...bibliographyItems);
+    models.push(...comments);
+    return models;
 };
 const createElementFn = (doc) => (tagName) => doc.createElement(tagName);
-const generateModelIDs = (models) => models.map((m) => m._id ? m : Object.assign(Object.assign({}, m), { _id: generateID(m.objectType) }));
-export const parseJATSArticle = async (doc) => {
-    const articleElement = doc.querySelector('article');
+const generateIDs = (models) => models.map((m) => m._id ? m : Object.assign(Object.assign({}, m), { _id: generateID(m.objectType) }));
+export const parseJATSArticle = (doc) => {
+    const article = doc.querySelector('article');
     const front = doc.querySelector('front');
     const body = doc.querySelector('body');
     const back = doc.querySelector('back');
     if (!front) {
         throw new InvalidInput('Invalid JATS format! Missing front element');
     }
-    if (!articleElement) {
+    if (!article) {
         throw new InvalidInput('Invalid JATS format! Missing article element');
     }
-    const authorQueriesMap = markProcessingInstructions(doc);
-    const createElement = createElementFn(document);
-    const { models: frontModels, authors, affiliations, } = await parseJATSFront(front);
-    const { references, crossReferences, referenceQueriesMap, referenceIdsMap } = parseJATSReferences(back, body, createElement);
-    transformTables(doc.querySelectorAll('table-wrap > table'), createElement);
-    const footnotesOrder = createEmptyFootnotesOrder();
-    let elementsOrder = [];
-    const bodyModels = [];
+    const marks = markComments(doc);
+    const createElement = createElementFn(doc);
+    const models = [];
+    let references;
+    if (back) {
+        references = jatsReferenceParser.parseReferences([...back.querySelectorAll('ref-list > ref')], createElement);
+    }
+    models.push(...parseJATSFront(doc, front));
     if (body) {
-        const bodyDoc = parseJATSBody(doc, body, references, authors, affiliations, crossReferences, referenceIdsMap, footnotesOrder);
-        bodyModels.push(...encode(bodyDoc).values());
-        elementsOrder = getElementsOrder(bodyDoc);
+        models.push(...parseJATSBody(doc, body, references));
     }
-    const frontModelsMap = new Map(frontModels.map((model) => [model._id, model]));
-    const manuscript = findManuscript(frontModelsMap);
+    const modelMap = new Map(models.map((model) => [model._id, model]));
+    const manuscript = findManuscript(modelMap);
     if (manuscript) {
-        const articleType = articleElement.getAttribute('article-type');
-        manuscript.articleType = articleType || 'other';
+        const type = article.getAttribute('article-type');
+        manuscript.articleType = type || 'other';
     }
-    const models = [
-        ...frontModels,
-        ...bodyModels,
-        ...crossReferences,
-        ...elementsOrder,
-    ];
-    if (footnotesOrder.footnotesList.length > 0) {
-        models.push(footnotesOrder);
+    if (references) {
+        models.push(...createBibliographyModels(references));
     }
-    if (authorQueriesMap.size) {
-        const commentAnnotations = createComments(authorQueriesMap, models);
-        models.push(...commentAnnotations);
+    if (marks.length) {
+        const comments = createComments(models, marks);
+        models.push(...comments);
     }
-    if (referenceQueriesMap && referenceQueriesMap.size) {
-        const commentAnnotations = createReferenceComments(referenceQueriesMap, references);
-        models.push(...commentAnnotations);
-    }
-    return models;
-};
-export const getElementsOrder = (node) => {
-    const elementsOrderIndex = new Map();
-    const models = [];
-    node.descendants((child) => {
-        const type = child.type;
-        if (auxiliaryObjectTypes.has(type)) {
-            const index = elementsOrderIndex.get(type);
-            if (index !== undefined) {
-                const elementsOrder = models[index];
-                elementsOrder.elements.push(child.attrs['id']);
-            }
-            else {
-                const elementsOrder = buildElementsOrder(nodeTypesMap.get(type));
-                elementsOrder.elements.push(child.attrs['id']);
-                models.push(elementsOrder);
-                elementsOrderIndex.set(type, elementsOrderIndex.size);
-            }
-        }
-    });
     return models;
 };

package/dist/es/jats/index.js

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { parseJATSFront, parseJATSReferences, parseJATSBody, parseJATSArticle, getElementsOrder, } from './importer';
+export { parseJATSFront, parseJATSBody, parseJATSArticle } from './importer';
 export * from './jats-exporter';
 export * from './jats-versions';