@manuscripts/transform 1.0.0

package/dist/cjs/transformer/highlight-markers.js

@@ -0,0 +1,126 @@
+"use strict";
+/*!
+ * © 2019 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.insertHighlightMarkers = exports.extractHighlightMarkers = exports.isHighlightableModel = void 0;
+const builders_1 = require("./builders");
+const highlightableFields = [
+    'caption',
+    'contents',
+    'title',
+];
+const isHighlightableModel = (model) => {
+    for (const field of highlightableFields) {
+        if (field in model) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.isHighlightableModel = isHighlightableModel;
+const extractHighlightMarkers = (model, commentAnnotationsMap) => {
+    for (const field of highlightableFields) {
+        let html = model[field];
+        if (html === undefined) {
+            continue;
+        }
+        const template = document.createElement('template');
+        template.innerHTML = `<div>${html}</div>`;
+        const element = template.content.firstChild;
+        if (!(element instanceof Element)) {
+            continue;
+        }
+        const markers = element.querySelectorAll('span.highlight-marker');
+        if (markers.length) {
+            for (const marker of markers) {
+                const markerHTML = marker.outerHTML;
+                const offset = html.indexOf(markerHTML);
+                if (offset === -1) {
+                    continue;
+                }
+                const _id = marker.getAttribute('id');
+                const target = marker.getAttribute('data-target-id');
+                if (_id && target) {
+                    const position = marker.getAttribute('data-position');
+                    const commentAnnotation = Object.assign(Object.assign({}, (0, builders_1.buildComment)(target, '')), { _id: _id });
+                    if (position === 'start') {
+                        commentAnnotationsMap.set(commentAnnotation._id, Object.assign(Object.assign({}, commentAnnotation), { selector: {
+                                from: offset,
+                                to: -1,
+                            } }));
+                    }
+                    else if (position === 'end') {
+                        const comment = commentAnnotationsMap.get(commentAnnotation._id);
+                        if (comment && comment.selector) {
+                            commentAnnotationsMap.set(comment._id, Object.assign(Object.assign({}, comment), { selector: Object.assign(Object.assign({}, comment.selector), { to: offset }) }));
+                        }
+                    }
+                    else if (position === 'point') {
+                        commentAnnotationsMap.set(commentAnnotation._id, Object.assign(Object.assign({}, commentAnnotation), { selector: { from: offset, to: offset } }));
+                    }
+                }
+                html = html.substr(0, offset) + html.substr(offset + markerHTML.length);
+            }
+            model[field] = html;
+        }
+    }
+};
+exports.extractHighlightMarkers = extractHighlightMarkers;
+const insertHighlightMarkers = (contents, commentAnnotations) => {
+    let output = contents;
+    const sortedComments = commentAnnotations.sort((a, b) => {
+        if (a.selector && b.selector) {
+            return b.selector.from - a.selector.from;
+        }
+        else {
+            return 0;
+        }
+    });
+    for (const comment of sortedComments) {
+        let element;
+        if (comment.selector) {
+            if (comment.selector.from === comment.selector.to) {
+                element = createHighlightElement(comment, 'point');
+                output = injectHighlightMarker(element, comment.selector.from, output);
+            }
+            else {
+                element = createHighlightElement(comment, 'start');
+                output = injectHighlightMarker(element, comment.selector.from, output);
+                const updatedEndOffset = element.outerHTML.length + comment.selector.to;
+                element = createHighlightElement(comment, 'end');
+                output = injectHighlightMarker(element, updatedEndOffset, output);
+            }
+        }
+    }
+    return output;
+};
+exports.insertHighlightMarkers = insertHighlightMarkers;
+function injectHighlightMarker(element, offset, contents) {
+    const parts = [
+        contents.substring(0, offset),
+        element.outerHTML,
+        contents.substring(offset),
+    ];
+    return parts.join('');
+}
+const createHighlightElement = (comment, position) => {
+    const element = document.createElement('span');
+    element.className = 'highlight-marker';
+    element.setAttribute('id', comment._id);
+    element.setAttribute('data-target-id', comment.target);
+    element.setAttribute('data-position', position);
+    return element;
+};

package/dist/cjs/transformer/html.js

@@ -0,0 +1,414 @@
+"use strict";
+/*!
+ * © 2019 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.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTMLTransformer = void 0;
+const manuscripts_json_schema_1 = require("@manuscripts/manuscripts-json-schema");
+const prosemirror_model_1 = require("prosemirror-model");
+const w3c_xmlserializer_1 = __importDefault(require("w3c-xmlserializer"));
+const jats_exporter_1 = require("../jats/jats-exporter");
+const styled_content_1 = require("../lib/styled-content");
+const schema_1 = require("../schema");
+const filename_1 = require("./filename");
+const labels_1 = require("./labels");
+const node_types_1 = require("./node-types");
+const object_types_1 = require("./object-types");
+const project_bundle_1 = require("./project-bundle");
+const section_category_1 = require("./section-category");
+const chooseNodeName = (element) => {
+    const nodeName = element.nodeName.toLowerCase();
+    if (nodeName === 'figure') {
+        if (element.classList.contains('table')) {
+            return 'figure-table';
+        }
+        if (element.classList.contains('listing')) {
+            return 'figure-listing';
+        }
+        if (element.classList.contains('equation')) {
+            return 'figure-equation';
+        }
+        return 'figure';
+    }
+    else if (nodeName === 'section') {
+        const sectionCategory = element.getAttribute('data-category');
+        if (sectionCategory) {
+            const secType = (0, section_category_1.chooseSecType)(sectionCategory);
+            if (secType) {
+                return secType;
+            }
+        }
+    }
+    else if (element.classList.length === 1) {
+        const className = element.classList.item(0);
+        if (className && !className.startsWith('MP')) {
+            return className;
+        }
+    }
+    return nodeName;
+};
+const createDefaultIdGenerator = () => {
+    const counter = (0, jats_exporter_1.createCounter)();
+    return async (element) => {
+        const nodeName = chooseNodeName(element);
+        const index = counter.increment(nodeName);
+        return `${nodeName}-${index}`;
+    };
+};
+class HTMLTransformer {
+    constructor() {
+        this.serializeToHTML = async (fragment, modelMap, options = {}) => {
+            const { idGenerator, mediaPathGenerator } = options;
+            this.modelMap = modelMap;
+            const manuscript = (0, project_bundle_1.findManuscript)(this.modelMap);
+            this.labelTargets = (0, labels_1.buildTargets)(fragment, manuscript);
+            this.document = document.implementation.createDocument('http://www.w3.org/1999/xhtml', 'html', document.implementation.createDocumentType('html', '', ''));
+            const article = this.document.createElement('article');
+            this.document.documentElement.appendChild(article);
+            article.appendChild(this.buildFront());
+            article.appendChild(this.buildBody(fragment));
+            this.fixBody(fragment);
+            await this.rewriteIDs(idGenerator);
+            if (mediaPathGenerator) {
+                await this.rewriteMediaPaths(mediaPathGenerator);
+            }
+            return (0, w3c_xmlserializer_1.default)(this.document);
+        };
+        this.rewriteMediaPaths = async (mediaPathGenerator) => {
+            for (const image of this.document.querySelectorAll('figure > img')) {
+                const parentFigure = image.parentNode;
+                if (parentFigure) {
+                    const parentID = parentFigure.getAttribute('data-uuid');
+                    if (parentID) {
+                        const newSrc = await mediaPathGenerator(image, parentID);
+                        image.setAttribute('src', newSrc);
+                    }
+                }
+            }
+        };
+        this.rewriteIDs = async (idGenerator = createDefaultIdGenerator()) => {
+            const idMap = new Map();
+            for (const element of this.document.querySelectorAll('[id]')) {
+                const previousID = element.getAttribute('id');
+                if (previousID && !previousID.match(/^MP[a-z]+:[a-z0-9-]+$/i)) {
+                    continue;
+                }
+                const newID = await idGenerator(element);
+                if (newID) {
+                    element.setAttribute('id', newID);
+                    if (previousID) {
+                        const ancores = [
+                            ...this.document.querySelectorAll(`a[href="#${previousID}"]`),
+                        ];
+                        ancores.map((a) => a.setAttribute('href', `#${newID}`));
+                        element.setAttribute('data-uuid', previousID);
+                    }
+                }
+                else {
+                    element.removeAttribute('id');
+                }
+                if (previousID) {
+                    idMap.set(previousID, newID);
+                }
+            }
+            for (const node of this.document.querySelectorAll('[data-reference-ids]')) {
+                const rids = node.getAttribute('data-reference-ids');
+                if (rids) {
+                    const newRIDs = rids
+                        .split(/\s+/)
+                        .filter(Boolean)
+                        .map((previousRID) => idMap.get(previousRID))
+                        .filter(Boolean);
+                    if (newRIDs.length) {
+                        node.setAttribute('data-reference-ids', newRIDs.join(' '));
+                    }
+                }
+            }
+            for (const node of this.document.querySelectorAll('[data-reference-id]')) {
+                const rid = node.getAttribute('data-reference-id');
+                if (rid) {
+                    const newRID = idMap.get(rid);
+                    if (newRID) {
+                        node.setAttribute('data-reference-id', newRID);
+                    }
+                }
+            }
+        };
+        this.buildFront = () => {
+            const manuscript = (0, project_bundle_1.findManuscript)(this.modelMap);
+            const journal = (0, project_bundle_1.findJournal)(this.modelMap);
+            if (!manuscript) {
+                throw new Error('Manuscript not found in project modelMap');
+            }
+            const front = this.document.createElement('header');
+            if (manuscript.headerFigure) {
+                const figure = this.modelMap.get(manuscript.headerFigure);
+                if (figure) {
+                    const headerFigure = document.createElement('figure');
+                    headerFigure.setAttribute('id', figure._id);
+                    front.appendChild(headerFigure);
+                    const filename = (0, filename_1.generateAttachmentFilename)(figure._id, figure.contentType);
+                    const img = this.document.createElement('img');
+                    img.setAttribute('src', filename);
+                    headerFigure.appendChild(img);
+                }
+            }
+            const articleMeta = this.document.createElement('div');
+            front.appendChild(articleMeta);
+            const articleTitle = this.document.createElement('h1');
+            if (manuscript.title) {
+                articleTitle.innerHTML = manuscript.title;
+            }
+            if (journal === null || journal === void 0 ? void 0 : journal.title) {
+                articleTitle.setAttribute('data-journal', journal.title);
+            }
+            articleMeta.appendChild(articleTitle);
+            if (manuscript.DOI) {
+                const articleID = this.document.createElement('article-id');
+                articleID.setAttribute('pub-id-type', 'doi');
+                articleID.innerHTML = manuscript.DOI;
+                articleMeta.append(articleID);
+            }
+            this.buildContributors(articleMeta);
+            return front;
+        };
+        this.buildBody = (fragment) => {
+            const getModel = (id) => id ? this.modelMap.get(id) : undefined;
+            const nodes = {};
+            for (const [name, node] of Object.entries(schema_1.schema.nodes)) {
+                if (node.spec.toDOM) {
+                    nodes[name] = node.spec.toDOM;
+                }
+            }
+            nodes.citation = (node) => {
+                const citationNode = node;
+                const element = this.document.createElement('span');
+                element.setAttribute('class', 'citation');
+                const citation = getModel(citationNode.attrs.rid);
+                if (citation) {
+                    element.setAttribute('data-reference-ids', citation.embeddedCitationItems
+                        .map((item) => item.bibliographyItem)
+                        .join(' '));
+                }
+                if (citationNode.attrs.contents) {
+                    element.innerHTML = citationNode.attrs.contents;
+                }
+                return element;
+            };
+            nodes.cross_reference = (node) => {
+                const crossReferenceNode = node;
+                const element = this.document.createElement('a');
+                element.classList.add('cross-reference');
+                const auxiliaryObjectReference = getModel(crossReferenceNode.attrs.rid);
+                if (auxiliaryObjectReference &&
+                    auxiliaryObjectReference.referencedObject) {
+                    if (auxiliaryObjectReference.referencedObject.startsWith('MPFigureElement')) {
+                        const model = getModel(auxiliaryObjectReference.referencedObject);
+                        if (model && model.containedObjectIDs.length > 0) {
+                            element.setAttribute('href', `#${model.containedObjectIDs[0]}`);
+                        }
+                    }
+                    else {
+                        element.setAttribute('href', `#${auxiliaryObjectReference.referencedObject}`);
+                    }
+                    element.setAttribute('data-reference-ids', crossReferenceNode.attrs.rid);
+                }
+                element.textContent = crossReferenceNode.attrs.label;
+                return element;
+            };
+            nodes.listing = (node) => {
+                const listingNode = node;
+                const pre = this.document.createElement('pre');
+                if (listingNode.attrs.id) {
+                    pre.setAttribute('id', listingNode.attrs.id);
+                }
+                pre.classList.add('listing');
+                const code = this.document.createElement('code');
+                if (listingNode.attrs.languageKey) {
+                    code.setAttribute('data-language', listingNode.attrs.languageKey);
+                }
+                code.textContent = listingNode.attrs.contents;
+                pre.appendChild(code);
+                return pre;
+            };
+            nodes.text = (node) => node.text;
+            const marks = {};
+            for (const [name, mark] of Object.entries(schema_1.schema.marks)) {
+                if (mark.spec.toDOM) {
+                    marks[name] = mark.spec.toDOM;
+                }
+            }
+            marks.styled = (mark) => {
+                const inlineStyle = getModel(mark.attrs.rid);
+                const attrs = {
+                    class: (0, styled_content_1.buildStyledContentClass)(mark.attrs, inlineStyle),
+                };
+                return ['span', attrs];
+            };
+            const serializer = new prosemirror_model_1.DOMSerializer(nodes, marks);
+            return serializer.serializeFragment(fragment, { document });
+        };
+        this.idSelector = (id) => '#' + id.replace(/:/g, '\\:');
+        this.fixFigure = (node) => {
+            const figure = this.document.querySelector(`[id="${node.attrs.id}"]`);
+            if (figure) {
+                const filename = (0, filename_1.generateAttachmentFilename)(node.attrs.id, node.attrs.contentType);
+                const img = this.document.createElement('img');
+                img.setAttribute('src', filename);
+                figure.insertBefore(img, figure.firstChild);
+            }
+        };
+        this.fixBody = (fragment) => {
+            fragment.descendants((node) => {
+                if (node.attrs.id) {
+                    const selector = this.idSelector(node.attrs.id);
+                    const element = this.document.querySelector(`${selector}`);
+                    if (element && this.labelTargets) {
+                        const target = this.labelTargets.get(node.attrs.id);
+                        if (target) {
+                            const label = this.document.createElement('label');
+                            label.textContent = target.label;
+                            element.appendChild(label);
+                        }
+                    }
+                    if (node.attrs.titleSuppressed) {
+                        const title = this.document.querySelector(`${selector} > h1`);
+                        if (title && title.parentNode) {
+                            title.parentNode.removeChild(title);
+                        }
+                    }
+                    if (node.attrs.suppressCaption) {
+                        const caption = this.document.querySelector(`${selector} > figcaption`);
+                        if (caption && caption.parentNode) {
+                            caption.parentNode.removeChild(caption);
+                        }
+                    }
+                    if ((0, node_types_1.isNodeType)(node, 'figure')) {
+                        this.fixFigure(node);
+                    }
+                    if ((0, node_types_1.isNodeType)(node, 'figure_element')) {
+                        const figureGroup = this.document.querySelector(`${selector}`);
+                        if (figureGroup) {
+                            const figures = this.document.querySelectorAll(`${selector} > figure`);
+                            const caption = this.document.querySelector(`${selector} > figcaption`);
+                            const listing = this.document.querySelector(`${selector} > pre.listing`);
+                            if (listing && !listing.textContent) {
+                                listing.remove();
+                            }
+                            if (figures.length === 1) {
+                                const [figure] = figures;
+                                figure.setAttribute('data-fig-type', 'figure');
+                                if (caption) {
+                                    figure.insertBefore(caption, figure.firstChild);
+                                }
+                                const label = this.document.querySelector(`${selector} > label`);
+                                if (label) {
+                                    figure.insertBefore(label, figure.firstChild);
+                                }
+                                if (figureGroup.parentElement) {
+                                    figureGroup.parentElement.replaceChild(figure, figureGroup);
+                                }
+                            }
+                            if (figures.length === 0 && !caption) {
+                                figureGroup.remove();
+                            }
+                        }
+                    }
+                }
+            });
+        };
+    }
+    buildContributors(articleMeta) {
+        const contributors = Array.from(this.modelMap.values()).filter((0, object_types_1.hasObjectType)(manuscripts_json_schema_1.ObjectTypes.Contributor));
+        const affiliationIDs = [];
+        if (contributors && contributors.length) {
+            const contribGroup = this.document.createElement('div');
+            contribGroup.classList.add('contrib-group');
+            articleMeta.appendChild(contribGroup);
+            contributors.sort((a, b) => Number(a.priority) - Number(b.priority));
+            contributors.forEach((contributor) => {
+                const contrib = this.document.createElement('span');
+                contrib.classList.add('contrib');
+                contrib.setAttribute('id', contributor._id);
+                if (contributor.isCorresponding) {
+                    contrib.setAttribute('data-corresp', 'yes');
+                }
+                const name = this.document.createElement('span');
+                name.classList.add('contrib-name');
+                contrib.appendChild(name);
+                const { given, family } = contributor.bibliographicName;
+                if (given) {
+                    const givenNames = this.document.createElement('span');
+                    givenNames.classList.add('contrib-given-names');
+                    givenNames.textContent = given;
+                    name.appendChild(givenNames);
+                }
+                if (family) {
+                    if (given) {
+                        const separator = document.createTextNode(' ');
+                        name.appendChild(separator);
+                    }
+                    const surname = this.document.createElement('span');
+                    surname.classList.add('contrib-surname');
+                    surname.textContent = family;
+                    name.appendChild(surname);
+                }
+                if (contributor.email) {
+                    const link = this.document.createElement('a');
+                    link.href = `mailto:${contributor.email}`;
+                    contrib.appendChild(link);
+                }
+                if (contributor.affiliations) {
+                    contributor.affiliations.forEach((rid) => {
+                        const link = this.document.createElement('a');
+                        link.setAttribute('data-ref-type', 'aff');
+                        link.setAttribute('href', '#' + rid);
+                        const affiliationIndex = affiliationIDs.indexOf(rid);
+                        if (affiliationIndex > -1) {
+                            link.textContent = String(affiliationIndex + 1);
+                        }
+                        else {
+                            affiliationIDs.push(rid);
+                            link.textContent = String(affiliationIDs.length);
+                        }
+                        contrib.appendChild(link);
+                    });
+                }
+                contribGroup.appendChild(contrib);
+            });
+        }
+        if (affiliationIDs.length) {
+            const affiliationList = this.document.createElement('ol');
+            affiliationList.classList.add('affiliations-list');
+            articleMeta.appendChild(affiliationList);
+            for (const affiliationID of affiliationIDs) {
+                const affiliation = this.modelMap.get(affiliationID);
+                if (affiliation) {
+                    const affiliationItem = this.document.createElement('li');
+                    affiliationItem.classList.add('affiliation');
+                    affiliationItem.setAttribute('id', affiliation._id);
+                    if (affiliation.institution) {
+                        affiliationItem.textContent = affiliation.institution;
+                    }
+                    affiliationList.appendChild(affiliationItem);
+                }
+            }
+        }
+    }
+}
+exports.HTMLTransformer = HTMLTransformer;

package/dist/cjs/transformer/id.js

@@ -0,0 +1,28 @@
+"use strict";
+/*!
+ * © 2019 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.generateID = exports.generateNodeID = void 0;
+const uuid_1 = require("uuid");
+const node_types_1 = require("./node-types");
+const generateNodeID = (type) => {
+    return node_types_1.nodeTypesMap.get(type) + ':' + (0, uuid_1.v4)().toUpperCase();
+};
+exports.generateNodeID = generateNodeID;
+const generateID = (objectType) => {
+    return objectType + ':' + (0, uuid_1.v4)().toUpperCase();
+};
+exports.generateID = generateID;

package/dist/cjs/transformer/index.js

@@ -0,0 +1,54 @@
+"use strict";
+/*!
+ * © 2019 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./builders"), exports);
+__exportStar(require("./bundles"), exports);
+__exportStar(require("./decode"), exports);
+__exportStar(require("./document-object-types"), exports);
+__exportStar(require("./encode"), exports);
+__exportStar(require("./filename"), exports);
+__exportStar(require("./highlight-markers"), exports);
+__exportStar(require("./html"), exports);
+__exportStar(require("./id"), exports);
+__exportStar(require("./labels"), exports);
+__exportStar(require("./manuscript-dependencies"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./node-names"), exports);
+__exportStar(require("./node-title"), exports);
+__exportStar(require("./node-types"), exports);
+__exportStar(require("./object-types"), exports);
+__exportStar(require("./project-bundle"), exports);
+__exportStar(require("./section-category"), exports);
+__exportStar(require("./serializer"), exports);
+__exportStar(require("./shared-data"), exports);
+__exportStar(require("./tei-grobid-importer"), exports);
+__exportStar(require("./timestamp"), exports);
+__exportStar(require("./update-identifiers"), exports);