@manuscripts/transform 2.3.34-LEAN-3911.2 → 2.3.34

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,26 +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 Object.assign(Object.assign({}, fn), { noteID: replacements.get(fn.noteID) });
-        });
-        const corresp = (_b = node.attrs.corresp) === null || _b === void 0 ? void 0 : _b.map((corresp) => {
-            return Object.assign(Object.assign({}, corresp), { correspID: replacements.get(corresp.correspID) });
-        });
-        const affiliations = node.attrs.affiliations.map((affiliation) => {
-            return replacements.get(affiliation);
-        });
-        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,22 +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) => {
-                const name = {
-                    _id: generateID(ObjectTypes.BibliographicName),
-                    objectType: ObjectTypes.BibliographicName,
-                };
+                var _a;
+                const name = buildBibliographicName({});
                 const given = getTrimmedTextContent(authorNode, 'given-names');
                 if (given) {
                     name.given = given;
@@ -103,13 +107,20 @@ 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();
+                }
                 authors.push(name);
             });
             if (authors.length) {
                 bibliographyItem.author = authors;
             }
             const id = element.getAttribute('id');
-            references.add(bibliographyItem, id);
+            references.add(bibliographyItem, id, comments);
         });
         return references;
     },

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

@@ -1,30 +1,30 @@
-/*!
- * © 2023 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.
- */
 export class References {
     constructor() {
         this.items = new Map();
         this.IDs = new Map();
+        this.comments = new Map();
     }
-    add(item, id) {
-        this.items.set(item.id, item);
+    add(item, id, comments) {
+        this.items.set(item._id, item);
+        this.comments.set(item._id, comments);
         if (id) {
-            this.IDs.set(id, item.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);
+        }
+    }
 }