@manuscripts/transform 1.0.0

package/dist/es/transformer/decode.js

@@ -0,0 +1,608 @@
+/*!
+ * © 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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ObjectTypes, } from '@manuscripts/manuscripts-json-schema';
+import debug from 'debug';
+import { DOMParser } from 'prosemirror-model';
+import { MissingElement } from '../errors';
+import { schema, } from '../schema';
+import { insertHighlightMarkers } from './highlight-markers';
+import { generateNodeID } from './id';
+import { ExtraObjectTypes, hasObjectType, isCommentAnnotation, isManuscript, } from './object-types';
+import { chooseSectionLableName, chooseSectionNodeType, chooseSecType, guessSectionCategory, } from './section-category';
+import { timestamp } from './timestamp';
+const warn = debug('manuscripts-transform');
+const parser = DOMParser.fromSchema(schema);
+export const getModelData = (model) => {
+    const { _rev, _deleted, updatedAt, createdAt, sessionID } = model, data = __rest(model, ["_rev", "_deleted", "updatedAt", "createdAt", "sessionID"]);
+    return data;
+};
+export const getModelsByType = (modelMap, objectType) => {
+    const output = [];
+    for (const model of modelMap.values()) {
+        if (model.objectType === objectType) {
+            output.push(model);
+        }
+    }
+    return output;
+};
+export const sortSectionsByPriority = (a, b) => a.priority === b.priority ? 0 : Number(a.priority) - Number(b.priority);
+const getSections = (modelMap) => getModelsByType(modelMap, ObjectTypes.Section).sort(sortSectionsByPriority);
+export const isManuscriptNode = (model) => model !== null;
+const isParagraphElement = hasObjectType(ObjectTypes.ParagraphElement);
+const isFootnote = hasObjectType(ObjectTypes.Footnote);
+const hasParentSection = (id) => (section) => section.path &&
+    section.path.length > 1 &&
+    section.path[section.path.length - 2] === id;
+export class Decoder {
+    createCommentsNode(model) {
+        const comments = [];
+        for (const comment of this.getComments(model)) {
+            comments.push(this.decode(comment));
+        }
+        return comments;
+    }
+    getComments(model) {
+        return Array.from(this.modelMap.values()).filter((c) => isCommentAnnotation(c) && c.target === model._id);
+    }
+    extractListing(model) {
+        if (model.listingID) {
+            const listingModel = this.getModel(model.listingID);
+            let listing;
+            if (listingModel) {
+                listing = this.decode(listingModel);
+            }
+            else if (this.allowMissingElements) {
+                listing = schema.nodes.placeholder.create({
+                    id: model.listingID,
+                    label: 'A listing',
+                });
+            }
+            else {
+                throw new MissingElement(model.listingID);
+            }
+            return listing;
+        }
+    }
+    constructor(modelMap, allowMissingElements = false) {
+        this.creators = {
+            [ObjectTypes.BibliographyElement]: (data) => {
+                var _a;
+                const model = data;
+                const referenceIDs = (_a = model.containedObjectIDs) === null || _a === void 0 ? void 0 : _a.filter((i) => i.startsWith('MPBibliographyItem'));
+                const references = [];
+                referenceIDs === null || referenceIDs === void 0 ? void 0 : referenceIDs.forEach((id) => {
+                    const referenceModel = this.getModel(id);
+                    if (referenceModel) {
+                        return references.push(this.decode(referenceModel));
+                    }
+                });
+                if (!references.length) {
+                    references.push(schema.nodes.placeholder.createAndFill());
+                }
+                return schema.nodes.bibliography_element.createChecked({
+                    id: model._id,
+                    contents: '',
+                    paragraphStyle: model.paragraphStyle,
+                }, references);
+            },
+            [ObjectTypes.BibliographyItem]: (data) => {
+                const model = data;
+                return schema.nodes.bibliography_item.create({
+                    id: model._id,
+                    type: model.type,
+                    author: model.author,
+                    issued: model.issued,
+                    containerTitle: model['container-title'],
+                    volume: model.volume,
+                    issue: model.issue,
+                    supplement: model.supplement,
+                    doi: model.DOI,
+                    page: model.page,
+                    title: model.title,
+                    literal: model.literal,
+                });
+            },
+            [ExtraObjectTypes.PlaceholderElement]: (data) => {
+                const model = data;
+                return schema.nodes.placeholder_element.create({
+                    id: model._id,
+                });
+            },
+            [ObjectTypes.Figure]: (data) => {
+                const model = data;
+                return schema.nodes.figure.create({
+                    id: model._id,
+                    contentType: model.contentType,
+                    src: model.src,
+                    position: model.position,
+                    comments: this.createCommentsNode(model),
+                });
+            },
+            [ObjectTypes.FigureElement]: (data) => {
+                const model = data;
+                const paragraphIDs = model.containedObjectIDs.filter((i) => i.startsWith('MPParagraphElement'));
+                const figureIDs = model.containedObjectIDs.filter((i) => i.startsWith('MPFigure') || i.startsWith('MPMissingFigure'));
+                const paragraphs = [];
+                paragraphIDs.forEach((id) => {
+                    const paragraphModel = this.getModel(id);
+                    if (paragraphModel) {
+                        return paragraphs.push(this.decode(paragraphModel));
+                    }
+                });
+                const figures = [];
+                figureIDs.forEach((id) => {
+                    const figureModel = this.getModel(id);
+                    if (!figureModel) {
+                        return figures.push(schema.nodes.placeholder.create({
+                            id,
+                            label: 'A figure',
+                        }));
+                    }
+                    return figures.push(this.decode(figureModel));
+                });
+                if (!figures.length) {
+                    figures.push(schema.nodes.figure.createAndFill());
+                }
+                const figcaption = this.getFigcaption(model);
+                const content = [...paragraphs, ...figures, figcaption];
+                const listing = this.extractListing(model);
+                if (listing) {
+                    content.push(listing);
+                }
+                else {
+                    const listing = schema.nodes.listing.create();
+                    content.push(listing);
+                }
+                return schema.nodes.figure_element.createChecked({
+                    id: model._id,
+                    figureLayout: model.figureLayout,
+                    label: model.label,
+                    figureStyle: model.figureStyle,
+                    alignment: model.alignment,
+                    sizeFraction: model.sizeFraction,
+                    suppressCaption: Boolean(model.suppressCaption),
+                    suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
+                    attribution: model.attribution,
+                    alternatives: model.alternatives,
+                    comments: this.createCommentsNode(model),
+                }, content);
+            },
+            [ObjectTypes.Equation]: (data) => {
+                const model = data;
+                return schema.nodes.equation.createChecked({
+                    id: model._id,
+                    MathMLStringRepresentation: model.MathMLStringRepresentation,
+                    SVGStringRepresentation: model.SVGStringRepresentation,
+                    TeXRepresentation: model.TeXRepresentation,
+                });
+            },
+            [ObjectTypes.EquationElement]: (data) => {
+                const model = data;
+                const equationModel = this.getModel(model.containedObjectID);
+                let equation;
+                if (equationModel) {
+                    equation = this.decode(equationModel);
+                }
+                else if (this.allowMissingElements) {
+                    equation = schema.nodes.placeholder.create({
+                        id: model.containedObjectID,
+                        label: 'An equation',
+                    });
+                }
+                else {
+                    throw new MissingElement(model.containedObjectID);
+                }
+                const figcaption = this.getFigcaption(model);
+                return schema.nodes.equation_element.createChecked({
+                    id: model._id,
+                    suppressCaption: Boolean(model.suppressCaption),
+                    suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
+                }, [equation, figcaption]);
+            },
+            [ObjectTypes.FootnotesElement]: (data) => {
+                const model = data;
+                const collateByKind = model.collateByKind || 'footnote';
+                const footnotesOfKind = [];
+                for (const model of this.modelMap.values()) {
+                    if (isFootnote(model) && model.kind === collateByKind) {
+                        const footnote = this.parseContents(model.contents || '<div></div>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.footnote.create({
+                                id: model._id,
+                                kind: model.kind,
+                                comments: this.createCommentsNode(model),
+                            }),
+                        });
+                        footnotesOfKind.push(footnote);
+                    }
+                }
+                return schema.nodes.footnotes_element.create({
+                    id: model._id,
+                    kind: model.collateByKind,
+                    paragraphStyle: model.paragraphStyle,
+                }, footnotesOfKind);
+            },
+            [ObjectTypes.Footnote]: (data) => {
+                const model = data;
+                return schema.nodes.footnote.create({
+                    id: model._id,
+                    kind: model.kind,
+                    comments: this.createCommentsNode(model),
+                });
+            },
+            [ObjectTypes.KeywordsElement]: (data) => {
+                const model = data;
+                return schema.nodes.keywords_element.create({
+                    id: model._id,
+                    contents: model.contents
+                        ? model.contents.replace(/\s+xmlns=".+?"/, '')
+                        : '',
+                    paragraphStyle: model.paragraphStyle,
+                });
+            },
+            [ObjectTypes.ListElement]: (data) => {
+                const model = data;
+                switch (model.elementType) {
+                    case 'ol':
+                        return this.parseContents(model.contents || '<ol></ol>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.ordered_list.create({
+                                id: model._id,
+                                paragraphStyle: model.paragraphStyle,
+                                comments: this.createCommentsNode(model),
+                            }),
+                        });
+                    case 'ul':
+                        return this.parseContents(model.contents || '<ul></ul>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.bullet_list.create({
+                                id: model._id,
+                                paragraphStyle: model.paragraphStyle,
+                            }),
+                        });
+                    default:
+                        throw new Error('Unknown list element type');
+                }
+            },
+            [ObjectTypes.Listing]: (data) => {
+                const model = data;
+                return schema.nodes.listing.createChecked({
+                    id: model._id,
+                    contents: model.contents,
+                    language: model.language,
+                    languageKey: model.languageKey,
+                    comments: this.createCommentsNode(model),
+                });
+            },
+            [ObjectTypes.ListingElement]: (data) => {
+                const model = data;
+                const listingModel = this.getModel(model.containedObjectID);
+                let listing;
+                if (listingModel) {
+                    listing = this.decode(listingModel);
+                }
+                else if (this.allowMissingElements) {
+                    listing = schema.nodes.placeholder.create({
+                        id: model.containedObjectID,
+                        label: 'A listing',
+                    });
+                }
+                else {
+                    throw new MissingElement(model.containedObjectID);
+                }
+                const figcaption = this.getFigcaption(model);
+                return schema.nodes.listing_element.createChecked({
+                    id: model._id,
+                    suppressCaption: model.suppressCaption,
+                    suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
+                    comments: this.createCommentsNode(model),
+                }, [listing, figcaption]);
+            },
+            [ObjectTypes.MissingFigure]: (data) => {
+                const model = data;
+                return schema.nodes.missing_figure.create({
+                    id: model._id,
+                    position: model.position,
+                });
+            },
+            [ObjectTypes.ParagraphElement]: (data) => {
+                const model = data;
+                return this.parseContents(model.contents || '<p></p>', undefined, this.getComments(model), {
+                    topNode: schema.nodes.paragraph.create({
+                        id: model._id,
+                        paragraphStyle: model.paragraphStyle,
+                        placeholder: model.placeholderInnerHTML,
+                        comments: this.createCommentsNode(model),
+                    }),
+                });
+            },
+            [ObjectTypes.QuoteElement]: (data) => {
+                const model = data;
+                switch (model.quoteType) {
+                    case 'block':
+                        return this.parseContents(model.contents || '<p></p>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.blockquote_element.create({
+                                id: model._id,
+                                paragraphStyle: model.paragraphStyle,
+                                placeholder: model.placeholderInnerHTML,
+                            }),
+                        });
+                    case 'pull':
+                        return this.parseContents(model.contents || '<p></p>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.pullquote_element.create({
+                                id: model._id,
+                                paragraphStyle: model.paragraphStyle,
+                                placeholder: model.placeholderInnerHTML,
+                            }),
+                        });
+                    default:
+                        throw new Error('Unknown block type');
+                }
+            },
+            [ObjectTypes.Section]: (data) => {
+                const model = data;
+                const isKeywordsSection = model.category === 'MPSectionCategory:keywords';
+                const elements = [];
+                if (model.elementIDs) {
+                    for (const id of model.elementIDs) {
+                        const element = this.getModel(id);
+                        if (element) {
+                            if (isKeywordsSection && isParagraphElement(element)) {
+                                continue;
+                            }
+                            elements.push(element);
+                        }
+                        else if (this.allowMissingElements) {
+                            const placeholderElement = {
+                                _id: id,
+                                containerID: model._id,
+                                elementType: 'p',
+                                objectType: ExtraObjectTypes.PlaceholderElement,
+                                createdAt: timestamp(),
+                                updatedAt: timestamp(),
+                            };
+                            elements.push(placeholderElement);
+                        }
+                        else {
+                            throw new MissingElement(id);
+                        }
+                    }
+                }
+                const elementNodes = elements
+                    .map(this.decode)
+                    .filter(isManuscriptNode);
+                const sectionTitleNode = model.title
+                    ? this.parseContents(model.title, 'h1', this.getComments(model), {
+                        topNode: schema.nodes.section_title.create(),
+                    })
+                    : schema.nodes.section_title.create();
+                let sectionLabelNode = undefined;
+                if (model.label) {
+                    sectionLabelNode = this.parseContents(model.label, 'label', this.getComments(model), {
+                        topNode: schema.nodes.section_label.create(),
+                    });
+                }
+                const nestedSections = getSections(this.modelMap)
+                    .filter(hasParentSection(model._id))
+                    .map(this.creators[ObjectTypes.Section]);
+                const sectionCategory = model.category || guessSectionCategory(elements);
+                const sectionNodeType = chooseSectionNodeType(sectionCategory);
+                const content = (sectionLabelNode
+                    ? [sectionLabelNode, sectionTitleNode]
+                    : [sectionTitleNode])
+                    .concat(elementNodes)
+                    .concat(nestedSections);
+                const sectionNode = sectionNodeType.createAndFill({
+                    id: model._id,
+                    category: sectionCategory,
+                    titleSuppressed: model.titleSuppressed,
+                    pageBreakStyle: model.pageBreakStyle,
+                    generatedLabel: model.generatedLabel,
+                    comments: this.createCommentsNode(model),
+                }, content);
+                if (!sectionNode) {
+                    console.error(model);
+                    throw new Error('Invalid content for section ' + model._id);
+                }
+                return sectionNode;
+            },
+            [ObjectTypes.Table]: (data) => {
+                const model = data;
+                return this.parseContents(model.contents, undefined, this.getComments(model), {
+                    topNode: schema.nodes.table.create({
+                        id: model._id,
+                        comments: this.createCommentsNode(model),
+                    }),
+                });
+            },
+            [ObjectTypes.TableElement]: (data) => {
+                const model = data;
+                const tableModel = this.getModel(model.containedObjectID);
+                let table;
+                if (tableModel) {
+                    table = this.decode(tableModel);
+                }
+                else if (this.allowMissingElements) {
+                    table = schema.nodes.placeholder.create({
+                        id: model.containedObjectID,
+                        label: 'A table',
+                    });
+                }
+                else {
+                    throw new MissingElement(model.containedObjectID);
+                }
+                const figcaption = this.getFigcaption(model);
+                const content = [table, figcaption];
+                if (model.listingID) {
+                    const listingModel = this.getModel(model.listingID);
+                    let listing;
+                    if (listingModel) {
+                        listing = this.decode(listingModel);
+                    }
+                    else if (this.allowMissingElements) {
+                        listing = schema.nodes.placeholder.create({
+                            id: model.listingID,
+                            label: 'A listing',
+                        });
+                    }
+                    else {
+                        throw new MissingElement(model.listingID);
+                    }
+                    content.push(listing);
+                }
+                else {
+                    const listing = schema.nodes.listing.create();
+                    content.push(listing);
+                }
+                return schema.nodes.table_element.createChecked({
+                    id: model._id,
+                    table: model.containedObjectID,
+                    suppressCaption: model.suppressCaption,
+                    suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
+                    suppressFooter: model.suppressFooter,
+                    suppressHeader: model.suppressHeader,
+                    tableStyle: model.tableStyle,
+                    paragraphStyle: model.paragraphStyle,
+                    comments: this.createCommentsNode(model),
+                }, content);
+            },
+            [ObjectTypes.TOCElement]: (data) => {
+                const model = data;
+                return schema.nodes.toc_element.create({
+                    id: model._id,
+                    contents: model.contents
+                        ? model.contents.replace(/\s+xmlns=".+?"/, '')
+                        : '',
+                    paragraphStyle: model.paragraphStyle,
+                });
+            },
+            [ObjectTypes.CommentAnnotation]: (data) => {
+                const model = data;
+                return schema.nodes.comment.create({
+                    id: model._id,
+                    contents: model.contents,
+                    selector: model.selector,
+                    target: model.target,
+                });
+            },
+        };
+        this.decode = (model) => {
+            if (!this.creators[model.objectType]) {
+                warn(`No converter for ${model.objectType}`);
+                return null;
+            }
+            return this.creators[model.objectType](model);
+        };
+        this.getModel = (id) => this.modelMap.get(id);
+        this.createArticleNode = (manuscriptID) => {
+            let rootSections = getSections(this.modelMap).filter((section) => !section.path || section.path.length <= 1);
+            rootSections = this.addGeneratedLabels(rootSections);
+            const rootSectionNodes = rootSections
+                .map(this.decode)
+                .filter(isManuscriptNode);
+            if (!rootSectionNodes.length) {
+                rootSectionNodes.push(schema.nodes.section.createAndFill({
+                    id: generateNodeID(schema.nodes.section),
+                }));
+            }
+            return schema.nodes.manuscript.create({
+                id: manuscriptID || this.getManuscriptID(),
+            }, rootSectionNodes);
+        };
+        this.addGeneratedLabels = (sections) => {
+            const nextLableCount = { Appendix: 1 };
+            return sections.map((section) => {
+                if (section.generatedLabel) {
+                    const secType = section.category
+                        ? chooseSecType(section.category)
+                        : undefined;
+                    if (secType === 'appendices') {
+                        section.label = `${chooseSectionLableName(secType)} ${nextLableCount['Appendix']}`;
+                        nextLableCount['Appendix'] += 1;
+                    }
+                    else {
+                        delete section.label;
+                    }
+                }
+                return section;
+            });
+        };
+        this.parseContents = (contents, wrapper, commentAnnotations = [], options) => {
+            const contentsWithComments = commentAnnotations.length
+                ? insertHighlightMarkers(contents, commentAnnotations)
+                : contents;
+            const wrappedContents = wrapper
+                ? `<${wrapper}>${contentsWithComments}</${wrapper}>`
+                : contentsWithComments;
+            const html = wrappedContents.trim();
+            if (!html.length) {
+                throw new Error('No HTML to parse');
+            }
+            const template = document.createElement('template');
+            template.innerHTML = html;
+            if (!template.content.firstChild) {
+                throw new Error('No content could be parsed');
+            }
+            return parser.parse(template.content.firstChild, options);
+        };
+        this.getManuscriptID = () => {
+            for (const item of this.modelMap.values()) {
+                if (isManuscript(item)) {
+                    return item._id;
+                }
+            }
+        };
+        this.getFigcaption = (model) => {
+            const titleNode = schema.nodes.caption_title.create();
+            const captionTitle = model.title
+                ? this.parseContents(model.title, 'caption_title', this.getComments(model), {
+                    topNode: titleNode,
+                })
+                : titleNode;
+            if (model.caption && /<\/?[a-z][\s\S]*>/i.test(model.caption)) {
+                const captionDoc = document.createElement('div');
+                captionDoc.innerHTML = model.caption;
+                const content = [captionTitle];
+                const paragraphs = captionDoc.querySelectorAll('p');
+                for (const paragraph of paragraphs) {
+                    const captionNode = schema.nodes.caption.create();
+                    const caption = this.parseContents(paragraph.outerHTML, 'caption', this.getComments(model), {
+                        topNode: captionNode,
+                    });
+                    content.push(caption);
+                }
+                return schema.nodes.figcaption.create({}, content);
+            }
+            const captionNode = schema.nodes.caption.create();
+            const caption = model.caption
+                ? this.parseContents(model.caption, 'caption', this.getComments(model), {
+                    topNode: captionNode,
+                })
+                : captionNode;
+            return schema.nodes.figcaption.create({}, [captionTitle, caption]);
+        };
+        this.modelMap = modelMap;
+        this.allowMissingElements = allowMissingElements;
+    }
+}

package/dist/es/transformer/document-object-types.js

@@ -0,0 +1,28 @@
+/*!
+ * © 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';
+export const documentObjectTypes = [
+    ObjectTypes.BibliographyElement,
+    ObjectTypes.EquationElement,
+    ObjectTypes.FigureElement,
+    ObjectTypes.ListElement,
+    ObjectTypes.ListingElement,
+    ObjectTypes.Manuscript,
+    ObjectTypes.ParagraphElement,
+    ObjectTypes.Section,
+    ObjectTypes.TableElement,
+    ObjectTypes.TOCElement,
+];