@manuscripts/transform 2.3.38-LEAN-3911.0 → 2.4.0

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);
+        }
+    }
 }

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

@@ -14,74 +14,111 @@
  * 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 { markComments } from './jats-comments';
-import { jatsDOMParser } from './jats-dom-parser';
-import { jatsFrontTransformations } from './jats-front-transformations';
-import { parseJournal } from './jats-journal-meta-parser';
+import { createComments, createReferenceComments, markComments, } from './jats-comments';
+import { jatsFrontParser } from './jats-front-parser';
 import { updateDocumentIDs } from './jats-parser-utils';
 import { jatsReferenceParser } from './jats-reference-parser';
-const parseJATSBody = (doc, body, references) => {
+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 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);
-    jatsBodyTransformations.moveReferencesToBackmatter(body, references, createElement);
-};
-const parseJATSFront = (doc, front, template) => {
-    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);
+    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);
-export const parseJATSArticle = (doc, template) => {
+const generateIDs = (models) => models.map((m) => m._id ? m : Object.assign(Object.assign({}, m), { _id: generateID(m.objectType) }));
+export const parseJATSArticle = (doc) => {
     const article = doc.querySelector('article');
     const front = doc.querySelector('front');
     const body = doc.querySelector('body');
     const back = doc.querySelector('back');
-    if (!article || !front) {
-        throw new InvalidInput('invalid JATS format');
+    if (!front) {
+        throw new InvalidInput('Invalid JATS format! Missing front element');
+    }
+    if (!article) {
+        throw new InvalidInput('Invalid JATS format! Missing article element');
     }
-    markComments(doc);
-    const journal = parseJournal(front.querySelector('journal-meta'));
+    const marks = markComments(doc);
     const createElement = createElementFn(doc);
+    const models = [];
     let references;
     if (back) {
         references = jatsReferenceParser.parseReferences([...back.querySelectorAll('ref-list > ref')], createElement);
     }
-    const replacements = new Map(references === null || references === void 0 ? void 0 : references.IDs);
-    parseJATSFront(doc, front, template);
+    models.push(...parseJATSFront(doc, front));
     if (body) {
-        parseJATSBody(doc, body, references);
+        models.push(...parseJATSBody(doc, body, references));
     }
-    const node = jatsDOMParser.parse(doc).firstChild;
-    if (!node) {
-        throw new Error('No content was parsed from the JATS article body');
+    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';
     }
-    updateDocumentIDs(node, replacements);
-    return {
-        node: node,
-        journal,
-    };
+    if (references && references.items.size) {
+        models.push(...createBibliographyModels(references));
+    }
+    if (marks.length) {
+        const comments = createComments(models, marks);
+        models.push(...comments);
+    }
+    return models;
 };

package/dist/es/jats/index.js

@@ -13,8 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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';
+export { parseJATSFront, parseJATSBody, parseJATSArticle } from './importer';
+export * from './jats-exporter';
+export * from './jats-versions';