@manuscripts/transform 1.0.0

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

@@ -0,0 +1,335 @@
+/*!
+ * © 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 { buildAffiliation, buildBibliographicName, buildContributor, buildCorresp, buildFootnote, buildKeyword, buildKeywordGroup, buildSupplementaryMaterial, } from '../../transformer/builders';
+import { createNewBundle, createParentBundle } from '../../transformer/bundles';
+import { loadBundlesMap, loadIssnBundleIndex, } from '../../transformer/bundles-data';
+import { parseJournalMeta } from './jats-journal-meta-parser';
+const warn = debug('manuscripts-transform');
+const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
+const chooseBundle = async (issns) => {
+    const issnBundleIndex = await loadIssnBundleIndex();
+    for (const { ISSN } of issns) {
+        const normalizedIssn = ISSN.toUpperCase().replace(/[^0-9X]/g, '');
+        if (normalizedIssn in issnBundleIndex) {
+            return issnBundleIndex[normalizedIssn];
+        }
+    }
+};
+export const jatsFrontParser = {
+    async loadJournalBundles(issns) {
+        if (issns.length === 0) {
+            return {
+                manuscript_bundle: undefined,
+                bundleNodes: [],
+            };
+        }
+        const bundleID = await chooseBundle(issns);
+        const bundlesMap = bundleID ? await loadBundlesMap() : undefined;
+        const bundle = bundleID && bundlesMap ? createNewBundle(bundleID, bundlesMap) : undefined;
+        const parentBundle = bundle && bundleID && bundlesMap
+            ? createParentBundle(bundle, bundlesMap)
+            : undefined;
+        return {
+            manuscript_bundle: bundle === null || bundle === void 0 ? void 0 : bundle._id,
+            bundleNodes: [parentBundle, bundle].filter((v) => v !== 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 && typeof count === 'number') {
+                    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(journalMeta) {
+        if (!journalMeta) {
+            return {
+                journalIdentifiers: [],
+                abbreviatedTitles: [],
+                ISSNs: [],
+                publisherName: undefined,
+                title: undefined,
+            };
+        }
+        return parseJournalMeta(journalMeta);
+    },
+    parseKeywords(keywordGroupNodes) {
+        var _a, _b;
+        if (!keywordGroupNodes) {
+            return { groups: [], keywords: [] };
+        }
+        let keywordPriority = 1;
+        const keywordGroups = { groups: [], keywords: [] };
+        for (const keywordGroupNode of keywordGroupNodes) {
+            const manuscriptKeywordGroup = buildKeywordGroup({
+                title: ((_a = keywordGroupNode.querySelector('title')) === null || _a === void 0 ? void 0 : _a.textContent) || undefined,
+                label: ((_b = keywordGroupNode.querySelector('label')) === null || _b === void 0 ? void 0 : _b.textContent) || undefined,
+                type: keywordGroupNode.getAttribute('kwd-group-type') || undefined,
+            });
+            keywordGroups.groups.push(manuscriptKeywordGroup);
+            for (const keywordNode of keywordGroupNode.querySelectorAll('kwd')) {
+                if (keywordNode.textContent) {
+                    const keyword = buildKeyword(keywordNode.textContent);
+                    keyword.priority = keywordPriority++;
+                    keyword.containedGroup = manuscriptKeywordGroup._id;
+                    keywordGroups.keywords.push(keyword);
+                }
+            }
+        }
+        return keywordGroups;
+    },
+    parseDates(historyNode) {
+        if (!historyNode) {
+            return undefined;
+        }
+        const history = {};
+        const dateToTimestamp = (dateElement) => {
+            var _a, _b;
+            const selectors = ['year', 'month', 'day'];
+            const values = [];
+            for (const selector of selectors) {
+                const value = (_b = (_a = dateElement.querySelector(selector)) === null || _a === void 0 ? void 0 : _a.textContent) === null || _b === void 0 ? void 0 : _b.trim();
+                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;
+    },
+    parseSupplements(supplementNodes) {
+        var _a, _b, _c, _d, _e;
+        if (!supplementNodes || supplementNodes.length === 0) {
+            return [];
+        }
+        const supplements = [];
+        for (const supplementNode of supplementNodes) {
+            const supplTitle = (_b = (_a = supplementNode.querySelector('caption > title')) === null || _a === void 0 ? void 0 : _a.textContent) !== null && _b !== void 0 ? _b : '';
+            const href = (_c = supplementNode.getAttributeNS(XLINK_NAMESPACE, 'href')) !== null && _c !== void 0 ? _c : '';
+            const supplementaryMaterial = buildSupplementaryMaterial(supplTitle, href);
+            const mimeType = (_d = supplementNode.getAttribute('mimetype')) !== null && _d !== void 0 ? _d : '';
+            const mimeSubtype = (_e = supplementNode.getAttribute('mime-subtype')) !== null && _e !== void 0 ? _e : '';
+            if (mimeType && mimeSubtype) {
+                supplementaryMaterial.MIME = [mimeType, mimeSubtype].join('/');
+            }
+            supplements.push(supplementaryMaterial);
+        }
+        return supplements;
+    },
+    parseAffiliationNodes(affiliationNodes) {
+        const affiliationIDs = new Map();
+        const affiliations = affiliationNodes.map((affiliationNode, priority) => {
+            var _a, _b, _c, _d, _e;
+            const affiliation = buildAffiliation('', priority);
+            for (const node of affiliationNode.querySelectorAll('institution')) {
+                const content = node.textContent;
+                if (!content) {
+                    continue;
+                }
+                const contentType = node.getAttribute('content-type');
+                switch (contentType) {
+                    case null:
+                        affiliation.institution = content;
+                        break;
+                    case 'dept':
+                        affiliation.department = content;
+                        break;
+                }
+            }
+            affiliation.addressLine1 =
+                ((_a = affiliationNode.querySelector('addr-line:nth-of-type(1)')) === null || _a === void 0 ? void 0 : _a.textContent) || undefined;
+            affiliation.addressLine2 =
+                ((_b = affiliationNode.querySelector('addr-line:nth-of-type(2)')) === null || _b === void 0 ? void 0 : _b.textContent) || undefined;
+            affiliation.addressLine3 =
+                ((_c = affiliationNode.querySelector('addr-line:nth-of-type(3)')) === null || _c === void 0 ? void 0 : _c.textContent) || undefined;
+            const emailNode = affiliationNode.querySelector('email');
+            if (emailNode) {
+                affiliation.email = {
+                    href: emailNode.getAttributeNS(XLINK_NAMESPACE, 'href') || undefined,
+                    text: emailNode.textContent || undefined,
+                };
+            }
+            affiliation.postCode =
+                ((_d = affiliationNode.querySelector('postal-code')) === null || _d === void 0 ? void 0 : _d.textContent) || undefined;
+            affiliation.country =
+                ((_e = affiliationNode.querySelector('country')) === null || _e === void 0 ? void 0 : _e.textContent) || undefined;
+            const id = affiliationNode.getAttribute('id');
+            if (id) {
+                affiliationIDs.set(id, affiliation._id);
+            }
+            return affiliation;
+        });
+        return {
+            affiliations,
+            affiliationIDs,
+        };
+    },
+    parseFootnoteNodes(footnoteNodes) {
+        const footnoteIDs = new Map();
+        const footnotes = footnoteNodes.map((footnoteNode) => {
+            const fn = buildFootnote('', footnoteNode.innerHTML);
+            const id = footnoteNode.getAttribute('id');
+            if (id) {
+                footnoteIDs.set(id, fn._id);
+            }
+            return fn;
+        });
+        return {
+            footnotes,
+            footnoteIDs,
+        };
+    },
+    parseCorrespNodes(correspNodes) {
+        const correspondingIDs = new Map();
+        const correspondingList = correspNodes.map((correspNode) => {
+            var _a;
+            const label = correspNode.querySelector('label');
+            if (label) {
+                label.remove();
+            }
+            const corresponding = buildCorresp((_a = correspNode.textContent) !== null && _a !== void 0 ? _a : '');
+            corresponding.label = (label === null || label === void 0 ? void 0 : label.textContent) || undefined;
+            const id = correspNode.getAttribute('id');
+            if (id) {
+                correspondingIDs.set(id, corresponding._id);
+            }
+            return corresponding;
+        });
+        return {
+            correspondingList,
+            correspondingIDs,
+        };
+    },
+    parseAuthorNodes(authorNodes, affiliationIDs, footnoteIDs, correspondingIDs) {
+        return authorNodes.map((authorNode, priority) => {
+            var _a, _b, _c;
+            const name = buildBibliographicName({});
+            const given = (_a = authorNode.querySelector('name > given-names')) === null || _a === void 0 ? void 0 : _a.textContent;
+            if (given) {
+                name.given = given;
+            }
+            const surname = (_b = authorNode.querySelector('name > surname')) === null || _b === void 0 ? void 0 : _b.textContent;
+            if (surname) {
+                name.family = surname;
+            }
+            const contributor = buildContributor(name, 'author', priority);
+            const corresponding = authorNode.getAttribute('corresp') === 'yes';
+            if (corresponding) {
+                contributor.isCorresponding = corresponding;
+            }
+            const orcid = (_c = authorNode.querySelector('contrib-id[contrib-id-type="orcid"]')) === null || _c === void 0 ? void 0 : _c.textContent;
+            if (orcid) {
+                contributor.ORCIDIdentifier = orcid;
+            }
+            const xrefNodes = authorNode.querySelectorAll('xref');
+            for (const xrefNode of xrefNodes) {
+                if (xrefNode) {
+                    const rid = xrefNode.getAttribute('rid');
+                    const rtype = xrefNode.getAttribute('ref-type');
+                    if (rid) {
+                        if (rtype === 'fn') {
+                            contributor.footnote = [];
+                            const footnoteId = footnoteIDs.get(rid);
+                            if (footnoteId) {
+                                const authorFootNoteRef = {
+                                    noteID: footnoteId,
+                                    noteLabel: xrefNode.textContent || '',
+                                };
+                                contributor.footnote.push(authorFootNoteRef);
+                            }
+                        }
+                        else if (rtype === 'corresp') {
+                            contributor.corresp = [];
+                            const correspId = correspondingIDs.get(rid);
+                            if (correspId) {
+                                const authorCorrespRef = {
+                                    correspID: correspId,
+                                    correspLabel: xrefNode.textContent || '',
+                                };
+                                contributor.corresp.push(authorCorrespRef);
+                            }
+                        }
+                        else if (rtype === 'aff') {
+                            const rids = rid
+                                .split(/\s+/)
+                                .filter((id) => affiliationIDs.has(id))
+                                .map((id) => affiliationIDs.get(id));
+                            if (rids.length) {
+                                contributor.affiliations = rids;
+                            }
+                        }
+                    }
+                }
+            }
+            return contributor;
+        });
+    },
+};

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

@@ -0,0 +1,70 @@
+/*!
+ * © 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 const parseJournalIdentifiers = (journalMeta) => {
+    const output = [];
+    const elements = journalMeta.querySelectorAll('journal-id');
+    for (const element of elements) {
+        const journalIDType = element.getAttribute('journal-id-type');
+        const journalID = element.textContent;
+        if (journalID !== null && journalIDType != null) {
+            output.push({ journalIDType, journalID });
+        }
+        else if (journalID !== null) {
+            output.push({ journalID });
+        }
+    }
+    return output;
+};
+export const parseJournalAbbreviatedTitles = (journalMeta) => {
+    const output = [];
+    const elements = journalMeta.querySelectorAll('journal-title-group > abbrev-journal-title');
+    for (const element of elements) {
+        const abbrevType = element.getAttribute('abbrev-type');
+        const abbreviatedTitle = element.textContent;
+        if (abbreviatedTitle !== null && abbrevType !== null) {
+            output.push({ abbreviatedTitle, abbrevType });
+        }
+        else if (abbreviatedTitle !== null) {
+            output.push({ abbreviatedTitle });
+        }
+    }
+    return output;
+};
+export const parseJournalISSNs = (journalMeta) => {
+    const output = [];
+    const elements = journalMeta.querySelectorAll('issn');
+    for (const element of elements) {
+        const publicationType = element.getAttribute('pub-type');
+        const ISSN = element.textContent;
+        if (publicationType !== null && ISSN !== null) {
+            output.push({ publicationType, ISSN });
+        }
+        else if (ISSN !== null) {
+            output.push({ ISSN });
+        }
+    }
+    return output;
+};
+export const parseJournalMeta = (journalMeta) => {
+    var _a, _b, _c, _d;
+    return {
+        abbreviatedTitles: parseJournalAbbreviatedTitles(journalMeta),
+        journalIdentifiers: parseJournalIdentifiers(journalMeta),
+        ISSNs: parseJournalISSNs(journalMeta),
+        publisherName: (_b = (_a = journalMeta.querySelector('publisher > publisher-name')) === null || _a === void 0 ? void 0 : _a.textContent) !== null && _b !== void 0 ? _b : undefined,
+        title: (_d = (_c = journalMeta.querySelector('journal-title-group > journal-title')) === null || _c === void 0 ? void 0 : _c.textContent) !== null && _d !== void 0 ? _d : undefined,
+    };
+};

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

@@ -0,0 +1,139 @@
+/*!
+ * © 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 { ObjectTypes, } from '@manuscripts/manuscripts-json-schema';
+import { generateID, hasObjectType, nodeTypesMap } from '../../transformer';
+const isAuxiliaryObjectReference = hasObjectType(ObjectTypes.AuxiliaryObjectReference);
+export function flatten(arrays) {
+    return [].concat(...arrays);
+}
+export const fixBodyPMNode = (output, models, referenceIdsMap = new Map()) => {
+    const replacements = referenceIdsMap;
+    const warnings = [];
+    recurseDoc(output, (n) => addMissingID(n, replacements, warnings));
+    recurseDoc(output, (n) => addMissingRID(n, replacements, warnings));
+    return {
+        warnings: [...warnings, ...fixReferences(models, replacements)],
+        replacements,
+    };
+};
+function recurseDoc(node, fn) {
+    fn(node);
+    if (node.content) {
+        node.content.forEach((n) => recurseDoc(n, fn));
+    }
+}
+const addMissingID = (node, replacements, warnings) => {
+    if (!('id' in node.attrs)) {
+        return;
+    }
+    const objectType = nodeTypesMap.get(node.type);
+    if (!objectType) {
+        warnings.push(`Unknown object type for node type ${node.type.name}`);
+        return;
+    }
+    const previousID = node.attrs.id;
+    const nextID = generateID(objectType);
+    if (previousID) {
+        if (replacements.has(previousID) ||
+            Array.from(replacements.values()).includes(previousID)) {
+            warnings.push(`node.attrs.id ${previousID} exists twice!`);
+            return;
+        }
+        replacements.set(previousID, nextID);
+    }
+    node.attrs = Object.assign(Object.assign({}, node.attrs), { id: nextID });
+};
+const addMissingRID = (node, replacements, warnings) => {
+    const previousRID = node.attrs.rid;
+    if (!('rid' in node.attrs) || !previousRID) {
+        return;
+    }
+    if (!replacements.has(previousRID)) {
+    }
+    else {
+        node.attrs = Object.assign(Object.assign({}, node.attrs), { rid: replacements.get(previousRID) });
+    }
+};
+const fixReferences = (models, replacements) => {
+    const warnings = [];
+    const getReferenceId = (referencedObject) => {
+        const newReferencedId = replacements.get(referencedObject);
+        if (newReferencedId) {
+            return newReferencedId;
+        }
+        else {
+            warnings.push(`Missing replacement for model.referencedObject ${referencedObject}`);
+        }
+    };
+    models.forEach((model) => {
+        var _a;
+        if (isAuxiliaryObjectReference(model)) {
+            if (model.referencedObject) {
+                model.referencedObject = getReferenceId(model.referencedObject);
+            }
+            else {
+                const referencedObjects = [];
+                (_a = model.referencedObjects) === null || _a === void 0 ? void 0 : _a.map((reference) => {
+                    const referenceId = getReferenceId(reference);
+                    if (referenceId) {
+                        referencedObjects.push(referenceId);
+                    }
+                });
+                model.referencedObjects = referencedObjects;
+            }
+        }
+    });
+    return warnings;
+};
+const JATS_TO_HTML_MAPPING = new Map([
+    ['bold', 'b'],
+    ['italic', 'i'],
+    ['sc', 'style'],
+    ['sub', 'sub'],
+    ['sup', 'sup'],
+]);
+const renameJatsNodesToHTML = (node, container, createElement) => {
+    node.childNodes.forEach((childNode) => {
+        switch (childNode.nodeType) {
+            case Node.ELEMENT_NODE: {
+                const newNodeName = JATS_TO_HTML_MAPPING.get(childNode.nodeName);
+                if (newNodeName) {
+                    const newNode = createElement(newNodeName);
+                    renameJatsNodesToHTML(childNode, newNode, createElement);
+                    container.appendChild(newNode);
+                }
+                else {
+                    console.warn(`Unhandled node name: ${newNodeName}`);
+                    container.appendChild(childNode.cloneNode());
+                }
+                break;
+            }
+            case Node.TEXT_NODE:
+            default: {
+                container.appendChild(childNode.cloneNode());
+                break;
+            }
+        }
+    });
+};
+export const htmlFromJatsNode = (element, createElement) => {
+    if (!element) {
+        return undefined;
+    }
+    const temp = createElement('template');
+    renameJatsNodesToHTML(element, temp.content, createElement);
+    return temp.innerHTML;
+};