@manuscripts/transform 1.0.0

package/dist/cjs/jats/importer/jats-body-transformations.js

@@ -0,0 +1,269 @@
+"use strict";
+/*!
+ * © 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jatsBodyTransformations = void 0;
+const transformer_1 = require("../../transformer");
+const removeNodeFromParent = (node) => node.parentNode && node.parentNode.removeChild(node);
+const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+exports.jatsBodyTransformations = {
+    ensureSection(body, createElement) {
+        let section = createElement('sec');
+        const title = section.querySelector('title');
+        if (!title) {
+            const title = createElement('title');
+            title.textContent = '';
+            section.appendChild(title);
+        }
+        const { firstElementChild } = body;
+        if (firstElementChild && firstElementChild.tagName === 'sec') {
+            section = firstElementChild;
+        }
+        else {
+            body.insertBefore(section, body.firstChild);
+        }
+        body.childNodes.forEach((child) => {
+            if (child.nodeType === Node.ELEMENT_NODE) {
+                const element = child;
+                if (element.tagName !== 'sec') {
+                    section.appendChild(element);
+                }
+                else {
+                    section = element;
+                }
+            }
+        });
+    },
+    createAbstract(abstractNode, createElement) {
+        const abstractType = abstractNode.getAttribute('abstract-type');
+        const section = createElement('sec');
+        const sectionType = abstractType ? `abstract-${abstractType}` : 'abstract';
+        section.setAttribute('sec-type', sectionType);
+        const title = createElement('title');
+        title.textContent = abstractType
+            ? `${capitalizeFirstLetter(abstractType)} Abstract`
+            : 'Abstract';
+        section.appendChild(title);
+        while (abstractNode.firstChild) {
+            section.appendChild(abstractNode.firstChild);
+        }
+        return section;
+    },
+    createAcknowledgments(ackNode, createElement) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'acknowledgments');
+        const titleNode = ackNode.querySelector('title');
+        if (titleNode) {
+            section.appendChild(titleNode);
+        }
+        else {
+            const title = createElement('title');
+            title.textContent = 'Acknowledgements';
+            section.appendChild(title);
+        }
+        while (ackNode.firstChild) {
+            section.appendChild(ackNode.firstChild);
+        }
+        return section;
+    },
+    createBibliography(doc, references, createElement) {
+        const bibSec = doc.createElement('sec');
+        bibSec.setAttribute('sec-type', 'bibliography');
+        const titleNode = doc.querySelector('back > ref-list > title');
+        if (titleNode) {
+            bibSec.appendChild(titleNode);
+        }
+        else {
+            const title = createElement('title');
+            title.textContent = 'References';
+            bibSec.appendChild(title);
+        }
+        const refList = doc.createElement('ref-list');
+        for (const ref of references) {
+            const item = doc.createElement('ref');
+            item.setAttribute('id', ref._id);
+            item.setAttribute('type', ref.type);
+            item.setAttribute('author', JSON.stringify(ref.author));
+            item.setAttribute('issued', JSON.stringify(ref.issued));
+            ref['container-title'] &&
+                item.setAttribute('container-title', ref['container-title']);
+            ref.DOI && item.setAttribute('doi', ref.DOI);
+            ref.volume && item.setAttribute('volume', ref.volume.toString());
+            ref.issue && item.setAttribute('issue', ref.issue.toString());
+            ref.supplement && item.setAttribute('supplement', ref.supplement);
+            ref.page && item.setAttribute('page', ref.page.toString());
+            ref.title && item.setAttribute('title', ref.title);
+            ref.literal && item.setAttribute('literal', ref.literal);
+            refList.appendChild(item);
+        }
+        bibSec.appendChild(refList);
+        return bibSec;
+    },
+    createFootnotes(footnoteGroups, createElement) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'endnotes');
+        const titleNode = footnoteGroups
+            .map((g) => g.querySelector('title'))
+            .filter((t) => t !== null)[0];
+        if (titleNode) {
+            section.appendChild(titleNode);
+        }
+        else {
+            const title = createElement('title');
+            title.textContent = 'Footnotes';
+            section.appendChild(title);
+        }
+        for (const footnoteGroup of footnoteGroups) {
+            section.appendChild(footnoteGroup);
+        }
+        return section;
+    },
+    createAppendixSection(app, createElement) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'appendices');
+        section.append(...app.children);
+        return section;
+    },
+    createFloatsGroupSection(floatsGroup, createElement) {
+        const section = createElement('sec');
+        section.setAttribute('sec-type', 'floating-element');
+        const title = createElement('title');
+        title.textContent = 'Floating Group';
+        section.appendChild(title);
+        section.append(...floatsGroup.children);
+        return section;
+    },
+    moveSectionsToBody(doc, body, references, createElement) {
+        const abstractNodes = doc.querySelectorAll('front > article-meta > abstract');
+        for (const abstractNode of abstractNodes) {
+            const abstract = this.createAbstract(abstractNode, createElement);
+            removeNodeFromParent(abstractNode);
+            body.insertBefore(abstract, body.firstChild);
+        }
+        for (const section of doc.querySelectorAll('back > sec')) {
+            removeNodeFromParent(section);
+            body.appendChild(section);
+        }
+        const ackNode = doc.querySelector('back > ack');
+        if (ackNode) {
+            const acknowledgements = this.createAcknowledgments(ackNode, createElement);
+            removeNodeFromParent(ackNode);
+            body.appendChild(acknowledgements);
+        }
+        const appGroup = doc.querySelectorAll('back > app-group > app');
+        for (const app of appGroup) {
+            const appendix = this.createAppendixSection(app, createElement);
+            removeNodeFromParent(app);
+            body.appendChild(appendix);
+        }
+        if (references) {
+            body.appendChild(this.createBibliography(doc, references, createElement));
+        }
+    },
+    mapFootnotesToSections(doc, body, createElement) {
+        const footnoteGroups = [...doc.querySelectorAll('fn[fn-type]')];
+        for (const footnote of footnoteGroups) {
+            const type = footnote.getAttribute('fn-type') || '';
+            const category = (0, transformer_1.chooseSectionCategoryByType)(type);
+            if (category) {
+                const section = createElement('sec');
+                const title = footnote.querySelector('p[content-type="fn-title"]');
+                if (title) {
+                    const sectionTitleElement = createElement('title');
+                    sectionTitleElement.textContent = title.textContent;
+                    removeNodeFromParent(title);
+                    section.append(sectionTitleElement);
+                }
+                section.append(...footnote.children);
+                removeNodeFromParent(footnote);
+                section.setAttribute('sec-type', (0, transformer_1.chooseSecType)(category));
+                body.append(section);
+            }
+        }
+        const footnotes = [...doc.querySelectorAll('fn')];
+        const footnotesSection = doc.querySelector('sec[sec-type="endnotes"]');
+        const footnotesSectionGroup = footnotesSection === null || footnotesSection === void 0 ? void 0 : footnotesSection.querySelector('fn-group');
+        const containingGroup = footnotesSectionGroup || createElement('fn-group');
+        for (const footnote of footnotes) {
+            const type = footnote.getAttribute('fn-type');
+            if (!type) {
+                containingGroup.appendChild(footnote);
+            }
+        }
+        if (!footnotesSection && containingGroup.innerHTML) {
+            const section = this.createFootnotes([containingGroup], createElement);
+            body.append(section);
+        }
+        let regularFootnoteGroups = [
+            ...doc.querySelectorAll('back > fn-group:not([fn-type])'),
+        ];
+        regularFootnoteGroups = regularFootnoteGroups.filter((group) => {
+            return group.childElementCount === 0
+                ? false
+                : !group.querySelector('fn[fn-type]');
+        });
+        if (regularFootnoteGroups.length > 0) {
+            regularFootnoteGroups.map((g) => removeNodeFromParent(g));
+            const footnotes = this.createFootnotes(regularFootnoteGroups, createElement);
+            body.appendChild(footnotes);
+        }
+    },
+    moveCaptionsToEnd(body) {
+        const captions = body.querySelectorAll('caption');
+        for (const caption of captions) {
+            if (caption.parentNode) {
+                caption.parentNode.appendChild(caption);
+            }
+        }
+    },
+    moveTableFooterToEnd(body) {
+        const tableFooters = body.querySelectorAll('table-wrap-foot');
+        for (const tableFooter of tableFooters) {
+            if (tableFooter.parentNode) {
+                tableFooter.parentNode.appendChild(tableFooter);
+            }
+        }
+    },
+    moveFloatsGroupToBody(doc, body, createElement) {
+        const floatsGroup = doc.querySelector('floats-group');
+        if (floatsGroup) {
+            const floatsGroupSection = this.createFloatsGroupSection(floatsGroup, createElement);
+            removeNodeFromParent(floatsGroup);
+            body.appendChild(floatsGroupSection);
+        }
+    },
+    moveBlockNodesFromParagraph(doc, body, createElement) {
+        const blockNodes = ['disp-formula'];
+        const paragraphs = [...body.querySelectorAll('sec > p')].filter((node) => blockNodes.find((node_name) => node.querySelector(`:scope > ${node_name}`)));
+        paragraphs.map((paragraph) => {
+            let newParagraph = createElement('p');
+            const parent = doc.createDocumentFragment();
+            while (paragraph === null || paragraph === void 0 ? void 0 : paragraph.firstChild) {
+                if (blockNodes.includes(paragraph === null || paragraph === void 0 ? void 0 : paragraph.firstChild.nodeName)) {
+                    if (newParagraph.innerHTML.trim().length > 0) {
+                        parent.append(newParagraph);
+                        newParagraph = createElement('p');
+                    }
+                    parent.append(paragraph === null || paragraph === void 0 ? void 0 : paragraph.firstChild);
+                }
+                else {
+                    newParagraph.append(paragraph === null || paragraph === void 0 ? void 0 : paragraph.firstChild);
+                }
+            }
+            paragraph === null || paragraph === void 0 ? void 0 : paragraph.replaceWith(parent);
+        });
+    },
+};

package/dist/cjs/jats/importer/jats-comments.js

@@ -0,0 +1,131 @@
+"use strict";
+/*!
+ * © 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReferenceComments = exports.createComments = exports.markProcessingInstructions = exports.parseProcessingInstruction = void 0;
+const uuid_1 = require("uuid");
+const transformer_1 = require("../../transformer");
+const DEFAULT_ANNOTATION_COLOR = 'rgb(250, 224, 150)';
+const DEFAULT_PROFILE_ID = 'MPUserProfile:0000000000000000000000000000000000000001';
+const parseProcessingInstruction = (node) => {
+    const value = `<AuthorQuery ${node.textContent} />`;
+    const processingInstruction = new DOMParser().parseFromString(value, 'application/xml').firstElementChild;
+    if (processingInstruction) {
+        const queryText = processingInstruction.getAttribute('queryText');
+        const id = processingInstruction.getAttribute('id');
+        if (queryText && id) {
+            return { queryText, id };
+        }
+    }
+};
+exports.parseProcessingInstruction = parseProcessingInstruction;
+const markProcessingInstructions = (doc) => {
+    const authorQueriesMap = new Map();
+    const root = doc.getRootNode();
+    const queue = [root];
+    while (queue.length !== 0) {
+        const node = queue.shift();
+        if (node) {
+            const { nodeType, nodeName } = node;
+            if (nodeType === node.PROCESSING_INSTRUCTION_NODE &&
+                nodeName === 'AuthorQuery') {
+                insertToken(doc, node, authorQueriesMap);
+            }
+            node.childNodes.forEach((child) => {
+                queue.push(child);
+            });
+        }
+    }
+    return authorQueriesMap;
+};
+exports.markProcessingInstructions = markProcessingInstructions;
+const insertToken = (doc, processingInstructionNode, authorQueriesMap) => {
+    const instruction = (0, exports.parseProcessingInstruction)(processingInstructionNode);
+    const { parentElement } = processingInstructionNode;
+    if (parentElement && instruction) {
+        const { queryText } = instruction;
+        const token = (0, uuid_1.v4)();
+        const tokenNode = doc.createTextNode(token);
+        authorQueriesMap.set(token, queryText);
+        return parentElement.insertBefore(tokenNode, processingInstructionNode);
+    }
+};
+const createComments = (authorQueriesMap, manuscriptModels) => {
+    const tokens = [...authorQueriesMap.keys()];
+    const commentAnnotations = [];
+    for (const model of manuscriptModels) {
+        if ((0, transformer_1.isHighlightableModel)(model)) {
+            const comments = addCommentsFromMarkedProcessingInstructions(tokens, model, authorQueriesMap);
+            commentAnnotations.push(...comments);
+        }
+    }
+    return commentAnnotations;
+};
+exports.createComments = createComments;
+const addCommentsFromMarkedProcessingInstructions = (tokens, model, authorQueriesMap) => {
+    const commentAnnotations = [];
+    for (const field of ['contents', 'caption', 'title']) {
+        const highlightableField = field;
+        const content = model[highlightableField];
+        if (!content) {
+            continue;
+        }
+        const sortedTokens = tokens
+            .filter((token) => content.indexOf(token) >= 0)
+            .sort((a, b) => content.indexOf(a) - content.indexOf(b));
+        let contentWithoutTokens = content;
+        for (const token of sortedTokens) {
+            const query = authorQueriesMap.get(token);
+            if (query) {
+                const trimmedTextContent = contentWithoutTokens
+                    ? contentWithoutTokens.replace(/^\s+/gm, '')
+                    : undefined;
+                const startTokenIndex = trimmedTextContent
+                    ? trimmedTextContent.indexOf(token)
+                    : undefined;
+                contentWithoutTokens = contentWithoutTokens.replace(token, '');
+                const comment = `${query}`;
+                const target = model._id && !(0, transformer_1.isCommentAnnotation)(model) ? model._id : (0, uuid_1.v4)();
+                const contributions = [(0, transformer_1.buildContribution)(DEFAULT_PROFILE_ID)];
+                const selector = startTokenIndex
+                    ? { from: startTokenIndex, to: startTokenIndex }
+                    : undefined;
+                const commentAnnotation = (0, transformer_1.buildComment)(target, comment, selector, contributions, DEFAULT_ANNOTATION_COLOR);
+                commentAnnotations.push(commentAnnotation);
+            }
+        }
+        model[highlightableField] = contentWithoutTokens;
+    }
+    return commentAnnotations;
+};
+const createReferenceComments = (referenceQueriesMap, references) => {
+    const comments = [];
+    for (const reference of references) {
+        const id = reference._id;
+        if (referenceQueriesMap.has(id)) {
+            for (const comment of referenceQueriesMap.get(id) || []) {
+                const target = reference._id && !(0, transformer_1.isCommentAnnotation)(reference)
+                    ? reference._id
+                    : (0, uuid_1.v4)();
+                const contributions = [(0, transformer_1.buildContribution)(DEFAULT_PROFILE_ID)];
+                const commentAnnotation = (0, transformer_1.buildComment)(target, comment, undefined, contributions, DEFAULT_ANNOTATION_COLOR);
+                comments.push(commentAnnotation);
+            }
+        }
+    }
+    return comments;
+};
+exports.createReferenceComments = createReferenceComments;