@manuscripts/transform 2.6.0 → 2.6.1-LEAN-3966.1

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

@@ -14,26 +14,38 @@
  * limitations under the License.
  */
 import { v4 as uuidv4 } from 'uuid';
-import { schema } from '../../schema';
-import { generateID, nodeTypesMap } from '../../transformer';
-export const updateDocumentIDs = (node, replacements) => {
+import { schema, } from '../../schema';
+import { generateNodeID, nodeTypesMap } from '../../transformer';
+const nonJSONSchemaTypes = new Set([
+    'inline_equation',
+    'general_table_footnote',
+    'award',
+]);
+export const updateDocumentIDs = (node) => {
+    const replacements = new Map();
     const warnings = [];
     recurseDoc(node, (n) => updateNodeID(n, replacements, warnings));
+    updateHighlightCommentTargets(node);
     recurseDoc(node, (n) => updateNodeRID(n, replacements, warnings));
     recurseDoc(node, (n) => updateNodeRIDS(n, replacements, warnings));
+    recurseDoc(node, (n) => updateContributorNodesIDS(n, replacements, warnings));
+    recurseDoc(node, (n) => updateCommentTarget(n, replacements, warnings));
     return warnings;
 };
-function recurseDoc(node, fn) {
+const recurseDoc = (node, fn) => {
     fn(node);
     node.descendants((n) => fn(n));
-}
+};
 const updateNodeID = (node, replacements, warnings) => {
-    if (node.type === schema.nodes.inline_equation) {
-        node.attrs = Object.assign(Object.assign({}, node.attrs), { id: `InlineMathFragment:${uuidv4()}` });
-        return;
+    if (nonJSONSchemaTypes.has(node.type.name)) {
+        const id = `${node.type.name
+            .split('_')
+            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('')}:${uuidv4()}`;
+        node.attrs = Object.assign(Object.assign({}, node.attrs), { id });
     }
-    if (node.type === schema.nodes.general_table_footnote) {
-        node.attrs = Object.assign(Object.assign({}, node.attrs), { id: `GeneralTableFootnote:${uuidv4()}` });
+    if (node.type === schema.nodes.comment ||
+        node.type === schema.nodes.highlight_marker) {
         return;
     }
     if (!('id' in node.attrs)) {
@@ -45,7 +57,7 @@ const updateNodeID = (node, replacements, warnings) => {
         return;
     }
     const previousID = node.attrs.id;
-    const nextID = generateID(objectType);
+    const nextID = generateNodeID(node.type);
     if (previousID) {
         if (replacements.has(previousID) ||
             Array.from(replacements.values()).includes(previousID)) {
@@ -74,6 +86,58 @@ const updateNodeRIDS = (node, replacements, warnings) => {
     }
     node.attrs = Object.assign(Object.assign({}, node.attrs), { rids: previousRIDs.map((r) => replacements.get(r) || r) });
 };
+const updateContributorNodesIDS = (node, replacements, warnings) => {
+    var _a, _b;
+    if (node.type === schema.nodes.contributor) {
+        const footnote = (_a = node.attrs.footnote) === null || _a === void 0 ? void 0 : _a.map((fn) => {
+            return replacements.get(fn.noteID)
+                ? Object.assign(Object.assign({}, fn), { noteID: replacements.get(fn.noteID) }) : undefined;
+        }).filter(Boolean);
+        const corresp = (_b = node.attrs.corresp) === null || _b === void 0 ? void 0 : _b.map((corresp) => {
+            return replacements.get(corresp.correspID)
+                ? Object.assign(Object.assign({}, corresp), { correspID: replacements.get(corresp.correspID) }) : undefined;
+        }).filter(Boolean);
+        const affiliations = node.attrs.affiliations
+            .map((affiliation) => {
+            return replacements.get(affiliation);
+        })
+            .filter(Boolean);
+        node.attrs = Object.assign(Object.assign({}, node.attrs), { footnote,
+            corresp,
+            affiliations });
+    }
+    if (node.type !== schema.nodes.contributors) {
+        return false;
+    }
+};
+const updateCommentTarget = (node, replacements, warnings) => {
+    if (node.type !== schema.nodes.comment) {
+        return;
+    }
+    const target = node.attrs.target;
+    if (!target) {
+        return;
+    }
+    if (!replacements.has(target)) {
+    }
+    else {
+        node.attrs = Object.assign(Object.assign({}, node.attrs), { target: replacements.get(target) });
+    }
+};
+const updateHighlightCommentTargets = (doc) => {
+    const targetIDs = new Map();
+    doc.descendants((node, pos, parent) => {
+        if (node.type === schema.nodes.highlight_marker) {
+            targetIDs.set(node.attrs.id, parent.attrs.id);
+        }
+        if (node.type === schema.nodes.comment) {
+            const targetID = targetIDs.get(node.attrs.id);
+            if (targetID) {
+                node.attrs = Object.assign(Object.assign({}, node.attrs), { target: targetID });
+            }
+        }
+    });
+};
 const JATS_TO_HTML_MAPPING = new Map([
     ['bold', 'b'],
     ['italic', 'i'],
@@ -109,6 +173,9 @@ export const htmlFromJatsNode = (element, createElement) => {
     if (!element) {
         return undefined;
     }
+    if (!createElement) {
+        createElement = (tagName) => element.ownerDocument.createElement(tagName);
+    }
     const temp = createElement('template');
     renameJatsNodesToHTML(element, temp, createElement);
     return temp.innerHTML;

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

@@ -0,0 +1,377 @@
+/*!
+ * © 2020 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { defaultTitle } from '../../lib/deafults';
+import { abstractsType, backmatterType, bodyType, } from '../../lib/section-group-type';
+import { chooseSectionCategoryByType, chooseSecType } from '../../transformer';
+import { htmlFromJatsNode } from './jats-parser-utils';
+const removeNodeFromParent = (node) => node.parentNode && node.parentNode.removeChild(node);
+const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+const createSectionGroup = (type, createElement) => {
+    const sec = createElement('sec');
+    sec.setAttribute('sec-type', type._id);
+    const title = createElement('title');
+    title.textContent = type.title;
+    sec.appendChild(title);
+    return sec;
+};
+export const ensureSection = (body, createElement) => {
+    let section;
+    const element = body.firstElementChild;
+    if (element && element.tagName === 'sec') {
+        section = element;
+    }
+    else {
+        section = createElement('sec');
+        body.insertBefore(section, body.firstChild);
+    }
+    body.childNodes.forEach((child) => {
+        if (child.nodeType === Node.ELEMENT_NODE) {
+            const element = child;
+            if (element.tagName !== 'sec') {
+                section.appendChild(element);
+            }
+            else {
+                section = element;
+            }
+        }
+    });
+};
+export const moveTitle = (front, createElement) => {
+    var _a, _b;
+    let title = front.querySelector('article-meta > title-group > article-title');
+    if (title) {
+        title.innerHTML = (_a = htmlFromJatsNode(title, createElement)) !== null && _a !== void 0 ? _a : defaultTitle;
+    }
+    else {
+        title = createElement('article-title');
+        title.innerHTML = defaultTitle;
+    }
+    (_b = front.parentNode) === null || _b === void 0 ? void 0 : _b.insertBefore(title, front);
+};
+export const moveAuthorNotes = (front, createElement) => {
+    var _a;
+    const authorNotes = front.querySelector('article-meta > author-notes');
+    if (authorNotes) {
+        const sectionTitle = createElement('title');
+        authorNotes.prepend(sectionTitle);
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(authorNotes, front);
+    }
+};
+export const moveAwards = (front) => {
+    var _a;
+    const awards = front.querySelector('article-meta > funding-group');
+    if (awards) {
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(awards, front);
+    }
+};
+export const moveContributors = (front, createElement) => {
+    var _a;
+    const contribs = front.querySelectorAll('contrib-group > contrib[contrib-type="author"]');
+    if (contribs.length) {
+        const contributors = createElement('contributors');
+        contribs.forEach((c) => contributors.appendChild(c));
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(contributors, front);
+    }
+};
+export const moveAffiliations = (front, createElement) => {
+    var _a;
+    const affs = front.querySelectorAll('article-meta > contrib-group > aff');
+    if (affs.length) {
+        const affiliations = createElement('affiliations');
+        affs.forEach((a) => affiliations.appendChild(a));
+        (_a = front.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(affiliations, front);
+    }
+};
+export const moveAbstracts = (doc, group, createElement) => {
+    const abstracts = doc.querySelectorAll('front > article-meta > abstract');
+    abstracts.forEach((abstract) => {
+        const sec = createAbstractSection(abstract, createElement);
+        removeNodeFromParent(abstract);
+        group.appendChild(sec);
+    });
+};
+export const createBoxedElementSection = (body, createElement) => {
+    const boxedTexts = body.querySelectorAll('boxed-text');
+    for (const boxedText of boxedTexts) {
+        const boxElementSec = createElement('sec');
+        boxElementSec.setAttribute('sec-type', 'box-element');
+        const title = createElement('title');
+        title.textContent = 'BoxElement';
+        boxElementSec.append(title);
+        for (const element of [...boxedText.children]) {
+            if ((element === null || element === void 0 ? void 0 : element.tagName) === 'label' || (element === null || element === void 0 ? void 0 : element.tagName) === 'caption') {
+                boxElementSec.append(element);
+            }
+        }
+        const containerSection = createElement('sec');
+        containerSection.append(...boxedText.children);
+        boxElementSec.append(containerSection);
+        boxedText.replaceWith(boxElementSec);
+    }
+};
+export const createBody = (doc, body, createElement) => {
+    const group = createSectionGroup(bodyType, createElement);
+    const sections = doc.querySelectorAll('body > sec:not([sec-type="backmatter"]), body > sec:not([sec-type])');
+    sections.forEach((section) => {
+        removeNodeFromParent(section);
+        group.appendChild(section);
+    });
+    moveFloatsGroupToBody(doc, group, createElement);
+    body.append(group);
+};
+export const createAbstracts = (doc, body, createElement) => {
+    const group = createSectionGroup(abstractsType, createElement);
+    moveAbstracts(doc, group, createElement);
+    body.insertBefore(group, body.lastElementChild);
+};
+export const createBackmatter = (doc, body, createElement) => {
+    const group = createSectionGroup(backmatterType, createElement);
+    moveBackSections(doc, group);
+    moveAppendices(doc, group, createElement);
+    moveSpecialFootnotes(doc, group, createElement);
+    moveFootnotes(doc, group, createElement);
+    moveAcknowledgments(doc, group, createElement);
+    body.append(group);
+};
+const moveFootnotes = (doc, group, createElement) => {
+    var _a;
+    const fns = [
+        ...doc.querySelectorAll('fn:not(table-wrap-foot fn, author-notes fn)'),
+    ];
+    let section = doc.querySelector('sec[sec-type="endnotes"]');
+    const fnGroup = (section === null || section === void 0 ? void 0 : section.querySelector('fn-group')) || createElement('fn-group');
+    fns.forEach((fn) => {
+        if (!fn.getAttribute('fn-type')) {
+            fnGroup.appendChild(fn);
+        }
+    });
+    if (!section && fnGroup.innerHTML) {
+        section = createFootnotesSection([fnGroup], createElement);
+    }
+    if (section) {
+        group.insertBefore(section, ((_a = group.firstChild) === null || _a === void 0 ? void 0 : _a.nextSibling) || group.firstChild);
+    }
+};
+const moveSpecialFootnotes = (doc, group, createElement) => {
+    var _a;
+    const fns = [...doc.querySelectorAll('fn[fn-type]')];
+    for (const fn of fns) {
+        const type = fn.getAttribute('fn-type') || '';
+        const category = chooseSectionCategoryByType(type);
+        if (category) {
+            const section = createElement('sec');
+            const fnTitle = fn.querySelector('p[content-type="fn-title"]');
+            if (fnTitle) {
+                const title = createElement('title');
+                const titleText = (_a = fnTitle.textContent) === null || _a === void 0 ? void 0 : _a.trim();
+                if (titleText) {
+                    title.textContent = titleText;
+                }
+                removeNodeFromParent(fnTitle);
+                section.append(title);
+            }
+            section.append(...fn.children);
+            removeNodeFromParent(fn);
+            section.setAttribute('sec-type', chooseSecType(category));
+            group.append(section);
+        }
+    }
+};
+export const moveCaptionsToEnd = (body) => {
+    const captions = body.querySelectorAll('caption');
+    for (const caption of captions) {
+        if (caption.parentNode &&
+            caption.parentNode.nodeName !== 'table-wrap' &&
+            caption.parentNode.nodeName !== 'boxed-text') {
+            caption.parentNode.appendChild(caption);
+        }
+    }
+};
+const createAbstractSection = (abstract, createElement) => {
+    const abstractType = abstract.getAttribute('abstract-type');
+    const section = createElement('sec');
+    const sectionType = abstractType ? `abstract-${abstractType}` : 'abstract';
+    section.setAttribute('sec-type', sectionType);
+    if (!abstract.querySelector(':scope > title')) {
+        const title = createElement('title');
+        title.textContent = abstractType
+            ? `${capitalizeFirstLetter(abstractType)} Abstract`
+            : 'Abstract';
+        section.appendChild(title);
+    }
+    while (abstract.firstChild) {
+        section.appendChild(abstract.firstChild);
+    }
+    return section;
+};
+const createAcknowledgmentsSection = (ack, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'acknowledgments');
+    if (!ack.querySelector('title')) {
+        const title = createElement('title');
+        title.textContent = 'Acknowledgements';
+        section.appendChild(title);
+    }
+    while (ack.firstChild) {
+        section.appendChild(ack.firstChild);
+    }
+    return section;
+};
+const createFootnotesSection = (fnGroups, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'endnotes');
+    const titleNode = fnGroups
+        .map((g) => g.querySelector('title'))
+        .filter((t) => t !== null)[0];
+    if (titleNode) {
+        section.appendChild(titleNode);
+    }
+    else {
+        const title = createElement('title');
+        title.textContent = 'Footnotes';
+        section.appendChild(title);
+    }
+    for (const fnGroup of fnGroups) {
+        section.appendChild(fnGroup);
+    }
+    return section;
+};
+const createAppendicesSection = (app, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'appendices');
+    section.append(...app.children);
+    return section;
+};
+const createFloatsGroupSection = (floatsGroup, createElement) => {
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'floating-element');
+    const title = createElement('title');
+    title.textContent = 'Floating Group';
+    section.appendChild(title);
+    section.append(...floatsGroup.children);
+    return section;
+};
+const moveBackSections = (doc, group) => {
+    for (const section of doc.querySelectorAll('back > sec')) {
+        removeNodeFromParent(section);
+        group.appendChild(section);
+    }
+};
+const moveAcknowledgments = (doc, group, createElement) => {
+    const ack = doc.querySelector('back > ack');
+    if (ack) {
+        const section = createAcknowledgmentsSection(ack, createElement);
+        removeNodeFromParent(ack);
+        group.appendChild(section);
+    }
+};
+const moveAppendices = (doc, group, createElement) => {
+    const apps = doc.querySelectorAll('back > app-group > app');
+    for (const app of apps) {
+        const section = createAppendicesSection(app, createElement);
+        removeNodeFromParent(app);
+        group.appendChild(section);
+    }
+};
+const moveFloatsGroupToBody = (doc, body, createElement) => {
+    const floatsGroup = doc.querySelector('floats-group');
+    if (floatsGroup) {
+        const sec = createFloatsGroupSection(floatsGroup, createElement);
+        removeNodeFromParent(floatsGroup);
+        body.appendChild(sec);
+    }
+};
+export const createKeywordsSection = (document, body, createElement) => {
+    const kwdGroups = [...document.querySelectorAll('kwd-group')];
+    if (kwdGroups.length > 0) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'keywords');
+        const title = createElement('title');
+        title.textContent = 'Keywords';
+        section.append(title);
+        const kwdGroupList = createElement('kwd-group-list');
+        kwdGroupList.append(kwdGroups[0]);
+        section.append(kwdGroupList);
+        body.prepend(section);
+    }
+};
+export const createSupplementaryMaterialsSection = (document, body, createElement) => {
+    const suppls = [
+        ...document.querySelectorAll('article-meta > supplementary-material'),
+    ];
+    if (suppls.length) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'supplementary-material');
+        const title = createElement('title');
+        title.textContent = 'Supplementary Material';
+        section.append(title);
+        section.append(...suppls);
+        body.prepend(section);
+    }
+};
+export const moveReferencesToBackmatter = (body, back, createElement) => {
+    const backmatter = body.querySelector('sec[sec-type="backmatter"]');
+    const refList = back.querySelector('ref-list');
+    if (!backmatter || !refList) {
+        return;
+    }
+    removeNodeFromParent(refList);
+    const section = createElement('sec');
+    section.setAttribute('sec-type', 'bibliography');
+    const title = createElement('title');
+    title.textContent = 'References';
+    section.appendChild(title);
+    section.appendChild(refList);
+    backmatter.appendChild(section);
+};
+export const orderTableFootnote = (doc, body) => {
+    const rids = new Set([...body.querySelectorAll('tbody > xref[ref-type="fn"]')].map((xref) => xref.getAttribute('rid')));
+    const fnGroups = doc.querySelectorAll('table-wrap-foot > fn-group');
+    fnGroups.forEach((fnGroup) => {
+        const fns = [...fnGroup.querySelectorAll('fn')].sort((fn) => rids.has(fn.getAttribute('id')) ? -1 : 0);
+        fnGroup.replaceChildren(...fns);
+    });
+};
+export const fixTables = (doc, body, createElement) => {
+    const tableWraps = body.querySelectorAll('table-wrap');
+    tableWraps.forEach((tableWrap) => {
+        const table = tableWrap.querySelector('table');
+        if (!table) {
+            return;
+        }
+        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);
+            }
+            tableWrap.insertBefore(colgroup, table.nextSibling);
+        }
+        const tableFootWrap = tableWrap.querySelector('table-wrap-foot');
+        if (tableFootWrap) {
+            const paragraphs = tableFootWrap.querySelectorAll(':scope > p');
+            if (paragraphs.length) {
+                const generalTableFootnote = createElement('general-table-footnote');
+                for (const paragraph of paragraphs) {
+                    removeNodeFromParent(paragraph);
+                    generalTableFootnote.append(paragraph);
+                }
+                tableFootWrap.prepend(generalTableFootnote);
+            }
+        }
+    });
+};

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

@@ -13,112 +13,57 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { InvalidInput } from '../../errors';
-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, markComments, } from './jats-comments';
-import { jatsFrontParser } from './jats-front-parser';
+import { markComments } from './jats-comments';
+import { jatsDOMParser } from './jats-dom-parser';
+import { parseJournal } from './jats-journal-meta-parser';
 import { updateDocumentIDs } from './jats-parser-utils';
-import { jatsReferenceParser } from './jats-reference-parser';
-export const parseJATSFront = (doc, front) => {
+import { createAbstracts, createBackmatter, createBody, createBoxedElementSection, createKeywordsSection, createSupplementaryMaterialsSection, ensureSection, fixTables, moveAffiliations, moveAuthorNotes, moveAwards, moveCaptionsToEnd, moveContributors, moveReferencesToBackmatter, moveTitle, orderTableFootnote, } from './jats-transformations';
+const processJATS = (doc) => {
     const createElement = createElementFn(doc);
-    const journal = jatsFrontParser.parseJournal(front.querySelector('journal-meta'));
-    const titles = jatsFrontParser.parseTitles(front.querySelector('article-meta > title-group'), createElement);
-    const DOI = jatsFrontParser.parseDOI(front);
-    const { affiliations, affiliationIDs } = jatsFrontParser.parseAffiliations([
-        ...front.querySelectorAll('article-meta > contrib-group > aff'),
-    ]);
-    const { footnotes, footnoteIDs, authorNotes, authorNotesParagraphs, correspondingIDs, correspondingList, } = jatsFrontParser.parseAuthorNotes(front.querySelector('article-meta > author-notes'));
-    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 counts = jatsFrontParser.parseCounts(front.querySelector('article-meta counts'));
-    const manuscript = Object.assign(Object.assign(Object.assign(Object.assign({}, buildManuscript()), counts), history), { DOI });
-    return generateIDs([
-        manuscript,
-        titles,
-        journal,
-        ...authorNotesParagraphs,
-        ...authorNotes,
-        ...footnotes,
-        ...authors,
-        ...affiliations,
-        ...correspondingList,
-    ]);
-};
-export const parseJATSBody = (doc, body, references) => {
-    const createElement = createElementFn(doc);
-    jatsBodyTransformations.ensureSection(body, createElement);
-    jatsBodyTransformations.moveCaptionsToEnd(body);
-    jatsBodyTransformations.fixTables(body, createElement);
-    jatsBodyTransformations.createBoxedElementSection(doc, body, createElement);
-    jatsBodyTransformations.createBody(doc, body, createElement);
-    jatsBodyTransformations.createAbstracts(doc, body, createElement);
-    jatsBodyTransformations.createBackmatter(doc, body, createElement);
-    jatsBodyTransformations.createSuppleMaterials(doc, body, createElement);
-    jatsBodyTransformations.createKeywords(doc, body, createElement);
-    jatsBodyTransformations.orderTableFootnote(doc, body);
-    const node = jatsBodyDOMParser.parse(body).firstChild;
-    if (!node) {
-        throw new Error('No content was parsed from the JATS article body');
-    }
-    const replacements = new Map(references === null || references === void 0 ? void 0 : references.IDs);
-    updateDocumentIDs(node, replacements);
-    return encode(node).values();
-};
-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 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');
+    markComments(doc);
     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');
+        return;
     }
-    if (!article) {
-        throw new InvalidInput('Invalid JATS format! Missing article element');
-    }
-    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) {
-        models.push(...parseJATSBody(doc, body, references));
+    moveTitle(front, createElement);
+    moveContributors(front, createElement);
+    moveAffiliations(front, createElement);
+    moveAuthorNotes(front, createElement);
+    moveAwards(front);
+    const body = doc.querySelector('body');
+    if (!body) {
+        return;
     }
-    const modelMap = new Map(models.map((model) => [model._id, model]));
-    const manuscript = findManuscript(modelMap);
-    if (manuscript) {
-        const type = article.getAttribute('article-type');
-        manuscript.articleType = type || 'other';
+    ensureSection(body, createElement);
+    moveCaptionsToEnd(body);
+    createBoxedElementSection(body, createElement);
+    createBody(doc, body, createElement);
+    createAbstracts(doc, body, createElement);
+    createBackmatter(doc, body, createElement);
+    createSupplementaryMaterialsSection(doc, body, createElement);
+    createKeywordsSection(doc, body, createElement);
+    fixTables(doc, body, createElement);
+    orderTableFootnote(doc, body);
+    const back = doc.querySelector('back');
+    if (!back) {
+        return;
     }
-    if (references && references.items.size) {
-        models.push(...createBibliographyModels(references));
+    moveReferencesToBackmatter(body, back, createElement);
+};
+const createElementFn = (doc) => (tagName) => doc.createElement(tagName);
+export const parseJATSArticle = (doc, template) => {
+    const journal = parseJournal(doc);
+    processJATS(doc);
+    const node = jatsDOMParser.parse(doc).firstChild;
+    if (!node) {
+        throw new Error('No content was parsed from the JATS article body');
     }
-    if (marks.length) {
-        const comments = createComments(models, marks);
-        models.push(...comments);
+    updateDocumentIDs(node);
+    if (template) {
+        node.attrs.prototype = template;
     }
-    return models;
+    return {
+        node,
+        journal,
+    };
 };

package/dist/es/jats/index.js

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