@manuscripts/transform 2.3.32 → 2.3.34-LEAN-3911.2

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 { buildBibliographicDate, buildBibliographicName, buildBibliographyItem, } from '../../transformer/builders';
-import { isJATSComment, parseJATSComment } from './jats-comments';
+import { generateID } from '../../transformer';
 import { htmlFromJatsNode } from './jats-parser-utils';
 import { References } from './jats-references';
 const chooseBibliographyItemType = (publicationType) => {
@@ -37,23 +37,15 @@ export const jatsReferenceParser = {
             const authorNodes = [
                 ...element.querySelectorAll('person-group[person-group-type="author"] > *'),
             ];
-            const bibliographyItem = buildBibliographyItem({
+            const bibliographyItem = {
+                id: generateID(ObjectTypes.BibliographyItem),
                 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;
@@ -66,7 +58,7 @@ export const jatsReferenceParser = {
             }
             const source = getTrimmedTextContent(element, 'source');
             if (source) {
-                bibliographyItem['container-title'] = source;
+                bibliographyItem.containerTitle = source;
             }
             const volume = getTrimmedTextContent(element, 'volume');
             if (volume) {
@@ -87,18 +79,22 @@ export const jatsReferenceParser = {
             }
             const year = getTrimmedTextContent(element, 'year');
             if (year) {
-                bibliographyItem.issued = buildBibliographicDate({
+                bibliographyItem.issued = {
                     '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 = buildBibliographicName({});
+                const name = {
+                    _id: generateID(ObjectTypes.BibliographicName),
+                    objectType: ObjectTypes.BibliographicName,
+                };
                 const given = getTrimmedTextContent(authorNode, 'given-names');
                 if (given) {
                     name.given = given;
@@ -107,20 +103,13 @@ 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, comments);
+            references.add(bibliographyItem, id);
         });
         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, comments) {
-        this.items.set(item._id, item);
-        this.comments.set(item._id, comments);
+    add(item, id) {
+        this.items.set(item.id, item);
         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);
-        }
-    }
 }

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

@@ -14,44 +14,14 @@
  * 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 { jatsFrontTransformations } from './jats-front-transformations';
+import { parseJournal } from './jats-journal-meta-parser';
 import { updateDocumentIDs } from './jats-parser-utils';
 import { jatsReferenceParser } from './jats-reference-parser';
-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 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 parseJATSBody = (doc, body, references) => {
     const createElement = createElementFn(doc);
     jatsBodyTransformations.ensureSection(body, createElement);
     jatsBodyTransformations.moveCaptionsToEnd(body);
@@ -62,62 +32,58 @@ export const parseJATSBody = (doc, body, references) => {
     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();
+    jatsBodyTransformations.moveReferencesToBackmatter(body, references, createElement);
 };
-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 parseJATSFront = (doc, front, template) => {
+    var _a;
+    const createElement = createElementFn(doc);
+    jatsFrontTransformations.setArticleAttrs(doc, template);
+    const authorNotes = jatsFrontTransformations.createAuthorNotes(doc, createElement);
+    if (authorNotes) {
+        doc.documentElement.prepend(authorNotes);
+    }
+    const affiliations = jatsFrontTransformations.createAffiliations(front, createElement);
+    if (affiliations) {
+        doc.documentElement.prepend(affiliations);
+    }
+    const contributors = jatsFrontTransformations.createContributors(front, createElement);
+    if (contributors) {
+        doc.documentElement.prepend(contributors);
+    }
+    const title = jatsFrontTransformations.createTitle(front, createElement);
+    if (title) {
+        doc.documentElement.prepend(title);
+    }
+    (_a = doc.querySelector('front')) === null || _a === void 0 ? void 0 : _a.remove();
 };
 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) => {
+export const parseJATSArticle = (doc, template) => {
     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 (!article) {
-        throw new InvalidInput('Invalid JATS format! Missing article element');
+    if (!article || !front) {
+        throw new InvalidInput('invalid JATS format');
     }
-    const marks = markComments(doc);
+    markComments(doc);
+    const journal = parseJournal(front.querySelector('journal-meta'));
     const createElement = createElementFn(doc);
-    const models = [];
     let references;
     if (back) {
         references = jatsReferenceParser.parseReferences([...back.querySelectorAll('ref-list > ref')], createElement);
     }
-    models.push(...parseJATSFront(doc, front));
+    const replacements = new Map(references === null || references === void 0 ? void 0 : references.IDs);
+    parseJATSFront(doc, front, template);
     if (body) {
-        models.push(...parseJATSBody(doc, body, references));
-    }
-    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';
+        parseJATSBody(doc, body, references);
     }
-    if (references && references.items.size) {
-        models.push(...createBibliographyModels(references));
-    }
-    if (marks.length) {
-        const comments = createComments(models, marks);
-        models.push(...comments);
+    const node = jatsDOMParser.parse(doc).firstChild;
+    if (!node) {
+        throw new Error('No content was parsed from the JATS article body');
     }
-    return models;
+    updateDocumentIDs(node, replacements);
+    return {
+        node: 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 { parseJATSArticle, createArticleNode } from './importer';
 export * from './jats-exporter';
 export * from './jats-versions';
+export * from './timestamp';
+export * from './labels';