@manuscripts/transform 2.3.38-LEAN-3911.0 → 2.4.0

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

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes } from '@manuscripts/json-schema';
-import { generateID } from '../../transformer';
-export const DEFAULT_PROFILE_ID = 'MPUserProfile:0000000000000000000000000000000000000001';
+import { v4 as uuidv4 } from 'uuid';
+import { buildComment, buildContribution, highlightableFields, isHighlightableModel, isKeyword, } from '../../transformer';
+const DEFAULT_PROFILE_ID = 'MPUserProfile:0000000000000000000000000000000000000001';
 export const isJATSComment = (node) => {
     return (node.nodeType === node.PROCESSING_INSTRUCTION_NODE &&
         node.nodeName === 'AuthorQuery');
@@ -23,33 +23,34 @@ export const isJATSComment = (node) => {
 export const parseJATSComment = (node) => {
     const text = node.textContent;
     if (text) {
+        const id = /id="(.+)"/.exec(text);
         const queryText = /queryText="(.+)"/.exec(text);
-        if (queryText) {
-            const parentNode = node.parentNode;
-            const index = parentNode.outerHTML.indexOf(queryText[1]);
+        if (id && queryText) {
             return {
-                id: generateID(ObjectTypes.CommentAnnotation),
+                id: id[1],
                 text: queryText[1],
-                index,
             };
         }
     }
 };
 export const markComments = (doc) => {
-    var _a;
+    const marks = [];
     const root = doc.getRootNode();
     const queue = [root];
-    const commentsElement = doc.createElement('comments-annotations');
     while (queue.length !== 0) {
         const node = queue.shift();
         if (node) {
             if (isJATSComment(node)) {
                 const comment = parseJATSComment(node);
                 if (comment) {
-                    const highlightMarker = createHighlightMarkerElement(doc, comment.id);
-                    (_a = node.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(highlightMarker, node);
-                    const commentElement = createCommentElement(doc, comment);
-                    commentsElement.appendChild(commentElement);
+                    const token = addMark(doc, node);
+                    if (token) {
+                        const mark = {
+                            token,
+                            comment,
+                        };
+                        marks.push(mark);
+                    }
                 }
             }
             node.childNodes.forEach((child) => {
@@ -57,19 +58,93 @@ export const markComments = (doc) => {
             });
         }
     }
-    if (commentsElement.hasChildNodes()) {
-        doc.documentElement.appendChild(commentsElement);
+    return marks;
+};
+const addMark = (doc, node) => {
+    const parent = node.parentElement;
+    if (parent) {
+        const token = uuidv4();
+        const tokenNode = doc.createTextNode(token);
+        parent.insertBefore(tokenNode, node);
+        return token;
+    }
+};
+export const createComments = (models, marks) => {
+    const comments = [];
+    for (const model of models) {
+        if (isHighlightableModel(model)) {
+            comments.push(...processModel(model, marks));
+        }
+        else if (isKeyword(model)) {
+            comments.push(...processKeyword(model, marks));
+        }
     }
+    return comments;
+};
+const getFieldMarks = (content, marks) => {
+    return marks
+        .filter((m) => content.indexOf(m.token) >= 0)
+        .sort((a, b) => content.indexOf(a.token) - content.indexOf(b.token));
 };
-const createHighlightMarkerElement = (doc, id) => {
-    const highlightMarker = doc.createElement('highlight-marker');
-    highlightMarker.setAttribute('id', id);
-    highlightMarker.setAttribute('position', 'point');
-    return highlightMarker;
+const processModel = (model, marks) => {
+    const comments = [];
+    for (const field of highlightableFields) {
+        const content = model[field];
+        if (!content) {
+            continue;
+        }
+        const results = processContent(model, content, getFieldMarks(content, marks));
+        model[field] = results.content;
+        comments.push(...results.comments);
+    }
+    return comments;
 };
-const createCommentElement = (doc, comment) => {
-    const commentElement = doc.createElement('comment-annotation');
-    commentElement.setAttribute('id', comment.id);
-    commentElement.textContent = comment.text;
-    return commentElement;
+const processKeyword = (model, marks) => {
+    const comments = [];
+    const name = model.name;
+    let content = name;
+    for (const mark of getFieldMarks(name, marks)) {
+        content = name.replace(mark.token, '');
+        const target = model.containedGroup;
+        if (!target) {
+            continue;
+        }
+        const contributions = [buildContribution(DEFAULT_PROFILE_ID)];
+        const comment = buildComment(target, mark.comment.text, undefined, contributions);
+        model.name = content;
+        comments.push(comment);
+    }
+    return comments;
+};
+const processContent = (model, content, marks) => {
+    const comments = [];
+    let result = content;
+    for (const mark of marks) {
+        const token = mark.token;
+        const index = result.indexOf(token);
+        result = result.replace(token, '');
+        const contributions = [buildContribution(DEFAULT_PROFILE_ID)];
+        const selector = {
+            from: index,
+            to: index,
+        };
+        const comment = buildComment(model._id, mark.comment.text, selector, contributions);
+        comments.push(comment);
+    }
+    return {
+        content: result,
+        comments,
+    };
+};
+export const createReferenceComments = (references) => {
+    const comments = [];
+    for (const item of references.getBibliographyItems()) {
+        const id = item._id;
+        for (const comment of references.getComments(id)) {
+            const contributions = [buildContribution(DEFAULT_PROFILE_ID)];
+            const c = buildComment(id, comment.text, undefined, contributions);
+            comments.push(c);
+        }
+    }
+    return comments;
 };

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

@@ -0,0 +1,315 @@
+/*!
+ * © 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 debug from 'debug';
+import { getTrimmedTextContent } from '../../lib/utils';
+import { buildAffiliation, buildAuthorNotes, buildBibliographicName, buildContributor, buildCorresp, buildFootnote, buildJournal, buildParagraph, buildTitles, } from '../../transformer';
+import { parseJournalMeta } from './jats-journal-meta-parser';
+import { htmlFromJatsNode } from './jats-parser-utils';
+const warn = debug('manuscripts-transform');
+const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
+const defaultTitle = 'Untitled Manuscript';
+export const jatsFrontParser = {
+    parseTitles(element, createElement) {
+        var _a;
+        if (!element) {
+            return buildTitles(defaultTitle);
+        }
+        const title = element.querySelector('article-title');
+        const subtitle = element.querySelector('subtitle');
+        const runningTitle = element.querySelector('alt-title[alt-title-type="right-running"]');
+        const titles = buildTitles((_a = htmlFromJatsNode(title, createElement)) !== null && _a !== void 0 ? _a : defaultTitle);
+        if (subtitle) {
+            titles.subtitle = htmlFromJatsNode(subtitle, createElement);
+        }
+        if (runningTitle) {
+            titles.runningTitle = htmlFromJatsNode(runningTitle, createElement);
+        }
+        return titles;
+    },
+    parseDOI(front) {
+        var _a;
+        const doi = front === null || front === void 0 ? void 0 : front.querySelector('article-meta > article-id[pub-id-type="doi"]');
+        return (_a = doi === null || doi === void 0 ? void 0 : doi.textContent) !== null && _a !== void 0 ? _a : undefined;
+    },
+    parseCounts(counts) {
+        var _a, _b, _c, _d, _e;
+        if (counts) {
+            const parseCount = (count) => {
+                if (count && /^-?\d+$/.test(count)) {
+                    return parseInt(count);
+                }
+                else if (count) {
+                    warn(`Invalid count number for ${count}`);
+                }
+            };
+            const genericCounts = [];
+            const countElements = counts.querySelectorAll('count');
+            for (const element of countElements.values()) {
+                const countType = element.getAttribute('count-type');
+                const count = parseCount(element.getAttribute('count'));
+                if (countType) {
+                    const genericCount = { count, countType };
+                    genericCounts.push(genericCount);
+                }
+            }
+            return {
+                wordCount: parseCount((_a = counts.querySelector('word-count')) === null || _a === void 0 ? void 0 : _a.getAttribute('count')),
+                figureCount: parseCount((_b = counts.querySelector('fig-count')) === null || _b === void 0 ? void 0 : _b.getAttribute('count')),
+                tableCount: parseCount((_c = counts.querySelector('table-count')) === null || _c === void 0 ? void 0 : _c.getAttribute('count')),
+                equationCount: parseCount((_d = counts.querySelector('equation-count')) === null || _d === void 0 ? void 0 : _d.getAttribute('count')),
+                referencesCount: parseCount((_e = counts.querySelector('ref-count')) === null || _e === void 0 ? void 0 : _e.getAttribute('count')),
+                genericCounts: genericCounts.length > 0 ? genericCounts : undefined,
+            };
+        }
+    },
+    parseJournal(element) {
+        const meta = parseJournalMeta(element);
+        return Object.assign(Object.assign({}, meta), buildJournal());
+    },
+    parseDates(historyNode) {
+        if (!historyNode) {
+            return undefined;
+        }
+        const history = {};
+        const dateToTimestamp = (dateElement) => {
+            const selectors = ['year', 'month', 'day'];
+            const values = [];
+            for (const selector of selectors) {
+                const value = getTrimmedTextContent(dateElement, selector);
+                if (!value || isNaN(+value)) {
+                    return;
+                }
+                values.push(+value);
+            }
+            return Date.UTC(values[0], values[1], values[2]) / 1000;
+        };
+        for (const date of historyNode.children) {
+            const dateType = date.getAttribute('date-type');
+            switch (dateType) {
+                case 'received': {
+                    history.receiveDate = dateToTimestamp(date);
+                    break;
+                }
+                case 'rev-recd': {
+                    history.revisionReceiveDate = dateToTimestamp(date);
+                    break;
+                }
+                case 'accepted': {
+                    history.acceptanceDate = dateToTimestamp(date);
+                    break;
+                }
+                case 'rev-request': {
+                    history.revisionRequestDate = dateToTimestamp(date);
+                    break;
+                }
+                case 'retracted': {
+                    history.retractionDate = dateToTimestamp(date);
+                    break;
+                }
+                case 'corrected': {
+                    history.correctionDate = dateToTimestamp(date);
+                    break;
+                }
+            }
+        }
+        return history;
+    },
+    parseAffiliations(elements) {
+        const affiliationIDs = new Map();
+        const affiliations = elements.map((element, priority) => {
+            var _a, _b;
+            const affiliation = buildAffiliation('', priority);
+            for (const node of element.querySelectorAll('institution')) {
+                const content = (_a = node.textContent) === null || _a === void 0 ? void 0 : _a.trim();
+                if (!content) {
+                    continue;
+                }
+                const type = node.getAttribute('content-type');
+                if (type === 'dept') {
+                    affiliation.department = content;
+                }
+                else {
+                    affiliation.institution = content;
+                }
+            }
+            affiliation.addressLine1 =
+                getTrimmedTextContent(element, 'addr-line:nth-of-type(1)') || undefined;
+            affiliation.addressLine2 =
+                getTrimmedTextContent(element, 'addr-line:nth-of-type(2)') || undefined;
+            affiliation.addressLine3 =
+                getTrimmedTextContent(element, 'addr-line:nth-of-type(3)') || undefined;
+            affiliation.postCode =
+                getTrimmedTextContent(element, 'postal-code') || undefined;
+            affiliation.country =
+                getTrimmedTextContent(element, 'country') || undefined;
+            const email = element.querySelector('email');
+            if (email) {
+                affiliation.email = {
+                    href: email.getAttributeNS(XLINK_NAMESPACE, 'href') || undefined,
+                    text: ((_b = email.textContent) === null || _b === void 0 ? void 0 : _b.trim()) || undefined,
+                };
+            }
+            const id = element.getAttribute('id');
+            if (id) {
+                affiliationIDs.set(id, affiliation._id);
+            }
+            return affiliation;
+        });
+        return {
+            affiliations,
+            affiliationIDs,
+        };
+    },
+    parseAuthorNotes(element) {
+        if (!element) {
+            return {
+                footnotes: [],
+                footnoteIDs: new Map(),
+                authorNotes: [],
+                authorNotesParagraphs: [],
+                correspondingIDs: new Map(),
+                correspondingList: [],
+            };
+        }
+        const { footnotes, footnoteIDs } = this.parseFootnotes([
+            ...element.querySelectorAll('fn:not([fn-type])'),
+        ]);
+        const authorNotesParagraphs = this.parseParagraphs([
+            ...element.querySelectorAll(':scope > p'),
+        ]);
+        const { correspondingList, correspondingIDs } = this.parseCorresp([
+            ...element.querySelectorAll('corresp'),
+        ]);
+        const authorNotes = [
+            buildAuthorNotes([
+                ...correspondingIDs.values(),
+                ...footnoteIDs.values(),
+                ...authorNotesParagraphs.map((p) => p._id),
+            ]),
+        ];
+        return {
+            footnotes,
+            footnoteIDs,
+            authorNotesParagraphs,
+            authorNotes,
+            correspondingIDs,
+            correspondingList,
+        };
+    },
+    parseParagraphs(elements) {
+        return elements.map((p) => buildParagraph(p.innerHTML));
+    },
+    parseFootnotes(elements) {
+        const footnoteIDs = new Map();
+        const footnotes = elements.map((element) => {
+            const fn = buildFootnote('', element.innerHTML);
+            const id = element.getAttribute('id');
+            if (id) {
+                footnoteIDs.set(id, fn._id);
+            }
+            return fn;
+        });
+        return {
+            footnotes,
+            footnoteIDs,
+        };
+    },
+    parseCorresp(elements) {
+        const correspondingIDs = new Map();
+        const correspondingList = elements.map((element) => {
+            var _a, _b, _c;
+            const label = element.querySelector('label');
+            if (label) {
+                label.remove();
+            }
+            const corresponding = buildCorresp((_b = (_a = element.textContent) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '');
+            corresponding.label = ((_c = label === null || label === void 0 ? void 0 : label.textContent) === null || _c === void 0 ? void 0 : _c.trim()) || undefined;
+            const id = element.getAttribute('id');
+            if (id) {
+                correspondingIDs.set(id, corresponding._id);
+            }
+            return corresponding;
+        });
+        return {
+            correspondingList,
+            correspondingIDs,
+        };
+    },
+    parseContributors(elements, affiliationIDs, footnoteIDs, correspondingIDs) {
+        return elements.map((element, priority) => {
+            var _a, _b;
+            const name = buildBibliographicName({});
+            const given = getTrimmedTextContent(element, 'name > given-names');
+            if (given) {
+                name.given = given;
+            }
+            const surname = getTrimmedTextContent(element, 'name > surname');
+            if (surname) {
+                name.family = surname;
+            }
+            const contributor = buildContributor(name, 'author', priority);
+            const corresponding = element.getAttribute('corresp') === 'yes';
+            if (corresponding) {
+                contributor.isCorresponding = corresponding;
+            }
+            const orcid = getTrimmedTextContent(element, 'contrib-id[contrib-id-type="orcid"]');
+            if (orcid) {
+                contributor.ORCIDIdentifier = orcid;
+            }
+            const xrefs = element.querySelectorAll('xref');
+            for (const xref of xrefs) {
+                if (xref) {
+                    const rid = xref.getAttribute('rid');
+                    const type = xref.getAttribute('ref-type');
+                    if (rid) {
+                        if (type === 'fn') {
+                            contributor.footnote = [];
+                            const footnoteID = footnoteIDs.get(rid);
+                            if (footnoteID) {
+                                const authorFootNoteRef = {
+                                    noteID: footnoteID,
+                                    noteLabel: ((_a = xref.textContent) === null || _a === void 0 ? void 0 : _a.trim()) || '',
+                                };
+                                contributor.footnote.push(authorFootNoteRef);
+                            }
+                        }
+                        else if (type === 'corresp') {
+                            contributor.corresp = [];
+                            const correspID = correspondingIDs.get(rid);
+                            if (correspID) {
+                                const authorCorrespRef = {
+                                    correspID: correspID,
+                                    correspLabel: ((_b = xref.textContent) === null || _b === void 0 ? void 0 : _b.trim()) || '',
+                                };
+                                contributor.corresp.push(authorCorrespRef);
+                            }
+                        }
+                        else if (type === 'aff') {
+                            const rids = rid
+                                .split(/\s+/)
+                                .map((id) => affiliationIDs.get(id))
+                                .filter(Boolean);
+                            if (rids.length) {
+                                contributor.affiliations = rids;
+                            }
+                        }
+                    }
+                }
+            }
+            return contributor;
+        });
+    },
+};

package/dist/es/jats/importer/jats-journal-meta-parser.js

@@ -13,9 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes } from '@manuscripts/json-schema';
 import { getTrimmedTextContent } from '../../lib/utils';
-import { generateID } from '../../transformer';
 export const parseJournalIdentifiers = (element) => {
     var _a;
     if (!element) {
@@ -86,7 +84,3 @@ export const parseJournalMeta = (element) => {
         title: (_b = getTrimmedTextContent(element, 'journal-title-group > journal-title')) !== null && _b !== void 0 ? _b : undefined,
     };
 };
-export const parseJournal = (element) => {
-    const meta = parseJournalMeta(element);
-    return Object.assign(Object.assign({}, meta), { _id: generateID(ObjectTypes.Journal), objectType: ObjectTypes.Journal });
-};

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

@@ -14,38 +14,24 @@
  * limitations under the License.
  */
 import { v4 as uuidv4 } from 'uuid';
-import { schema, } from '../../schema';
+import { schema } from '../../schema';
 import { generateID, nodeTypesMap } from '../../transformer';
 export const updateDocumentIDs = (node, replacements) => {
     const warnings = [];
-    const highlightNodes = [];
-    recurseDoc(node, (n, parent) => updateNodeID(n, parent, replacements, warnings, highlightNodes));
+    recurseDoc(node, (n) => updateNodeID(n, replacements, warnings));
     recurseDoc(node, (n) => updateNodeRID(n, replacements, warnings));
     recurseDoc(node, (n) => updateNodeRIDS(n, replacements, warnings));
-    recurseDoc(node, (n) => updateContributorNodesIDS(n, replacements, warnings));
     return warnings;
 };
-function recurseDoc(node, fn, parent = null) {
-    fn(node, parent);
-    node.descendants((n, pos, parent) => fn(n, parent));
+function recurseDoc(node, fn) {
+    fn(node);
+    node.descendants((n) => fn(n));
 }
-const updateNodeID = (node, parent, replacements, warnings, highlightNodes) => {
+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 (node.type === schema.nodes.highlight_marker) {
-        node.attrs = Object.assign(Object.assign({}, node.attrs), { tid: parent === null || parent === void 0 ? void 0 : parent.attrs.id });
-        highlightNodes.push(node);
-        return;
-    }
-    if (node.type === schema.nodes.comment) {
-        const highlightNode = highlightNodes.find((n) => n.attrs.id === node.attrs.id);
-        if (highlightNode) {
-            node.attrs = Object.assign(Object.assign({}, node.attrs), { target: highlightNode.attrs.tid });
-        }
-        return;
-    }
     if (node.type === schema.nodes.general_table_footnote) {
         node.attrs = Object.assign(Object.assign({}, node.attrs), { id: `GeneralTableFootnote:${uuidv4()}` });
         return;
@@ -88,30 +74,6 @@ 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 JATS_TO_HTML_MAPPING = new Map([
     ['bold', 'b'],
     ['italic', 'i'],

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

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ObjectTypes } from '@manuscripts/json-schema';
 import { getTrimmedTextContent } from '../../lib/utils';
-import { generateID } from '../../transformer';
+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) => {
@@ -37,15 +37,23 @@ export const jatsReferenceParser = {
             const authorNodes = [
                 ...element.querySelectorAll('person-group[person-group-type="author"] > *'),
             ];
-            const bibliographyItem = {
-                id: generateID(ObjectTypes.BibliographyItem),
+            const bibliographyItem = buildBibliographyItem({
                 type: chooseBibliographyItemType(publicationType),
-            };
+            });
             const titleNode = element.querySelector('article-title');
             if (titleNode) {
                 bibliographyItem.title = (_a = htmlFromJatsNode(titleNode, createElement)) === null || _a === void 0 ? void 0 : _a.trim();
             }
+            const comments = [];
             const mixedCitation = element.querySelector('mixed-citation');
+            mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes.forEach((item) => {
+                if (isJATSComment(item)) {
+                    const comment = parseJATSComment(item);
+                    if (comment) {
+                        comments.push(comment);
+                    }
+                }
+            });
             if (authorNodes.length <= 0) {
                 mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes.forEach((item) => {
                     var _a, _b, _c;
@@ -58,7 +66,7 @@ export const jatsReferenceParser = {
             }
             const source = getTrimmedTextContent(element, 'source');
             if (source) {
-                bibliographyItem.containerTitle = source;
+                bibliographyItem['container-title'] = source;
             }
             const volume = getTrimmedTextContent(element, 'volume');
             if (volume) {
@@ -79,23 +87,18 @@ export const jatsReferenceParser = {
             }
             const year = getTrimmedTextContent(element, 'year');
             if (year) {
-                bibliographyItem.issued = {
+                bibliographyItem.issued = buildBibliographicDate({
                     'date-parts': [[year]],
-                    _id: generateID(ObjectTypes.BibliographicDate),
-                    objectType: ObjectTypes.BibliographicDate,
-                };
+                });
             }
             const doi = getTrimmedTextContent(element, 'pub-id[pub-id-type="doi"]');
             if (doi) {
-                bibliographyItem.doi = doi;
+                bibliographyItem.DOI = doi;
             }
             const authors = [];
             authorNodes.forEach((authorNode) => {
                 var _a;
-                const name = {
-                    _id: generateID(ObjectTypes.BibliographicName),
-                    objectType: ObjectTypes.BibliographicName,
-                };
+                const name = buildBibliographicName({});
                 const given = getTrimmedTextContent(authorNode, 'given-names');
                 if (given) {
                     name.given = given;
@@ -104,6 +107,10 @@ export const jatsReferenceParser = {
                 if (family) {
                     name.family = family;
                 }
+                const suffix = getTrimmedTextContent(authorNode, 'suffix');
+                if (suffix) {
+                    name.suffix = suffix;
+                }
                 if (authorNode.nodeName === 'collab') {
                     name.literal = (_a = authorNode.textContent) === null || _a === void 0 ? void 0 : _a.trim();
                 }
@@ -113,7 +120,7 @@ export const jatsReferenceParser = {
                 bibliographyItem.author = authors;
             }
             const id = element.getAttribute('id');
-            references.add(bibliographyItem, id);
+            references.add(bibliographyItem, id, comments);
         });
         return references;
     },