@manuscripts/transform 2.3.38-LEAN-3911.0 → 2.4.0

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

@@ -0,0 +1,31 @@
+"use strict";
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentObjectTypes = void 0;
+const json_schema_1 = require("@manuscripts/json-schema");
+exports.documentObjectTypes = [
+    json_schema_1.ObjectTypes.BibliographyElement,
+    json_schema_1.ObjectTypes.EquationElement,
+    json_schema_1.ObjectTypes.FigureElement,
+    json_schema_1.ObjectTypes.ListElement,
+    json_schema_1.ObjectTypes.ListingElement,
+    json_schema_1.ObjectTypes.Manuscript,
+    json_schema_1.ObjectTypes.ParagraphElement,
+    json_schema_1.ObjectTypes.Section,
+    json_schema_1.ObjectTypes.TableElement,
+    json_schema_1.ObjectTypes.TOCElement,
+];

package/dist/cjs/transformer/encode.js

@@ -0,0 +1,674 @@
+"use strict";
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.modelFromNode = exports.inlineText = exports.inlineContents = void 0;
+const prosemirror_model_1 = require("prosemirror-model");
+const w3c_xmlserializer_1 = __importDefault(require("w3c-xmlserializer"));
+const utils_1 = require("../lib/utils");
+const schema_1 = require("../schema");
+const builders_1 = require("./builders");
+const highlight_markers_1 = require("./highlight-markers");
+const node_types_1 = require("./node-types");
+const section_category_1 = require("./section-category");
+const serializer = prosemirror_model_1.DOMSerializer.fromSchema(schema_1.schema);
+const contents = (node) => {
+    const output = serializer.serializeNode(node);
+    return (0, w3c_xmlserializer_1.default)(output);
+};
+const footnoteContents = (node) => {
+    const output = serializer.serializeNode(node);
+    output.querySelectorAll('p').forEach((element) => {
+        element.removeAttribute('class');
+        element.removeAttribute('data-object-type');
+    });
+    return (0, w3c_xmlserializer_1.default)(output);
+};
+const keywordContents = (node) => {
+    const text = serializer.serializeNode(node).textContent;
+    return text === null ? '' : text;
+};
+const inlineContents = (node) => serializer.serializeNode(node).innerHTML;
+exports.inlineContents = inlineContents;
+const inlineText = (node) => {
+    const text = serializer.serializeNode(node).textContent;
+    return text === null ? '' : text;
+};
+exports.inlineText = inlineText;
+const listContents = (node) => {
+    const output = serializer.serializeNode(node);
+    for (const p of output.querySelectorAll('li > p')) {
+        const parent = p.parentNode;
+        while (p.firstChild) {
+            parent.insertBefore(p.firstChild, p);
+        }
+        parent.removeChild(p);
+    }
+    return (0, w3c_xmlserializer_1.default)(output);
+};
+const tableRowDisplayStyle = (tagName, parent) => {
+    switch (tagName) {
+        case 'thead':
+            return parent.attrs.suppressHeader ? 'none' : 'table-header-group';
+        case 'tfoot':
+            return parent.attrs.suppressFooter ? 'none' : 'table-footer-group';
+        default:
+            return null;
+    }
+};
+const buildTableSection = (tagName, inputRows, parent) => {
+    const section = document.createElement(tagName);
+    for (const sectionRow of inputRows) {
+        const row = section.appendChild(document.createElement('tr'));
+        for (const child of sectionRow.children) {
+            const cellType = tagName === 'thead' ? 'th' : 'td';
+            const cell = row.appendChild(document.createElement(cellType));
+            while (child.firstChild) {
+                cell.appendChild(child.firstChild);
+            }
+            for (const attribute of child.attributes) {
+                cell.setAttribute(attribute.name, attribute.value);
+            }
+        }
+    }
+    const displayStyle = tableRowDisplayStyle(tagName, parent);
+    if (displayStyle) {
+        section.style.display = displayStyle;
+    }
+    return section;
+};
+function buildTableColGroup(cols) {
+    if (cols.length === 0) {
+        return undefined;
+    }
+    const colgroup = document.createElement('colgroup');
+    for (const inputCol of cols) {
+        const col = document.createElement('col');
+        for (const attribute of inputCol.attributes) {
+            col.setAttribute(attribute.name, attribute.value);
+        }
+        colgroup.appendChild(inputCol);
+    }
+    return colgroup;
+}
+const tableContents = (node, parent) => {
+    const input = serializer.serializeNode(node);
+    const parentInput = serializer.serializeNode(parent);
+    const output = document.createElement('table');
+    const colgroup = buildTableColGroup(Array.from(parentInput.querySelectorAll('col')));
+    if (colgroup) {
+        output.appendChild(colgroup);
+    }
+    output.setAttribute('id', parent.attrs.id);
+    output.classList.add('MPElement');
+    if (parent.attrs.tableStyle) {
+        output.classList.add(parent.attrs.tableStyle.replace(/:/g, '_'));
+    }
+    if (parent.attrs.paragraphStyle) {
+        output.classList.add(parent.attrs.paragraphStyle.replace(/:/g, '_'));
+    }
+    output.setAttribute('data-contained-object-id', node.attrs.id);
+    const rows = Array.from(input.querySelectorAll('tr'));
+    let headerCount = 0;
+    for (const row of rows) {
+        const th = row.querySelector('th[scope="col"], th[scope="colgroup"]');
+        th && headerCount++;
+    }
+    const thead = rows.splice(0, headerCount || 1);
+    const tfoot = rows.splice(-1, 1);
+    output.appendChild(buildTableSection('thead', thead, parent));
+    output.appendChild(buildTableSection('tbody', rows, parent));
+    output.appendChild(buildTableSection('tfoot', tfoot, parent));
+    return (0, w3c_xmlserializer_1.default)(output);
+};
+const elementContents = (node) => {
+    const input = serializer.serializeNode(node);
+    input.classList.add('MPElement');
+    if (node.attrs.paragraphStyle) {
+        input.classList.add(node.attrs.paragraphStyle.replace(/:/g, '_'));
+    }
+    if (node.attrs.id) {
+        input.setAttribute('id', node.attrs.id);
+    }
+    return (0, w3c_xmlserializer_1.default)(input);
+};
+const childElements = (node) => {
+    const nodes = [];
+    node.forEach((childNode) => {
+        if (!(0, schema_1.isSectionNode)(childNode)) {
+            nodes.push(childNode);
+        }
+    });
+    return nodes;
+};
+const sectionChildElementIds = (node) => {
+    const nodes = [];
+    node.forEach((childNode) => {
+        if (!(0, schema_1.hasGroup)(childNode.type, 'sections')) {
+            nodes.push(childNode);
+        }
+    });
+    return nodes.map((childNode) => childNode.attrs.id).filter((id) => id);
+};
+const attributeOfNodeType = (node, type, attribute) => {
+    for (const child of (0, utils_1.iterateChildren)(node)) {
+        if (child.type.name === type) {
+            return child.attrs[attribute];
+        }
+    }
+    return '';
+};
+const inlineContentsOfNodeType = (node, nodeType) => {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child.type === nodeType) {
+            return (0, exports.inlineContents)(child);
+        }
+    }
+    return '';
+};
+const inlineContentOfChildNodeType = (node, parentNodeType, childNodeType, empty = true) => {
+    const parentNode = childElements(node).find((node) => node.type === parentNodeType && node);
+    const content = parentNode && inlineContentsOfNodeType(parentNode, childNodeType);
+    return content && content.length > 1 ? content : empty ? content : undefined;
+};
+const wrappedContentOfChildrenNodeType = (node, parentNodeType, childNodeType) => {
+    const parentNode = childElements(node).find((node) => node.type === parentNodeType && node);
+    const content = parentNode &&
+        childElements(parentNode)
+            .filter((node) => node.type === childNodeType && node)
+            .map((node) => serializer.serializeNode(node).outerHTML)
+            .join('');
+    return content;
+};
+const containedFigureIDs = (node) => {
+    const figureNodeType = node.type.schema.nodes.figure;
+    const missingFigureNodeType = node.type.schema.nodes.missing_figure;
+    return containedObjectIDs(node, [figureNodeType, missingFigureNodeType]);
+};
+const containedParagraphIDs = (node) => {
+    const paragraphNodeType = node.type.schema.nodes.paragraph;
+    return containedObjectIDs(node, [paragraphNodeType]);
+};
+const containedAuthorNotesIDs = (node) => {
+    const correspNodeType = node.type.schema.nodes.corresp;
+    const footnoteNodetype = node.type.schema.nodes.footnote;
+    const paragraphNodeType = node.type.schema.nodes.paragraph;
+    return containedObjectIDs(node, [
+        correspNodeType,
+        footnoteNodetype,
+        paragraphNodeType,
+    ]);
+};
+const containedBibliographyItemIDs = (node) => {
+    const bibliographyItemNodeType = node.type.schema.nodes.bibliography_item;
+    return containedObjectIDs(node, [bibliographyItemNodeType]);
+};
+const tableElementFooterContainedIDs = (node) => {
+    const containedGeneralTableFootnoteIDs = containedObjectIDs(node, [
+        schema_1.schema.nodes.footnotes_element,
+    ]);
+    for (let i = 0; i < node.childCount; i++) {
+        const childNode = node.child(i);
+        if (childNode.type === schema_1.schema.nodes.general_table_footnote) {
+            containedGeneralTableFootnoteIDs.push(...containedObjectIDs(childNode));
+        }
+    }
+    return containedGeneralTableFootnoteIDs;
+};
+const containedObjectIDs = (node, nodeTypes) => {
+    const ids = [];
+    for (let i = 0; i < node.childCount; i++) {
+        const childNode = node.child(i);
+        if (!nodeTypes || nodeTypes.includes(childNode.type)) {
+            ids.push(childNode.attrs.id);
+        }
+    }
+    return ids;
+};
+const attribution = (node) => {
+    if (node.attrs.attribution) {
+        return Object.assign(Object.assign({}, node.attrs.attribution), (0, builders_1.buildAttribution)());
+    }
+    return undefined;
+};
+const fromJson = (json) => {
+    let obj;
+    try {
+        obj = JSON.parse(json);
+    }
+    catch (e) {
+    }
+    return obj;
+};
+function figureElementEncoder(node) {
+    var _a;
+    return {
+        containedObjectIDs: (_a = containedParagraphIDs(node)) === null || _a === void 0 ? void 0 : _a.concat(containedFigureIDs(node)),
+        caption: wrappedContentOfChildrenNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        label: node.attrs.label,
+        elementType: 'figure',
+        attribution: attribution(node),
+        alternatives: node.attrs.alternatives,
+        listingID: attributeOfNodeType(node, 'listing', 'id') || undefined,
+        alignment: node.attrs.alignment || undefined,
+        sizeFraction: node.attrs.sizeFraction || undefined,
+        suppressCaption: Boolean(node.attrs.suppressCaption) || undefined,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+        figureStyle: node.attrs.figureStyle || undefined,
+        figureLayout: node.attrs.figureLayout || undefined,
+    };
+}
+const encoders = {
+    title: (node) => ({
+        title: (0, exports.inlineContents)(node),
+        subtitle: node.attrs.subtitle,
+        runningTitle: node.attrs.runningTitle,
+        placeholder: node.attrs.placeholder,
+        _id: node.attrs._id,
+    }),
+    bibliography_element: (node) => ({
+        elementType: 'div',
+        contents: '',
+        containedObjectIDs: containedBibliographyItemIDs(node),
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    bibliography_item: (node) => {
+        const { type, containerTitle, doi, volume, issue, supplement, page, title, literal, } = node.attrs;
+        const getObjectAtrr = (obj) => typeof obj === 'string' ? fromJson(obj) : obj;
+        const author = getObjectAtrr(node.attrs.author);
+        const issued = getObjectAtrr(node.attrs.issued);
+        const ref = {
+            type,
+        };
+        if (author) {
+            ref.author = author;
+        }
+        if (issued) {
+            ref.issued = issued;
+        }
+        if (containerTitle) {
+            ref['container-title'] = containerTitle;
+        }
+        if (doi) {
+            ref.DOI = doi;
+        }
+        if (volume) {
+            ref.volume = volume;
+        }
+        if (issue) {
+            ref.issue = issue;
+        }
+        if (supplement) {
+            ref.supplement = supplement;
+        }
+        if (page) {
+            ref.page = page;
+        }
+        if (title) {
+            ref.title = title;
+        }
+        if (literal) {
+            ref.literal = literal;
+        }
+        return ref;
+    },
+    bibliography_section: (node, parent, path, priority) => ({
+        category: (0, section_category_1.buildSectionCategory)(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    blockquote_element: (node) => ({
+        contents: contents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        placeholderInnerHTML: node.attrs.placeholder || '',
+        quoteType: 'block',
+    }),
+    list: (node) => ({
+        elementType: (0, schema_1.getListType)(node.attrs.listStyleType).type,
+        contents: listContents(node),
+        listStyleType: node.attrs.listStyleType,
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    listing: (node) => ({
+        contents: (0, exports.inlineText)(node),
+        language: node.attrs.language || undefined,
+        languageKey: node.attrs.languageKey || 'null',
+    }),
+    listing_element: (node) => ({
+        containedObjectID: attributeOfNodeType(node, 'listing', 'id'),
+        caption: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        elementType: 'figure',
+        suppressCaption: node.attrs.suppressCaption === true ? undefined : false,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+    }),
+    equation: (node) => ({
+        contents: node.attrs.contents,
+        format: node.attrs.format,
+    }),
+    equation_element: (node) => ({
+        containedObjectID: attributeOfNodeType(node, 'equation', 'id'),
+        elementType: 'div',
+        label: node.attrs.label,
+    }),
+    figure: (node) => ({
+        contentType: node.attrs.contentType || undefined,
+        src: node.attrs.src || undefined,
+        position: node.attrs.position || undefined,
+    }),
+    figure_element: (node) => figureElementEncoder(node),
+    comment: (node) => ({
+        selector: node.attrs.selector,
+        target: node.attrs.target,
+        contents: node.attrs.contents,
+        resolved: node.attrs.resolved,
+        contributions: node.attrs.contributions,
+        originalText: node.attrs.originalText,
+    }),
+    footnote: (node, parent) => ({
+        containingObject: parent.attrs.id,
+        contents: footnoteContents(node),
+        kind: node.attrs.kind || 'footnote',
+    }),
+    footnotes_element: (node) => ({
+        contents: '<div></div>',
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    table_element_footer: (node) => ({
+        containedObjectIDs: tableElementFooterContainedIDs(node),
+    }),
+    author_notes: (node) => ({
+        containedObjectIDs: containedAuthorNotesIDs(node),
+    }),
+    footnotes_section: (node, parent, path, priority) => ({
+        category: (0, section_category_1.buildSectionCategory)(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    graphical_abstract_section: (node, parent, path, priority) => ({
+        category: (0, section_category_1.buildSectionCategory)(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    keyword: (node, parent) => ({
+        containedGroup: parent.attrs.id,
+        name: keywordContents(node),
+    }),
+    keywords_element: (node) => ({
+        contents: '<div></div>',
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    keyword_group: (node) => ({
+        type: node.attrs.type,
+    }),
+    missing_figure: (node) => ({
+        position: node.attrs.position || undefined,
+    }),
+    paragraph: (node) => ({
+        elementType: 'p',
+        contents: contents(node),
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        placeholderInnerHTML: node.attrs.placeholder || '',
+    }),
+    placeholder_element: () => ({
+        elementType: 'p',
+    }),
+    pullquote_element: (node) => ({
+        contents: contents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        placeholderInnerHTML: node.attrs.placeholder || '',
+        quoteType: 'pull',
+    }),
+    section: (node, parent, path, priority) => ({
+        category: (0, section_category_1.buildSectionCategory)(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        label: inlineContentsOfNodeType(node, node.type.schema.nodes.section_label) ||
+            undefined,
+        path: path.concat([node.attrs.id]),
+        elementIDs: sectionChildElementIds(node),
+        titleSuppressed: node.attrs.titleSuppressed || undefined,
+        generatedLabel: node.attrs.generatedLabel || undefined,
+        pageBreakStyle: node.attrs.pageBreakStyle || undefined,
+    }),
+    table: (node, parent) => ({
+        contents: tableContents(node, parent),
+        listingAttachment: node.attrs.listingAttachment || undefined,
+    }),
+    table_element: (node) => ({
+        containedObjectID: attributeOfNodeType(node, 'table', 'id'),
+        tableElementFooterID: attributeOfNodeType(node, 'table_element_footer', 'id') || undefined,
+        caption: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        elementType: 'table',
+        listingID: attributeOfNodeType(node, 'listing', 'id') || undefined,
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+        suppressCaption: Boolean(node.attrs.suppressCaption) || undefined,
+        suppressTitle: node.attrs.suppressTitle === undefined ||
+            node.attrs.suppressTitle === true
+            ? undefined
+            : false,
+        suppressFooter: Boolean(node.attrs.suppressFooter) || undefined,
+        suppressHeader: Boolean(node.attrs.suppressHeader) || undefined,
+        tableStyle: node.attrs.tableStyle || undefined,
+    }),
+    toc_element: (node) => ({
+        contents: elementContents(node),
+        elementType: 'div',
+        paragraphStyle: node.attrs.paragraphStyle || undefined,
+    }),
+    toc_section: (node, parent, path, priority) => ({
+        category: (0, section_category_1.buildSectionCategory)(node),
+        priority: priority.value++,
+        title: inlineContentsOfNodeType(node, node.type.schema.nodes.section_title),
+        path: path.concat([node.attrs.id]),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+    }),
+    affiliation: (node) => ({
+        institution: node.attrs.institution,
+        addressLine1: node.attrs.addressLine1,
+        addressLine2: node.attrs.addressLine2,
+        addressLine3: node.attrs.addressLine3,
+        department: node.attrs.department,
+        postCode: node.attrs.postCode,
+        country: node.attrs.country,
+        county: node.attrs.county,
+        city: node.attrs.city,
+        email: node.attrs.email,
+        priority: node.attrs.priority,
+    }),
+    contributor: (node) => ({
+        role: node.attrs.role,
+        affiliations: node.attrs.affiliations,
+        bibliographicName: node.attrs.bibliographicName,
+        userID: node.attrs.userID,
+        invitationID: node.attrs.invitationID,
+        isCorresponding: node.attrs.isCorresponding,
+        isJointContributor: node.attrs.isJointContributor,
+        ORCIDIdentifier: node.attrs.ORCIDIdentifier,
+        footnote: node.attrs.footnote,
+        corresp: node.attrs.corresp,
+        priority: node.attrs.priority,
+    }),
+    supplement: (node) => ({
+        href: node.attrs.href,
+        title: node.attrs.title,
+        MIME: node.attrs.mimeType && node.attrs.mimeSubType
+            ? [node.attrs.mimeType, node.attrs.mimeSubType].join('/')
+            : '',
+    }),
+    corresp: (node) => ({
+        contents: (0, exports.inlineContents)(node),
+        label: node.attrs.label,
+    }),
+    box_element: (node, parent, path, priority) => ({
+        label: node.attrs.label,
+        priority: priority.value++,
+        path: path.concat([node.attrs.id]),
+        title: inlineContentOfChildNodeType(node, node.type.schema.nodes.figcaption, node.type.schema.nodes.caption_title, false),
+        elementIDs: childElements(node)
+            .map((childNode) => childNode.attrs.id)
+            .filter((id) => id),
+        category: (0, section_category_1.buildSectionCategory)(node),
+    }),
+};
+const modelData = (node, parent, path, priority) => {
+    const encoder = encoders[node.type.name];
+    if (!encoder) {
+        throw new Error(`Unhandled model: ${node.type.name}`);
+    }
+    return encoder(node, parent, path, priority);
+};
+const modelFromNode = (node, parent, path, priority) => {
+    const objectType = node_types_1.nodeTypesMap.get(node.type);
+    if (!objectType) {
+        throw new Error(`No objectType is defined for ${node.type.name}`);
+    }
+    const { id } = node.attrs;
+    if (!id) {
+        throw new Error(`No id is defined for this ${node.type.name}`);
+    }
+    const data = Object.assign(Object.assign({}, modelData(node, parent, path, priority)), { _id: id, objectType: objectType });
+    const model = data;
+    const markers = (0, highlight_markers_1.extractCommentMarkers)(model);
+    return { model, markers };
+};
+exports.modelFromNode = modelFromNode;
+const containerTypes = [
+    schema_1.schema.nodes.affiliations,
+    schema_1.schema.nodes.contributors,
+    schema_1.schema.nodes.keywords,
+    schema_1.schema.nodes.supplements,
+    schema_1.schema.nodes.abstracts,
+    schema_1.schema.nodes.body,
+    schema_1.schema.nodes.backmatter,
+    schema_1.schema.nodes.general_table_footnote,
+];
+const placeholderTypes = [
+    schema_1.schema.nodes.placeholder,
+    schema_1.schema.nodes.placeholder_element,
+];
+const encode = (node) => {
+    const models = new Map();
+    const priority = {
+        value: 1,
+    };
+    const processNode = (path, parent) => (child) => {
+        if (containerTypes.includes(child.type)) {
+            child.forEach(processNode([], child));
+            return;
+        }
+        if (!child.attrs.id) {
+            return;
+        }
+        if ((0, schema_1.isHighlightMarkerNode)(child)) {
+            return;
+        }
+        if (placeholderTypes.includes(child.type)) {
+            return;
+        }
+        if (parent.type === schema_1.schema.nodes.paragraph) {
+            return;
+        }
+        if (child.type === schema_1.schema.nodes.footnotes_element) {
+            addFootnotesOrderModel(child, models);
+        }
+        const { model, markers } = (0, exports.modelFromNode)(child, parent, path, priority);
+        markers.forEach((marker) => {
+            const comment = models.get(marker._id);
+            if (comment) {
+                comment.selector = {
+                    from: marker.from,
+                    to: marker.to,
+                };
+            }
+        });
+        if (models.has(model._id)) {
+            throw Error(`Duplicate ids in encode: ${model._id}`);
+        }
+        models.set(model._id, model);
+        child.forEach(processNode(path.concat(child.attrs.id), child));
+    };
+    const comments = node.lastChild;
+    if (comments && comments.type === schema_1.schema.nodes.comments) {
+        comments.forEach(processNode([], comments));
+    }
+    node.forEach(processNode([], node));
+    if ((0, schema_1.isManuscriptNode)(node)) {
+        builders_1.auxiliaryObjectTypes.forEach((t) => {
+            const order = generateElementOrder(node, t);
+            if (order) {
+                models.set(order._id, order);
+            }
+        });
+    }
+    return models;
+};
+exports.encode = encode;
+const generateElementOrder = (node, nodeType) => {
+    const ids = [];
+    node.descendants((n) => {
+        if (n.type === nodeType) {
+            ids.push(n.attrs.id);
+        }
+        return true;
+    });
+    if (!ids.length) {
+        return undefined;
+    }
+    const type = node_types_1.nodeTypesMap.get(nodeType);
+    if (!type) {
+        return undefined;
+    }
+    const order = (0, builders_1.buildElementsOrder)(type);
+    order.elements = ids;
+    return order;
+};
+const addFootnotesOrderModel = (child, models) => {
+    const footnoteList = [];
+    child.forEach((footnote, _, index) => footnoteList.push({ id: footnote.attrs.id, index }));
+    const footnotesOrder = (0, builders_1.buildFootnotesOrder)(footnoteList, child.attrs.id);
+    models.set(footnotesOrder._id, footnotesOrder);
+};