@manuscripts/transform 2.3.38-LEAN-3911.0 → 2.4.0

package/dist/es/transformer/decode.js

@@ -0,0 +1,888 @@
+/*!
+ * © 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/json-schema';
+import debug from 'debug';
+import { DOMParser } from 'prosemirror-model';
+import { MissingElement } from '../errors';
+import { abstractsType, backmatterType, bodyType, } from '../lib/section-group-type';
+import { schema, } from '../schema';
+import { buildTitles } from './builders';
+import { insertHighlightMarkers } from './highlight-markers';
+import { generateID } from './id';
+import { ExtraObjectTypes, isCommentAnnotation, isManuscript, } from './object-types';
+import { chooseSectionLableName, chooseSectionNodeType, chooseSecType, getSectionGroupType, guessSectionCategory, } from './section-category';
+import { timestamp } from './timestamp';
+const warn = debug('manuscripts-transform');
+const parser = DOMParser.fromSchema(schema);
+export const getModelData = (model) => {
+    const { updatedAt, createdAt } = model, data = __rest(model, ["updatedAt", "createdAt"]);
+    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);
+const getAffiliations = (modelMap) => getModelsByType(modelMap, ObjectTypes.Affiliation);
+const getContributors = (modelMap) => getModelsByType(modelMap, ObjectTypes.Contributor);
+const getAuthorNotes = (modelMap) => getModelsByType(modelMap, ObjectTypes.AuthorNotes);
+const getKeywordElements = (modelMap) => getModelsByType(modelMap, ObjectTypes.KeywordsElement);
+const getSupplements = (modelMap) => getModelsByType(modelMap, ObjectTypes.Supplement);
+const getKeywordGroups = (modelMap) => getModelsByType(modelMap, ObjectTypes.KeywordGroup);
+const getKeywords = (modelMap) => getModelsByType(modelMap, ObjectTypes.Keyword);
+const getTitles = (modelMap) => getModelsByType(modelMap, ObjectTypes.Titles)[0];
+const hasParentSection = (id) => (section) => section.path &&
+    section.path.length > 1 &&
+    section.path[section.path.length - 2] === id;
+const deprecatedCategories = [
+    'MPSectionCategory:contributors',
+    'MPSectionCategory:affiliations',
+    'MPSectionCategory:keywords',
+];
+export class Decoder {
+    createTitleNode() {
+        const titles = getTitles(this.modelMap) || buildTitles();
+        return this.decode(titles);
+    }
+    createAffiliationsNode() {
+        const affiliations = getAffiliations(this.modelMap)
+            .map((a) => this.decode(a))
+            .filter(Boolean);
+        if (!affiliations.length) {
+            return false;
+        }
+        return schema.nodes.affiliations.createAndFill({}, affiliations);
+    }
+    createContributorsNode() {
+        const contributors = getContributors(this.modelMap)
+            .map((c) => this.decode(c))
+            .filter(Boolean);
+        const content = [...contributors];
+        if (!content.length) {
+            return false;
+        }
+        return schema.nodes.contributors.createAndFill({}, content);
+    }
+    createAuthorNotesNode() {
+        return getAuthorNotes(this.modelMap)
+            .map((authorNote) => this.decode(authorNote))
+            .filter(Boolean);
+    }
+    createKeywordsNode() {
+        const elements = getKeywordElements(this.modelMap)
+            .map((e) => this.decode(e))
+            .filter(Boolean);
+        if (!elements.length) {
+            return false;
+        }
+        return schema.nodes.keywords.createAndFill({}, [
+            schema.nodes.section_title.create({}, schema.text('Keywords')),
+            ...elements,
+        ]);
+    }
+    createSupplementsNode() {
+        const elements = getSupplements(this.modelMap)
+            .map((e) => this.decode(e))
+            .filter(Boolean);
+        if (!elements.length) {
+            return false;
+        }
+        return schema.nodes.supplements.createAndFill({}, [
+            schema.nodes.section_title.create({}, schema.text('SupplementaryMaterials')),
+            ...elements,
+        ]);
+    }
+    createCommentsNode() {
+        return schema.nodes.comments.createAndFill({}, [
+            ...this.comments.values(),
+        ]);
+    }
+    createContentSections() {
+        let sections = getSections(this.modelMap);
+        sections = this.addGeneratedLabels(sections);
+        const groups = {
+            abstracts: [],
+            body: [],
+            backmatter: [],
+        };
+        for (const section of sections) {
+            if (section.path.length > 1) {
+                continue;
+            }
+            const category = section.category;
+            if (category && deprecatedCategories.includes(category)) {
+                continue;
+            }
+            const group = category ? getSectionGroupType(category) : bodyType;
+            groups[group._id].push(this.decode(section));
+        }
+        const abstracts = schema.nodes.abstracts.createAndFill({}, groups[abstractsType._id]);
+        const body = schema.nodes.body.createAndFill({}, groups[bodyType._id]);
+        const backmatter = schema.nodes.backmatter.createAndFill({}, groups[backmatterType._id]);
+        return [abstracts, body, backmatter];
+    }
+    createCommentNodes(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) {
+            return this.createListing(model.listingID);
+        }
+    }
+    constructor(modelMap, allowMissingElements = false) {
+        this.comments = new Map();
+        this.creators = {
+            [ObjectTypes.Titles]: (data) => {
+                const model = data;
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return this.parseContents(model.title, 'div', this.getComments(model), {
+                    topNode: schema.nodes.title.create({
+                        id: model._id,
+                    }),
+                });
+            },
+            [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));
+                    }
+                });
+                return schema.nodes.bibliography_element.createChecked({
+                    id: model._id,
+                    contents: '',
+                    paragraphStyle: model.paragraphStyle,
+                }, references);
+            },
+            [ObjectTypes.BibliographyItem]: (data) => {
+                const model = data;
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                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;
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return schema.nodes.figure.create({
+                    id: model._id,
+                    contentType: model.contentType,
+                    src: model.src,
+                    position: model.position,
+                });
+            },
+            [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 comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                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,
+                }, content);
+            },
+            [ObjectTypes.Equation]: (data) => {
+                const model = data;
+                return schema.nodes.equation.createChecked({
+                    id: model._id,
+                    contents: model.contents,
+                    format: model.format,
+                });
+            },
+            [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);
+                }
+                return schema.nodes.equation_element.createChecked({
+                    id: model._id,
+                    label: model.label,
+                }, [equation]);
+            },
+            [ObjectTypes.FootnotesElement]: (data) => {
+                const foonotesElementModel = data;
+                const footnotesOfKind = [];
+                const footnoteOrder = getModelsByType(this.modelMap, ObjectTypes.FootnotesOrder).find((model) => model.containedObjectID === data._id);
+                if (footnoteOrder) {
+                    footnoteOrder.footnotesList.map(({ id }) => {
+                        const model = this.modelMap.get(id);
+                        const collateByKind = foonotesElementModel.collateByKind || 'footnote';
+                        if (model.kind === collateByKind) {
+                            const comments = this.createCommentNodes(model);
+                            comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                            const footnote = this.parseContents(model.contents || '<div></div>', undefined, this.getComments(model), {
+                                topNode: schema.nodes.footnote.create({
+                                    id: model._id,
+                                    kind: model.kind,
+                                }),
+                            });
+                            footnotesOfKind.push(footnote);
+                        }
+                    });
+                }
+                return schema.nodes.footnotes_element.create({
+                    id: foonotesElementModel._id,
+                    kind: foonotesElementModel.collateByKind,
+                    paragraphStyle: foonotesElementModel.paragraphStyle,
+                }, footnotesOfKind);
+            },
+            [ObjectTypes.Footnote]: (data) => {
+                const footnoteModel = data;
+                const comments = this.createCommentNodes(footnoteModel);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return this.parseContents(footnoteModel.contents || '<div></div>', undefined, this.getComments(footnoteModel), {
+                    topNode: schema.nodes.footnote.create({
+                        id: footnoteModel._id,
+                        kind: footnoteModel.kind,
+                    }),
+                });
+            },
+            [ObjectTypes.KeywordsElement]: (data) => {
+                const model = data;
+                const keywordGroups = getKeywordGroups(this.modelMap).map((k) => this.decode(k));
+                return schema.nodes.keywords_element.create({
+                    id: model._id,
+                    paragraphStyle: model.paragraphStyle,
+                }, keywordGroups);
+            },
+            [ObjectTypes.KeywordGroup]: (data) => {
+                const keywordGroup = data;
+                const keywords = getKeywords(this.modelMap)
+                    .filter((k) => k.containedGroup === keywordGroup._id)
+                    .map((k) => this.decode(k));
+                const comments = this.createCommentNodes(keywordGroup);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return schema.nodes.keyword_group.create({
+                    id: keywordGroup._id,
+                    type: keywordGroup.type,
+                }, keywords);
+            },
+            [ObjectTypes.Keyword]: (data) => {
+                const keyword = data;
+                const comments = this.createCommentNodes(keyword);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return schema.nodes.keyword.create({
+                    id: keyword._id,
+                    contents: keyword.name,
+                }, schema.text(keyword.name));
+            },
+            [ObjectTypes.ListElement]: (data) => {
+                const model = data;
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                switch (model.elementType) {
+                    case 'ol':
+                        return this.parseContents(model.contents || '<ol></ol>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.list.create({
+                                id: model._id,
+                                listStyleType: model.listStyleType || 'order',
+                                paragraphStyle: model.paragraphStyle,
+                            }),
+                        });
+                    case 'ul':
+                        return this.parseContents(model.contents || '<ul></ul>', undefined, this.getComments(model), {
+                            topNode: schema.nodes.list.create({
+                                id: model._id,
+                                listStyleType: model.listStyleType || 'bullet',
+                                paragraphStyle: model.paragraphStyle,
+                            }),
+                        });
+                    default:
+                        throw new Error('Unknown list element type');
+                }
+            },
+            [ObjectTypes.Listing]: (data) => {
+                const model = data;
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return schema.nodes.listing.createChecked({
+                    id: model._id,
+                    contents: model.contents,
+                    language: model.language,
+                    languageKey: model.languageKey,
+                });
+            },
+            [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);
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                return schema.nodes.listing_element.createChecked({
+                    id: model._id,
+                    suppressCaption: model.suppressCaption,
+                    suppressTitle: Boolean(model.suppressTitle === undefined ? true : model.suppressTitle),
+                }, [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;
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                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,
+                    }),
+                });
+            },
+            [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.TableElementFooter]: (data) => {
+                const model = data;
+                const contents = [];
+                const generalTableFootnotes = [];
+                const footnotesElements = [];
+                for (const containedObjectID of model.containedObjectIDs) {
+                    const model = this.modelMap.get(containedObjectID);
+                    if (model.objectType === ObjectTypes.ParagraphElement) {
+                        const paragraph = this.decode(model);
+                        if (paragraph) {
+                            generalTableFootnotes.push(paragraph);
+                        }
+                    }
+                    else {
+                        footnotesElements.push(this.decode(model));
+                    }
+                }
+                if (generalTableFootnotes && generalTableFootnotes.length) {
+                    contents.push(schema.nodes.general_table_footnote.create({ id: generateID(ExtraObjectTypes.GeneralTableFootnote) }, [...generalTableFootnotes]));
+                }
+                if (footnotesElements && footnotesElements.length) {
+                    contents.push(...footnotesElements);
+                }
+                return schema.nodes.table_element_footer.create({
+                    id: model._id,
+                }, contents);
+            },
+            [ObjectTypes.AuthorNotes]: (data) => {
+                const model = data;
+                const content = model.containedObjectIDs.map((id) => this.decode(this.modelMap.get(id)));
+                if (content.length == 0) {
+                    return null;
+                }
+                return schema.nodes.author_notes.createAndFill({
+                    id: model._id,
+                }, [...content]);
+            },
+            [ObjectTypes.Corresponding]: (data) => {
+                const model = data;
+                return this.parseContents(model.contents, 'corresp', [], {
+                    topNode: schema.nodes.corresp.create({
+                        id: model._id,
+                        label: model.label,
+                    }),
+                });
+            },
+            [ObjectTypes.Section]: (data) => {
+                const model = data;
+                const elements = [];
+                if (model.elementIDs) {
+                    for (const id of model.elementIDs) {
+                        const element = this.getModel(id);
+                        if (element) {
+                            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((e) => this.decode(e));
+                const sectionTitle = 'section_title';
+                const sectionTitleNode = model.title
+                    ? this.parseContents(model.title, 'h1', this.getComments(model), {
+                        topNode: schema.nodes[sectionTitle].create(),
+                    })
+                    : schema.nodes[sectionTitle].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))
+                    .filter((s) => s.category !== 'MPSectionCategory:box-element')
+                    .map(this.creators[ObjectTypes.Section]);
+                const sectionCategory = model.category || guessSectionCategory(elements);
+                const sectionNodeType = chooseSectionNodeType(sectionCategory);
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                let content = [];
+                if (sectionLabelNode &&
+                    model.category !== 'MPSectionCategory:box-element') {
+                    content.push(sectionLabelNode);
+                }
+                const attrs = {
+                    id: model._id,
+                    category: sectionCategory,
+                    titleSuppressed: model.titleSuppressed,
+                    pageBreakStyle: model.pageBreakStyle,
+                    generatedLabel: model.generatedLabel,
+                };
+                if (model.category === 'MPSectionCategory:box-element') {
+                    const figCaption = this.getBoxElementFigCaption(model);
+                    if (figCaption) {
+                        content.push(figCaption);
+                    }
+                    if (model.label) {
+                        attrs.label = model.label;
+                    }
+                }
+                else {
+                    content.push(sectionTitleNode);
+                }
+                content = content.concat(elementNodes).concat(nestedSections);
+                const sectionNode = sectionNodeType.createAndFill(attrs, 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, [], {
+                    topNode: schema.nodes.table.create({
+                        id: model._id,
+                    }),
+                });
+            },
+            [ObjectTypes.TableElement]: (data) => {
+                const model = data;
+                const table = this.createTable(model);
+                const tableColGroup = this.createTableColGroup(model);
+                const tableElementFooter = this.createTableElementFooter(model);
+                const figcaption = this.getFigcaption(model);
+                const comments = this.createCommentNodes(model);
+                comments.forEach((c) => this.comments.set(c.attrs.id, c));
+                const content = [figcaption, table];
+                if (tableColGroup) {
+                    content.push(tableColGroup);
+                }
+                if (tableElementFooter) {
+                    content.push(tableElementFooter);
+                }
+                const listing = model.listingID
+                    ? this.createListing(model.listingID)
+                    : 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,
+                }, 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,
+                    resolved: model.resolved,
+                    contributions: model.contributions,
+                    originalText: model.originalText,
+                });
+            },
+            [ObjectTypes.Affiliation]: (data) => {
+                const model = data;
+                return schema.nodes.affiliation.create({
+                    id: model._id,
+                    institution: model.institution,
+                    addressLine1: model.addressLine1,
+                    addressLine2: model.addressLine2,
+                    addressLine3: model.addressLine3,
+                    postCode: model.postCode,
+                    country: model.country,
+                    county: model.county,
+                    city: model.city,
+                    email: model.email,
+                    department: model.department,
+                    priority: model.priority,
+                }, schema.text('_'));
+            },
+            [ObjectTypes.Contributor]: (data) => {
+                const model = data;
+                return schema.nodes.contributor.create({
+                    id: model._id,
+                    role: model.role,
+                    affiliations: model.affiliations,
+                    email: model.email,
+                    isJointContributor: model.isJointContributor,
+                    bibliographicName: model.bibliographicName,
+                    userID: model.userID,
+                    invitationID: model.invitationID,
+                    isCorresponding: model.isCorresponding,
+                    ORCIDIdentifier: model.ORCIDIdentifier,
+                    footnote: model.footnote,
+                    corresp: model.corresp,
+                    priority: model.priority,
+                }, schema.text('_'));
+            },
+            [ObjectTypes.Supplement]: (data) => {
+                var _a, _b;
+                const model = data;
+                return schema.nodes.supplement.create({
+                    id: model._id,
+                    href: model.href,
+                    mimeType: (_a = model.MIME) === null || _a === void 0 ? void 0 : _a.split('/')[0],
+                    mimeSubType: (_b = model.MIME) === null || _b === void 0 ? void 0 : _b.split('/')[1],
+                    title: model.title,
+                });
+            },
+        };
+        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) => {
+            const nodes = [
+                this.createTitleNode(),
+                this.createContributorsNode(),
+                this.createAffiliationsNode(),
+                ...this.createAuthorNotesNode(),
+                this.createKeywordsNode(),
+                this.createSupplementsNode(),
+                ...this.createContentSections(),
+                this.createCommentsNode(),
+            ];
+            const contents = nodes.filter((node) => node !== false);
+            const props = this.getManuscript();
+            return schema.nodes.manuscript.create({
+                id: manuscriptID || this.getManuscriptID(),
+                doi: (props === null || props === void 0 ? void 0 : props.DOI) || '',
+                articleType: props === null || props === void 0 ? void 0 : props.articleType,
+                prototype: props === null || props === void 0 ? void 0 : props.prototype,
+                primaryLanguageCode: props === null || props === void 0 ? void 0 : props.primaryLanguageCode,
+            }, contents);
+        };
+        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.firstElementChild) {
+                throw new Error('No content could be parsed');
+            }
+            return parser.parse(template.content.firstElementChild, options);
+        };
+        this.getManuscriptID = () => {
+            for (const item of this.modelMap.values()) {
+                if (isManuscript(item)) {
+                    return item._id;
+                }
+            }
+        };
+        this.getManuscript = () => {
+            for (const item of this.modelMap.values()) {
+                if (isManuscript(item)) {
+                    return item;
+                }
+            }
+        };
+        this.getBoxElementFigCaption = (model) => {
+            const titleNode = schema.nodes.caption_title.create();
+            const captionTitle = model.title
+                ? this.parseContents(model.title, 'caption_title', this.getComments(model), {
+                    topNode: titleNode,
+                })
+                : titleNode;
+            return schema.nodes.figcaption.create({}, captionTitle);
+        };
+        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;
+    }
+    createTable(model) {
+        const tableID = model.containedObjectID;
+        const tableModel = this.getModel(tableID);
+        let table;
+        if (tableModel) {
+            table = this.decode(tableModel);
+        }
+        else if (this.allowMissingElements) {
+            table = schema.nodes.placeholder.create({
+                id: tableID,
+                label: 'A table',
+            });
+        }
+        else {
+            throw new MissingElement(tableID);
+        }
+        return table;
+    }
+    createTableColGroup(model) {
+        const tableID = model.containedObjectID;
+        const tableModel = this.getModel(tableID);
+        if (!tableModel || !tableModel.contents.includes('<colgroup>')) {
+            return undefined;
+        }
+        return this.parseContents(tableModel.contents, undefined, [], {
+            topNode: schema.nodes.table_colgroup.create(),
+        });
+    }
+    createTableElementFooter(model) {
+        const tableElementFooterID = model.tableElementFooterID;
+        if (!tableElementFooterID) {
+            return undefined;
+        }
+        const tableElementFooterModel = this.getModel(tableElementFooterID);
+        return tableElementFooterModel
+            ? this.decode(tableElementFooterModel)
+            : undefined;
+    }
+    createListing(id) {
+        const listing = this.getModel(id);
+        if (listing) {
+            return this.decode(listing);
+        }
+        else if (this.allowMissingElements) {
+            return schema.nodes.placeholder.create({
+                id,
+                label: 'A listing',
+            });
+        }
+        else {
+            throw new MissingElement(id);
+        }
+    }
+}