@manuscripts/transform 1.0.0

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

@@ -0,0 +1,120 @@
+/*!
+ * © 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.
+ */
+import { buildComment } from './builders';
+const highlightableFields = [
+    'caption',
+    'contents',
+    'title',
+];
+export const isHighlightableModel = (model) => {
+    for (const field of highlightableFields) {
+        if (field in model) {
+            return true;
+        }
+    }
+    return false;
+};
+export 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({}, 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;
+        }
+    }
+};
+export 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;
+};
+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/es/transformer/html.js

@@ -0,0 +1,407 @@
+/*!
+ * © 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.
+ */
+import { ObjectTypes, } from '@manuscripts/manuscripts-json-schema';
+import { DOMSerializer } from 'prosemirror-model';
+import serializeToXML from 'w3c-xmlserializer';
+import { createCounter } from '../jats/jats-exporter';
+import { buildStyledContentClass } from '../lib/styled-content';
+import { schema, } from '../schema';
+import { generateAttachmentFilename } from './filename';
+import { buildTargets } from './labels';
+import { isNodeType } from './node-types';
+import { hasObjectType } from './object-types';
+import { findJournal, findManuscript } from './project-bundle';
+import { chooseSecType } from './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 = 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 = createCounter();
+    return async (element) => {
+        const nodeName = chooseNodeName(element);
+        const index = counter.increment(nodeName);
+        return `${nodeName}-${index}`;
+    };
+};
+export class HTMLTransformer {
+    constructor() {
+        this.serializeToHTML = async (fragment, modelMap, options = {}) => {
+            const { idGenerator, mediaPathGenerator } = options;
+            this.modelMap = modelMap;
+            const manuscript = findManuscript(this.modelMap);
+            this.labelTargets = 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 serializeToXML(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 = findManuscript(this.modelMap);
+            const journal = 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 = 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.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.marks)) {
+                if (mark.spec.toDOM) {
+                    marks[name] = mark.spec.toDOM;
+                }
+            }
+            marks.styled = (mark) => {
+                const inlineStyle = getModel(mark.attrs.rid);
+                const attrs = {
+                    class: buildStyledContentClass(mark.attrs, inlineStyle),
+                };
+                return ['span', attrs];
+            };
+            const serializer = new 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 = 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 (isNodeType(node, 'figure')) {
+                        this.fixFigure(node);
+                    }
+                    if (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(hasObjectType(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);
+                }
+            }
+        }
+    }
+}

package/dist/es/transformer/id.js

@@ -0,0 +1,23 @@
+/*!
+ * © 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.
+ */
+import { v4 as uuid } from 'uuid';
+import { nodeTypesMap } from './node-types';
+export const generateNodeID = (type) => {
+    return nodeTypesMap.get(type) + ':' + uuid().toUpperCase();
+};
+export const generateID = (objectType) => {
+    return objectType + ':' + uuid().toUpperCase();
+};

package/dist/es/transformer/index.js

@@ -0,0 +1,38 @@
+/*!
+ * © 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.
+ */
+export * from './builders';
+export * from './bundles';
+export * from './decode';
+export * from './document-object-types';
+export * from './encode';
+export * from './filename';
+export * from './highlight-markers';
+export * from './html';
+export * from './id';
+export * from './labels';
+export * from './manuscript-dependencies';
+export * from './models';
+export * from './node-names';
+export * from './node-title';
+export * from './node-types';
+export * from './object-types';
+export * from './project-bundle';
+export * from './section-category';
+export * from './serializer';
+export * from './shared-data';
+export * from './tei-grobid-importer';
+export * from './timestamp';
+export * from './update-identifiers';

package/dist/es/transformer/labels.js

@@ -0,0 +1,81 @@
+/*!
+ * © 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 { schema } from '../schema';
+import { nodeNames } from './node-names';
+const labelledNodeTypes = [
+    schema.nodes.figure_element,
+    schema.nodes.table_element,
+    schema.nodes.equation_element,
+    schema.nodes.listing_element,
+];
+const labelProperties = new Map([
+    [schema.nodes.figure_element, 'figureElementLabel'],
+    [schema.nodes.table_element, 'tableElementLabel'],
+    [schema.nodes.equation_element, 'equationElementLabel'],
+    [schema.nodes.listing_element, 'listingElementLabel'],
+]);
+const chooseLabel = (nodeType, manuscript) => {
+    const labelProperty = labelProperties.get(nodeType);
+    if (labelProperty) {
+        const label = manuscript[labelProperty];
+        if (label) {
+            return label;
+        }
+    }
+    return nodeNames.get(nodeType);
+};
+export const buildTargets = (fragment, manuscript) => {
+    const counters = {};
+    for (const nodeType of labelledNodeTypes) {
+        counters[nodeType.name] = {
+            label: chooseLabel(nodeType, manuscript),
+            index: 0,
+        };
+    }
+    const buildLabel = (type) => {
+        const viewLabel = type;
+        const counter = counters[viewLabel.name];
+        counter.index++;
+        return `${counter.label} ${counter.index}`;
+    };
+    const targets = new Map();
+    const figures = [];
+    fragment.forEach((node) => {
+        if (node.type === node.type.schema.nodes.graphical_abstract_section) {
+            node.forEach((item) => {
+                if (item.type === node.type.schema.nodes.figure_element) {
+                    figures.push(item.attrs.id);
+                }
+            });
+        }
+    });
+    fragment.descendants((node) => {
+        if (node.type.name in counters) {
+            const isInGraphicalAbstract = figures.indexOf(node.attrs.id) > -1;
+            if (isInGraphicalAbstract) {
+                return;
+            }
+            const label = buildLabel(node.type);
+            targets.set(node.attrs.id, {
+                type: node.type.name,
+                id: node.attrs.id,
+                label,
+                caption: node.textContent,
+            });
+        }
+    });
+    return targets;
+};