@manuscripts/transform 1.0.0

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

@@ -0,0 +1,177 @@
+/*!
+ * © 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 { buildAuxiliaryObjectReference, buildBibliographicDate, buildBibliographicName, buildBibliographyItem, buildCitation, } from '../../transformer/builders';
+import { parseProcessingInstruction } from './jats-comments';
+import { flatten, htmlFromJatsNode } from './jats-parser-utils';
+const chooseBibliographyItemType = (publicationType) => {
+    switch (publicationType) {
+        case 'book':
+        case 'thesis':
+            return publicationType;
+        case 'journal':
+        default:
+            return 'article-journal';
+    }
+};
+export const jatsReferenceParser = {
+    parseReferences(referenceNodes, createElement) {
+        const referenceIDs = new Map();
+        const referenceQueries = new Map();
+        const references = referenceNodes.map((referenceNode) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const publicationType = referenceNode.getAttribute('publication-type');
+            const authorNodes = [
+                ...referenceNode.querySelectorAll('person-group[person-group-type="author"] > *'),
+            ];
+            const bibliographyItem = buildBibliographyItem({
+                type: chooseBibliographyItemType(publicationType),
+            });
+            const titleNode = referenceNode.querySelector('article-title');
+            if (titleNode) {
+                bibliographyItem.title = htmlFromJatsNode(titleNode, createElement);
+            }
+            const queriesText = [];
+            const mixedCitation = referenceNode.querySelector('mixed-citation');
+            mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes.forEach((item) => {
+                if (item.nodeType === item.PROCESSING_INSTRUCTION_NODE &&
+                    item.nodeName === 'AuthorQuery') {
+                    const instruction = parseProcessingInstruction(item);
+                    if (instruction) {
+                        const { queryText } = instruction;
+                        queriesText.push(queryText);
+                    }
+                }
+            });
+            if (queriesText.length) {
+                referenceQueries.set(bibliographyItem._id, queriesText);
+            }
+            if (authorNodes.length <= 0) {
+                mixedCitation === null || mixedCitation === void 0 ? void 0 : mixedCitation.childNodes.forEach((item) => {
+                    var _a, _b;
+                    if (item.nodeType === Node.TEXT_NODE &&
+                        ((_a = item.textContent) === null || _a === void 0 ? void 0 : _a.match(/[A-Za-z]+/g))) {
+                        bibliographyItem.literal = (_b = mixedCitation.textContent) !== null && _b !== void 0 ? _b : '';
+                        return bibliographyItem;
+                    }
+                });
+            }
+            const source = (_a = referenceNode.querySelector('source')) === null || _a === void 0 ? void 0 : _a.textContent;
+            if (source) {
+                bibliographyItem['container-title'] = source;
+            }
+            const volume = (_b = referenceNode.querySelector('volume')) === null || _b === void 0 ? void 0 : _b.textContent;
+            if (volume) {
+                bibliographyItem.volume = volume;
+            }
+            const issue = (_c = referenceNode.querySelector('issue')) === null || _c === void 0 ? void 0 : _c.textContent;
+            if (issue) {
+                bibliographyItem.issue = issue;
+            }
+            const supplement = (_d = referenceNode.querySelector('supplement')) === null || _d === void 0 ? void 0 : _d.textContent;
+            if (supplement) {
+                bibliographyItem.supplement = supplement;
+            }
+            const fpage = (_e = referenceNode.querySelector('fpage')) === null || _e === void 0 ? void 0 : _e.textContent;
+            const lpage = (_f = referenceNode.querySelector('lpage')) === null || _f === void 0 ? void 0 : _f.textContent;
+            if (fpage) {
+                bibliographyItem.page = lpage ? `${fpage}-${lpage}` : fpage;
+            }
+            const year = (_g = referenceNode.querySelector('year')) === null || _g === void 0 ? void 0 : _g.textContent;
+            if (year) {
+                bibliographyItem.issued = buildBibliographicDate({
+                    'date-parts': [[year]],
+                });
+            }
+            const doi = (_h = referenceNode.querySelector('pub-id[pub-id-type="doi"]')) === null || _h === void 0 ? void 0 : _h.textContent;
+            if (doi) {
+                bibliographyItem.DOI = doi;
+            }
+            const authors = [];
+            authorNodes.forEach((authorNode) => {
+                var _a, _b, _c;
+                const name = buildBibliographicName({});
+                const given = (_a = authorNode.querySelector('given-names')) === null || _a === void 0 ? void 0 : _a.textContent;
+                if (given) {
+                    name.given = given;
+                }
+                const family = (_b = authorNode.querySelector('surname')) === null || _b === void 0 ? void 0 : _b.textContent;
+                if (family) {
+                    name.family = family;
+                }
+                const suffix = (_c = authorNode.querySelector('suffix')) === null || _c === void 0 ? void 0 : _c.textContent;
+                if (suffix) {
+                    name.suffix = suffix;
+                }
+                if (authorNode.nodeName === 'collab') {
+                    name.literal = authorNode.textContent;
+                }
+                authors.push(name);
+            });
+            if (authors.length) {
+                bibliographyItem.author = authors;
+            }
+            const id = referenceNode.getAttribute('id');
+            if (id) {
+                referenceIDs.set(id, bibliographyItem._id);
+            }
+            return bibliographyItem;
+        });
+        return {
+            references,
+            referenceIDs,
+            referenceQueries,
+        };
+    },
+    parseCrossReferences(crossReferenceNodes, referenceIDs) {
+        return flatten(crossReferenceNodes.map((crossReferenceNode) => {
+            const rid = crossReferenceNode.getAttribute('rid');
+            if (!rid) {
+                return [];
+            }
+            const modelNodes = [];
+            const refType = crossReferenceNode.getAttribute('ref-type');
+            switch (refType) {
+                case 'bibr':
+                    {
+                        const rids = rid
+                            .split(/\s+/)
+                            .filter((id) => referenceIDs.has(id))
+                            .map((id) => referenceIDs.get(id));
+                        if (rids.length) {
+                            const citation = buildCitation('', rids);
+                            modelNodes.push(citation);
+                            crossReferenceNode.setAttribute('rid', citation._id);
+                        }
+                        else {
+                            crossReferenceNode.removeAttribute('rid');
+                        }
+                    }
+                    break;
+                case 'fn':
+                    break;
+                default:
+                    {
+                        const rids = rid.trim().split(/\s+/);
+                        const auxiliaryObjectReference = buildAuxiliaryObjectReference('', rids);
+                        modelNodes.push(auxiliaryObjectReference);
+                        crossReferenceNode.setAttribute('rid', auxiliaryObjectReference._id);
+                    }
+                    break;
+            }
+            return modelNodes;
+        }));
+    },
+};

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

@@ -0,0 +1,229 @@
+/*!
+ * © 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 { DOMParser } from 'prosemirror-model';
+import { InvalidInput } from '../../errors';
+import { nodeFromHTML } from '../../lib/html';
+import { schema } from '../../schema';
+import { auxiliaryObjectTypes, nodeTypesMap } from '../../transformer';
+import { buildElementsOrder, buildJournal, buildManuscript, } from '../../transformer/builders';
+import { encode, inlineContents } from '../../transformer/encode';
+import { createEmptyFootnotesOrder, createOrderedFootnotesIDs, handleFootnotesOrder, } from '../../transformer/footnotes-order';
+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, markProcessingInstructions, } from './jats-comments';
+import { jatsFrontParser } from './jats-front-parser';
+import { fixBodyPMNode } from './jats-parser-utils';
+import { jatsReferenceParser } from './jats-reference-parser';
+const parser = DOMParser.fromSchema(schema);
+const inlineContentsFromJATSTitle = (htmlTitle) => {
+    const node = nodeFromHTML(`<h1>${htmlTitle}</h1>`);
+    if (node) {
+        const titleNode = parser.parse(node, {
+            topNode: schema.nodes.section_title.create(),
+        });
+        return inlineContents(titleNode);
+    }
+    throw new InvalidInput('Invalid title content for: ' + htmlTitle);
+};
+export const parseJATSFront = async (front) => {
+    var _a, _b, _c;
+    const journalMeta = jatsFrontParser.parseJournal(front.querySelector('journal-meta'));
+    const journal = Object.assign(Object.assign({}, buildJournal()), journalMeta);
+    const { manuscript_bundle, bundleNodes } = await jatsFrontParser.loadJournalBundles(journal.ISSNs);
+    const articleMeta = front.querySelector('article-meta');
+    const title = (_a = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('title-group > article-title')) === null || _a === void 0 ? void 0 : _a.innerHTML;
+    const subtitle = (_b = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('title-group > subtitle')) === null || _b === void 0 ? void 0 : _b.innerHTML;
+    const runningTitle = (_c = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('title-group > alt-title[alt-title-type="right-running"]')) === null || _c === void 0 ? void 0 : _c.innerHTML;
+    const manuscriptMeta = Object.assign({ title: title ? inlineContentsFromJATSTitle(title) : undefined, subtitle: subtitle ? inlineContentsFromJATSTitle(subtitle) : undefined, runningTitle: runningTitle
+            ? inlineContentsFromJATSTitle(runningTitle)
+            : undefined }, jatsFrontParser.parseCounts(articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelector('counts')));
+    const keywordGroupNodes = articleMeta === null || articleMeta === void 0 ? void 0 : articleMeta.querySelectorAll('kwd-group');
+    const { keywords, groups: keywordGroups } = jatsFrontParser.parseKeywords(keywordGroupNodes);
+    const manuscript_keywordIDs = keywords.length > 0 ? keywords.map((k) => k._id) : undefined;
+    const { affiliations, affiliationIDs } = jatsFrontParser.parseAffiliationNodes([
+        ...front.querySelectorAll('article-meta > contrib-group > aff'),
+    ]);
+    const { footnotes, footnoteIDs } = jatsFrontParser.parseFootnoteNodes([
+        ...front.querySelectorAll('article-meta > author-notes > fn:not([fn-type])'),
+    ]);
+    const { correspondingList, correspondingIDs } = jatsFrontParser.parseCorrespNodes([
+        ...front.querySelectorAll('article-meta > author-notes > corresp'),
+    ]);
+    const authors = jatsFrontParser.parseAuthorNodes([
+        ...front.querySelectorAll('article-meta > contrib-group > contrib[contrib-type="author"]'),
+    ], affiliationIDs, footnoteIDs, correspondingIDs);
+    const history = jatsFrontParser.parseDates(front.querySelector('article-meta > history'));
+    const supplements = jatsFrontParser.parseSupplements([
+        ...front.querySelectorAll('article-meta > supplementary-material'),
+    ]);
+    const manuscript = Object.assign(Object.assign(Object.assign(Object.assign({}, buildManuscript()), manuscriptMeta), { bundle: manuscript_bundle, keywordIDs: manuscript_keywordIDs }), history);
+    return {
+        models: generateModelIDs([
+            manuscript,
+            ...bundleNodes,
+            ...keywords,
+            ...affiliations,
+            ...authors,
+            ...keywordGroups,
+            ...footnotes,
+            ...correspondingList,
+            journal,
+            ...supplements,
+        ]),
+        bundles: bundleNodes,
+    };
+};
+export const parseJATSReferences = (back, body, createElement) => {
+    const bibliographyItems = [];
+    const crossReferences = [];
+    let referenceQueriesMap;
+    let referenceIdsMap;
+    if (back) {
+        const { references, referenceIDs, referenceQueries } = jatsReferenceParser.parseReferences([...back.querySelectorAll('ref-list > ref')], createElement);
+        bibliographyItems.push(...references);
+        referenceQueriesMap = new Map([...referenceQueries]);
+        referenceIdsMap = new Map([...referenceIDs]);
+        if (body) {
+            crossReferences.push(...jatsReferenceParser.parseCrossReferences([...body.querySelectorAll('xref')], referenceIDs));
+        }
+    }
+    return {
+        references: generateModelIDs(bibliographyItems),
+        crossReferences: generateModelIDs(crossReferences),
+        referenceQueriesMap,
+        referenceIdsMap,
+    };
+};
+export const parseJATSBody = (document, body, bibliographyItems, refModels, referenceIdsMap, footnotesOrder) => {
+    const createElement = createElementFn(document);
+    const orderedFootnotesIDs = createOrderedFootnotesIDs(document);
+    jatsBodyTransformations.moveFloatsGroupToBody(document, body, createElement);
+    jatsBodyTransformations.ensureSection(body, createElement);
+    jatsBodyTransformations.mapFootnotesToSections(document, body, createElement);
+    jatsBodyTransformations.moveSectionsToBody(document, body, bibliographyItems, createElement);
+    jatsBodyTransformations.moveCaptionsToEnd(body);
+    jatsBodyTransformations.moveTableFooterToEnd(body);
+    jatsBodyTransformations.moveBlockNodesFromParagraph(document, body, createElement);
+    const node = jatsBodyDOMParser.parse(body);
+    if (!node.firstChild) {
+        throw new Error('No content was parsed from the JATS article body');
+    }
+    const { replacements } = fixBodyPMNode(node.firstChild, refModels, referenceIdsMap);
+    if (footnotesOrder) {
+        handleFootnotesOrder(orderedFootnotesIDs, replacements, footnotesOrder);
+    }
+    return node.firstChild;
+};
+const transformTables = (tables, createElement) => {
+    tables.forEach((table) => {
+        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);
+            }
+            table.insertBefore(colgroup, table.firstChild);
+        }
+        const tbody = table.querySelector('tbody');
+        if (tbody) {
+            const headerRow = table.querySelector('thead > tr');
+            if (!headerRow) {
+                const tr = createElement('tr');
+                tbody.insertBefore(tr, tbody.firstElementChild);
+            }
+            const footerRow = table.querySelector('tfoot > tr');
+            if (!footerRow) {
+                const tr = createElement('tr');
+                tbody.appendChild(tr);
+            }
+        }
+    });
+};
+const createElementFn = (doc) => (tagName) => doc.createElement(tagName);
+const generateModelIDs = (models) => models.map((m) => m._id ? m : Object.assign(Object.assign({}, m), { _id: generateID(m.objectType) }));
+export const parseJATSArticle = async (doc) => {
+    const articleElement = 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 (!articleElement) {
+        throw new InvalidInput('Invalid JATS format! Missing article element');
+    }
+    const authorQueriesMap = markProcessingInstructions(doc);
+    const createElement = createElementFn(document);
+    const { models: frontModels } = await parseJATSFront(front);
+    const { references, crossReferences, referenceQueriesMap, referenceIdsMap } = parseJATSReferences(back, body, createElement);
+    transformTables(doc.querySelectorAll('table-wrap > table'), createElement);
+    const footnotesOrder = createEmptyFootnotesOrder();
+    let elementsOrder = [];
+    const bodyModels = [];
+    if (body) {
+        const bodyDoc = parseJATSBody(doc, body, references, crossReferences, referenceIdsMap, footnotesOrder);
+        bodyModels.push(...encode(bodyDoc).values());
+        elementsOrder = getElementsOrder(bodyDoc);
+    }
+    const frontModelsMap = new Map(frontModels.map((model) => [model._id, model]));
+    const manuscript = findManuscript(frontModelsMap);
+    if (manuscript) {
+        const articleType = articleElement.getAttribute('article-type');
+        manuscript.articleType = articleType || 'other';
+    }
+    const models = [
+        ...frontModels,
+        ...bodyModels,
+        ...crossReferences,
+        ...elementsOrder,
+    ];
+    if (footnotesOrder.footnotesList.length > 0) {
+        models.push(footnotesOrder);
+    }
+    if (authorQueriesMap.size) {
+        const commentAnnotations = createComments(authorQueriesMap, models);
+        models.push(...commentAnnotations);
+    }
+    if (referenceQueriesMap && referenceQueriesMap.size) {
+        const commentAnnotations = createReferenceComments(referenceQueriesMap, references);
+        models.push(...commentAnnotations);
+    }
+    return models;
+};
+export const getElementsOrder = (node) => {
+    const elementsOrderIndex = new Map();
+    const models = [];
+    node.descendants((child) => {
+        const type = child.type;
+        if (auxiliaryObjectTypes.has(type)) {
+            const index = elementsOrderIndex.get(type);
+            if (index !== undefined) {
+                const elementsOrder = models[index];
+                elementsOrder.elements.push(child.attrs['id']);
+            }
+            else {
+                const elementsOrder = buildElementsOrder(nodeTypesMap.get(type));
+                elementsOrder.elements.push(child.attrs['id']);
+                models.push(elementsOrder);
+                elementsOrderIndex.set(type, elementsOrderIndex.size);
+            }
+        }
+    });
+    return models;
+};

package/dist/es/jats/index.js

@@ -0,0 +1,18 @@
+/*!
+ * © 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.
+ */
+export { parseJATSFront, parseJATSReferences, parseJATSBody, parseJATSArticle, getElementsOrder, } from './importer';
+export * from './jats-exporter';
+export * from './jats-versions';