@manuscripts/transform 1.0.0

package/dist/es/transformer/manuscript-dependencies.js

@@ -0,0 +1,64 @@
+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 { generateID } from './id';
+import { hasObjectType } from './object-types';
+import { loadSharedData } from './shared-data';
+const isStatusLabel = hasObjectType(ObjectTypes.StatusLabel);
+const isBundledModel = (model) => model.bundled === true;
+const loadBundledData = async (file) => {
+    const models = await loadSharedData(file);
+    return models.filter(isBundledModel);
+};
+export const loadStyles = () => loadBundledData('styles');
+export const loadKeywords = () => loadBundledData('keywords');
+export const loadContributorRoles = () => loadBundledData('contributor-roles');
+export const loadBundledDependencies = async () => {
+    const contributorRoles = await loadContributorRoles();
+    const keywords = await loadKeywords();
+    const styles = await loadStyles();
+    return [...contributorRoles, ...keywords.filter(isStatusLabel), ...styles];
+};
+export const fromPrototype = (model) => {
+    const { _id, _rev } = model, data = __rest(model, ["_id", "_rev"]);
+    const output = Object.assign(Object.assign({}, data), { prototype: _id, _id: generateID(model.objectType) });
+    return output;
+};
+export const getByPrototype = (modelMap, prototype) => {
+    for (const model of modelMap.values()) {
+        if (model.prototype === prototype) {
+            return model;
+        }
+    }
+};
+const isParagraphStyle = hasObjectType(ObjectTypes.ParagraphStyle);
+const chooseNewDefaultParagraphStyle = (styles) => {
+    for (const style of styles.values()) {
+        if (isParagraphStyle(style)) {
+            if (style.title === 'Body Text') {
+                return style;
+            }
+        }
+    }
+};
+export const updatedPageLayout = (styleMap, pageLayoutID) => {
+    const newPageLayout = getByPrototype(styleMap, pageLayoutID);
+    if (!newPageLayout) {
+        throw new Error('Page layout not found');
+    }
+    const newDefaultParagraphStyle = getByPrototype(styleMap, newPageLayout.defaultParagraphStyle) || chooseNewDefaultParagraphStyle(styleMap);
+    if (!newDefaultParagraphStyle) {
+        throw new Error('Default paragraph style not found');
+    }
+    newPageLayout.defaultParagraphStyle = newDefaultParagraphStyle._id;
+    return newPageLayout;
+};

package/dist/es/transformer/model-map.js

@@ -0,0 +1,22 @@
+/*!
+ * © 2020 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { generateID } from './id';
+export const addModelToMap = (modelMap) => (data) => {
+    if (!data._id) {
+        data._id = generateID(data.objectType);
+    }
+    modelMap.set(data._id, data);
+};

package/dist/es/transformer/models.js

@@ -0,0 +1,16 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/dist/es/transformer/node-names.js

@@ -0,0 +1,39 @@
+/*!
+ * © 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 { schema } from '../schema';
+export const nodeNames = new Map([
+    [schema.nodes.bibliography_element, 'Bibliography'],
+    [schema.nodes.bibliography_section, 'Section'],
+    [schema.nodes.citation, 'Citation'],
+    [schema.nodes.listing_element, 'Listing'],
+    [schema.nodes.cross_reference, 'Cross Reference'],
+    [schema.nodes.equation_element, 'Equation'],
+    [schema.nodes.figure_element, 'Figure'],
+    [schema.nodes.footnote, 'Footnote'],
+    [schema.nodes.footnotes_element, 'Notes'],
+    [schema.nodes.bullet_list, 'Bullet List'],
+    [schema.nodes.ordered_list, 'Ordered List'],
+    [schema.nodes.manuscript, 'Manuscript'],
+    [schema.nodes.paragraph, 'Paragraph'],
+    [schema.nodes.section, 'Section'],
+    [schema.nodes.section_title, 'Section'],
+    [schema.nodes.table, 'Table'],
+    [schema.nodes.table_element, 'Table'],
+    [schema.nodes.blockquote_element, 'Block Quote'],
+    [schema.nodes.pullquote_element, 'Pull Quote'],
+    [schema.nodes.keywords_section, 'Section'],
+    [schema.nodes.toc_section, 'Section'],
+]);

package/dist/es/transformer/node-title.js

@@ -0,0 +1,82 @@
+/*!
+ * © 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 { iterateChildren } from '../lib/utils';
+import { isHighlightMarkerNode } from '../schema';
+import { nodeNames } from './node-names';
+const textSnippet = (node, max = 100) => {
+    let text = '';
+    node.forEach((child) => {
+        if (child.isText) {
+            text += child.text;
+        }
+        else if (isHighlightMarkerNode(node)) {
+            text += '';
+        }
+        else {
+            text += ' ';
+        }
+    });
+    return text.substr(0, max);
+};
+const snippetOfNodeType = (node, nodeType) => {
+    for (const child of iterateChildren(node, true)) {
+        if (child.type === nodeType) {
+            return textSnippet(child);
+        }
+    }
+    return null;
+};
+export const nodeTitle = (node) => {
+    const nodes = node.type.schema.nodes;
+    switch (node.type) {
+        case nodes.section:
+        case nodes.bibliography_section:
+        case nodes.footnotes_section:
+        case nodes.keywords_section:
+        case nodes.toc_section:
+        case nodes.graphical_abstract_section:
+            return snippetOfNodeType(node, nodes.section_title);
+        case nodes.footnotes_element:
+            return node.attrs.collateByKind === 'footnote' ? 'Footnotes' : 'Endnotes';
+        case nodes.ordered_list:
+        case nodes.bullet_list:
+        case nodes.blockquote_element:
+        case nodes.footnote:
+        case nodes.pullquote_element:
+            return snippetOfNodeType(node, nodes.paragraph);
+        case nodes.figure_element:
+        case nodes.table_element:
+        case nodes.equation_element:
+        case nodes.listing_element:
+        case nodes.multi_graphic_figure_element:
+            return '';
+        default:
+            return textSnippet(node);
+    }
+};
+export const nodeTitlePlaceholder = (nodeType) => {
+    const nodes = nodeType.schema.nodes;
+    switch (nodeType) {
+        case nodes.title:
+            return 'Untitled Manuscript';
+        case nodes.section:
+            return 'Untitled Section';
+        case nodes.bibliography_section:
+            return 'Bibliography';
+        default:
+            return nodeNames.get(nodeType) || '';
+    }
+};

package/dist/es/transformer/node-types.js

@@ -0,0 +1,55 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ObjectTypes } from '@manuscripts/manuscripts-json-schema';
+import { GROUP_ELEMENT, GROUP_EXECUTABLE, GROUP_SECTION, hasGroup, schema, } from '../schema';
+export const nodeTypesMap = new Map([
+    [schema.nodes.comment, ObjectTypes.CommentAnnotation],
+    [schema.nodes.bibliography_item, ObjectTypes.BibliographyItem],
+    [schema.nodes.bibliography_element, ObjectTypes.BibliographyElement],
+    [schema.nodes.bibliography_section, ObjectTypes.Section],
+    [schema.nodes.blockquote_element, ObjectTypes.QuoteElement],
+    [schema.nodes.bullet_list, ObjectTypes.ListElement],
+    [schema.nodes.citation, ObjectTypes.Citation],
+    [schema.nodes.cross_reference, ObjectTypes.AuxiliaryObjectReference],
+    [schema.nodes.equation, ObjectTypes.Equation],
+    [schema.nodes.equation_element, ObjectTypes.EquationElement],
+    [schema.nodes.figure, ObjectTypes.Figure],
+    [schema.nodes.missing_figure, ObjectTypes.MissingFigure],
+    [schema.nodes.figure_element, ObjectTypes.FigureElement],
+    [schema.nodes.footnote, ObjectTypes.Footnote],
+    [schema.nodes.footnotes_element, ObjectTypes.FootnotesElement],
+    [schema.nodes.footnotes_section, ObjectTypes.Section],
+    [schema.nodes.graphical_abstract_section, ObjectTypes.Section],
+    [schema.nodes.highlight_marker, ObjectTypes.HighlightMarker],
+    [schema.nodes.inline_equation, ObjectTypes.InlineMathFragment],
+    [schema.nodes.keywords_element, ObjectTypes.KeywordsElement],
+    [schema.nodes.keywords_section, ObjectTypes.Section],
+    [schema.nodes.listing, ObjectTypes.Listing],
+    [schema.nodes.listing_element, ObjectTypes.ListingElement],
+    [schema.nodes.manuscript, ObjectTypes.Manuscript],
+    [schema.nodes.ordered_list, ObjectTypes.ListElement],
+    [schema.nodes.paragraph, ObjectTypes.ParagraphElement],
+    [schema.nodes.pullquote_element, ObjectTypes.QuoteElement],
+    [schema.nodes.section, ObjectTypes.Section],
+    [schema.nodes.table, ObjectTypes.Table],
+    [schema.nodes.table_element, ObjectTypes.TableElement],
+    [schema.nodes.toc_element, ObjectTypes.TOCElement],
+    [schema.nodes.toc_section, ObjectTypes.Section],
+]);
+export const isExecutableNodeType = (type) => hasGroup(type, GROUP_EXECUTABLE);
+export const isElementNodeType = (type) => hasGroup(type, GROUP_ELEMENT);
+export const isSectionNodeType = (type) => hasGroup(type, GROUP_SECTION);
+export const isNodeType = (node, type) => node.type === node.type.schema.nodes[type];

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

@@ -0,0 +1,52 @@
+/*!
+ * © 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 { manuscriptIDTypes, ObjectTypes, } from '@manuscripts/manuscripts-json-schema';
+export var ExtraObjectTypes;
+(function (ExtraObjectTypes) {
+    ExtraObjectTypes["PlaceholderElement"] = "MPPlaceholderElement";
+})(ExtraObjectTypes || (ExtraObjectTypes = {}));
+export const elementObjects = [
+    ObjectTypes.BibliographyElement,
+    ObjectTypes.EquationElement,
+    ObjectTypes.FigureElement,
+    ObjectTypes.FootnotesElement,
+    ObjectTypes.ListElement,
+    ObjectTypes.ListingElement,
+    ObjectTypes.ParagraphElement,
+    ObjectTypes.TableElement,
+    ObjectTypes.TOCElement,
+];
+export const manuscriptObjects = [
+    ObjectTypes.Affiliation,
+    ObjectTypes.Citation,
+    ObjectTypes.CommentAnnotation,
+    ObjectTypes.Contributor,
+    ObjectTypes.Footnote,
+    ObjectTypes.InlineMathFragment,
+    ObjectTypes.Section,
+].concat(elementObjects);
+export const isManuscriptModel = (model) => {
+    if (!model.objectType) {
+        throw new Error('Model must have objectType');
+    }
+    return manuscriptIDTypes.has(model.objectType);
+};
+export const hasObjectType = (objectType) => (model) => model.objectType === objectType;
+export const isFigure = hasObjectType(ObjectTypes.Figure);
+export const isManuscript = hasObjectType(ObjectTypes.Manuscript);
+export const isTable = hasObjectType(ObjectTypes.Table);
+export const isUserProfile = hasObjectType(ObjectTypes.UserProfile);
+export const isCommentAnnotation = hasObjectType(ObjectTypes.CommentAnnotation);

package/dist/es/transformer/project-bundle.js

@@ -0,0 +1,77 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ObjectTypes, } from '@manuscripts/manuscripts-json-schema';
+import { Decoder } from './decode';
+import { hasObjectType } from './object-types';
+export const parseProjectBundle = (projectBundle, manuscriptID) => {
+    const manuscriptData = manuscriptID
+        ? projectBundle.data.filter((doc) => !doc.manuscriptID || doc.manuscriptID === manuscriptID)
+        : projectBundle.data;
+    const modelMap = new Map();
+    for (const component of manuscriptData) {
+        modelMap.set(component._id, component);
+    }
+    const decoder = new Decoder(modelMap);
+    const doc = decoder.createArticleNode();
+    return { doc, modelMap };
+};
+const isManuscript = hasObjectType(ObjectTypes.Manuscript);
+export const findManuscript = (modelMap) => {
+    for (const model of modelMap.values()) {
+        if (isManuscript(model)) {
+            return model;
+        }
+    }
+    throw new Error('No manuscript found');
+};
+const isJournal = hasObjectType(ObjectTypes.Journal);
+export const findJournal = (modelMap) => {
+    for (const model of modelMap.values()) {
+        if (isJournal(model)) {
+            return model;
+        }
+    }
+    return null;
+};
+const isManuscriptModel = (model) => 'manuscriptID' in model;
+export const findManuscriptModelByType = (modelMap, manuscript, objectType) => {
+    for (const model of modelMap.values()) {
+        if (model.objectType === objectType &&
+            isManuscriptModel(model) &&
+            manuscript._id === model.manuscriptID) {
+            return model;
+        }
+    }
+};
+const isSubmission = hasObjectType(ObjectTypes.Submission);
+const newestFirst = (a, b) => b.createdAt - a.createdAt;
+export const findLatestManuscriptSubmission = (modelMap, manuscript) => {
+    const submissions = [];
+    for (const model of modelMap.values()) {
+        if (isSubmission(model) && model.manuscriptID === manuscript._id) {
+            submissions.push(model);
+        }
+    }
+    submissions.sort(newestFirst);
+    return submissions.length ? submissions[0] : undefined;
+};
+export const findManuscriptById = (modelMap, manuscriptID) => {
+    const manuscript = modelMap.get(manuscriptID);
+    if (manuscript && isManuscript(manuscript)) {
+        return manuscript;
+    }
+    throw new Error(`There is no manuscript found for the following _id (${manuscriptID})`);
+};

package/dist/es/transformer/section-category.js

@@ -0,0 +1,210 @@
+/*!
+ * © 2019 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ObjectTypes } from '@manuscripts/manuscripts-json-schema';
+import { schema } from '../schema';
+const sectionNodeTypes = [
+    schema.nodes.bibliography_section,
+    schema.nodes.footnotes_section,
+    schema.nodes.keywords_section,
+    schema.nodes.section,
+    schema.nodes.toc_section,
+];
+export const isAnySectionNode = (node) => sectionNodeTypes.includes(node.type);
+export const chooseSectionNodeType = (category) => {
+    switch (category) {
+        case 'MPSectionCategory:bibliography':
+            return schema.nodes.bibliography_section;
+        case 'MPSectionCategory:abstract-graphical':
+            return schema.nodes.graphical_abstract_section;
+        case 'MPSectionCategory:endnotes':
+            return schema.nodes.footnotes_section;
+        case 'MPSectionCategory:keywords':
+            return schema.nodes.keywords_section;
+        case 'MPSectionCategory:toc':
+            return schema.nodes.toc_section;
+        default:
+            return schema.nodes.section;
+    }
+};
+export const chooseSectionLableName = (type) => {
+    switch (type) {
+        case 'appendices':
+            return 'Appendix';
+        default:
+            return type;
+    }
+};
+export const guessSectionCategory = (elements) => {
+    if (!elements.length) {
+        return undefined;
+    }
+    switch (elements[0].objectType) {
+        case ObjectTypes.BibliographyElement:
+            return 'MPSectionCategory:bibliography';
+        case ObjectTypes.FootnotesElement:
+            return 'MPSectionCategory:endnotes';
+        case ObjectTypes.KeywordsElement:
+            return 'MPSectionCategory:keywords';
+        case ObjectTypes.TOCElement:
+            return 'MPSectionCategory:toc';
+        default:
+            return undefined;
+    }
+};
+export const buildSectionCategory = (node) => {
+    switch (node.type) {
+        case schema.nodes.bibliography_section:
+            return 'MPSectionCategory:bibliography';
+        case schema.nodes.footnotes_section:
+            return 'MPSectionCategory:endnotes';
+        case schema.nodes.keywords_section:
+            return 'MPSectionCategory:keywords';
+        case schema.nodes.toc_section:
+            return 'MPSectionCategory:toc';
+        case schema.nodes.graphical_abstract_section:
+            return 'MPSectionCategory:abstract-graphical';
+        default:
+            return node.attrs.category || undefined;
+    }
+};
+export const chooseSecType = (sectionCategory) => {
+    const [, suffix] = sectionCategory.split(':', 2);
+    switch (suffix) {
+        case 'acknowledgement':
+            return 'acknowledgments';
+        case 'introduction':
+            return 'intro';
+        case 'materials-method':
+            return 'methods';
+        default:
+            return suffix;
+    }
+};
+export const chooseSectionCategoryByType = (secType) => {
+    switch (secType) {
+        case 'abstract':
+            return 'MPSectionCategory:abstract';
+        case 'abstract-teaser':
+            return 'MPSectionCategory:abstract-teaser';
+        case 'abstract-graphical':
+            return 'MPSectionCategory:abstract-graphical';
+        case 'acknowledgments':
+            return 'MPSectionCategory:acknowledgement';
+        case 'availability':
+        case 'data-availability':
+            return 'MPSectionCategory:availability';
+        case 'bibliography':
+            return 'MPSectionCategory:bibliography';
+        case 'conclusions':
+            return 'MPSectionCategory:conclusions';
+        case 'discussion':
+            return 'MPSectionCategory:discussion';
+        case 'endnotes':
+            return 'MPSectionCategory:endnotes';
+        case 'intro':
+            return 'MPSectionCategory:introduction';
+        case 'keywords':
+            return 'MPSectionCategory:keywords';
+        case 'materials':
+        case 'methods':
+            return 'MPSectionCategory:materials-method';
+        case 'results':
+            return 'MPSectionCategory:results';
+        case 'toc':
+            return 'MPSectionCategory:toc';
+        case 'floating-element':
+            return 'MPSectionCategory:floating-element';
+        case 'appendices':
+            return 'MPSectionCategory:appendices';
+        case 'competing-interests':
+        case 'conflict':
+            return 'MPSectionCategory:competing-interests';
+        case 'financial-disclosure':
+            return 'MPSectionCategory:financial-disclosure';
+        case 'con':
+            return 'MPSectionCategory:con';
+        case 'deceased':
+            return 'MPSectionCategory:deceased';
+        case 'equal':
+            return 'MPSectionCategory:equal';
+        case 'present-address':
+            return 'MPSectionCategory:present-address';
+        case 'presented-at':
+            return 'MPSectionCategory:presented-at';
+        case 'previously-at':
+            return 'MPSectionCategory:previously-at';
+        case 'supplementary-material':
+            return 'MPSectionCategory:supplementary-material';
+        case 'supported-by':
+            return 'MPSectionCategory:supported-by';
+        case 'ethics-statement':
+            return 'MPSectionCategory:ethics-statement';
+        default:
+            return undefined;
+    }
+};
+export const chooseSectionCategory = (section) => {
+    const secType = section.getAttribute('sec-type');
+    const secCat = chooseSectionCategoryByType(secType);
+    if (secCat) {
+        return secCat;
+    }
+    else {
+        const titleNode = section.firstElementChild;
+        if (titleNode && titleNode.nodeName === 'title' && titleNode.textContent) {
+            return chooseSectionCategoryFromTitle(titleNode.textContent.trim().toLowerCase());
+        }
+        return undefined;
+    }
+};
+export const chooseSectionCategoryFromTitle = (title) => {
+    if (!title) {
+        return undefined;
+    }
+    switch (title) {
+        case 'abstract':
+            return 'MPSectionCategory:abstract';
+        case 'acknowledgments':
+        case 'acknowledgements':
+            return 'MPSectionCategory:acknowledgement';
+        case 'availability':
+        case 'data availability':
+            return 'MPSectionCategory:availability';
+        case 'conclusions':
+            return 'MPSectionCategory:conclusions';
+        case 'discussion':
+            return 'MPSectionCategory:discussion';
+        case 'introduction':
+            return 'MPSectionCategory:introduction';
+        case 'methods':
+        case 'materials':
+        case 'materials and methods':
+        case 'materials & methods':
+            return 'MPSectionCategory:materials-method';
+        case 'results':
+            return 'MPSectionCategory:results';
+        case 'bibliography':
+        case 'references':
+            return 'MPSectionCategory:bibliography';
+        case 'conflict':
+        case 'conflict of interest':
+        case 'competing interests':
+            return 'MPSectionCategory:competing-interests';
+        case 'financial-disclosure':
+        case 'funding information':
+            return 'MPSectionCategory:financial-disclosure';
+    }
+};

package/dist/es/transformer/serializer.js

@@ -0,0 +1,17 @@
+/*!
+ * © 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 serializeToString from 'w3c-xmlserializer';
+export const xmlSerializer = { serializeToString };

package/dist/es/transformer/shared-data.js

@@ -0,0 +1 @@
+export const loadSharedData = (file) => import(`@manuscripts/data/dist/shared/${file}.json`).then((module) => module.default);