@manuscripts/transform 1.0.0

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

@@ -0,0 +1,222 @@
+"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.chooseSectionCategoryFromTitle = exports.chooseSectionCategory = exports.chooseSectionCategoryByType = exports.chooseSecType = exports.buildSectionCategory = exports.guessSectionCategory = exports.chooseSectionLableName = exports.chooseSectionNodeType = exports.isAnySectionNode = void 0;
+const manuscripts_json_schema_1 = require("@manuscripts/manuscripts-json-schema");
+const schema_1 = require("../schema");
+const sectionNodeTypes = [
+    schema_1.schema.nodes.bibliography_section,
+    schema_1.schema.nodes.footnotes_section,
+    schema_1.schema.nodes.keywords_section,
+    schema_1.schema.nodes.section,
+    schema_1.schema.nodes.toc_section,
+];
+const isAnySectionNode = (node) => sectionNodeTypes.includes(node.type);
+exports.isAnySectionNode = isAnySectionNode;
+const chooseSectionNodeType = (category) => {
+    switch (category) {
+        case 'MPSectionCategory:bibliography':
+            return schema_1.schema.nodes.bibliography_section;
+        case 'MPSectionCategory:abstract-graphical':
+            return schema_1.schema.nodes.graphical_abstract_section;
+        case 'MPSectionCategory:endnotes':
+            return schema_1.schema.nodes.footnotes_section;
+        case 'MPSectionCategory:keywords':
+            return schema_1.schema.nodes.keywords_section;
+        case 'MPSectionCategory:toc':
+            return schema_1.schema.nodes.toc_section;
+        default:
+            return schema_1.schema.nodes.section;
+    }
+};
+exports.chooseSectionNodeType = chooseSectionNodeType;
+const chooseSectionLableName = (type) => {
+    switch (type) {
+        case 'appendices':
+            return 'Appendix';
+        default:
+            return type;
+    }
+};
+exports.chooseSectionLableName = chooseSectionLableName;
+const guessSectionCategory = (elements) => {
+    if (!elements.length) {
+        return undefined;
+    }
+    switch (elements[0].objectType) {
+        case manuscripts_json_schema_1.ObjectTypes.BibliographyElement:
+            return 'MPSectionCategory:bibliography';
+        case manuscripts_json_schema_1.ObjectTypes.FootnotesElement:
+            return 'MPSectionCategory:endnotes';
+        case manuscripts_json_schema_1.ObjectTypes.KeywordsElement:
+            return 'MPSectionCategory:keywords';
+        case manuscripts_json_schema_1.ObjectTypes.TOCElement:
+            return 'MPSectionCategory:toc';
+        default:
+            return undefined;
+    }
+};
+exports.guessSectionCategory = guessSectionCategory;
+const buildSectionCategory = (node) => {
+    switch (node.type) {
+        case schema_1.schema.nodes.bibliography_section:
+            return 'MPSectionCategory:bibliography';
+        case schema_1.schema.nodes.footnotes_section:
+            return 'MPSectionCategory:endnotes';
+        case schema_1.schema.nodes.keywords_section:
+            return 'MPSectionCategory:keywords';
+        case schema_1.schema.nodes.toc_section:
+            return 'MPSectionCategory:toc';
+        case schema_1.schema.nodes.graphical_abstract_section:
+            return 'MPSectionCategory:abstract-graphical';
+        default:
+            return node.attrs.category || undefined;
+    }
+};
+exports.buildSectionCategory = buildSectionCategory;
+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;
+    }
+};
+exports.chooseSecType = chooseSecType;
+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;
+    }
+};
+exports.chooseSectionCategoryByType = chooseSectionCategoryByType;
+const chooseSectionCategory = (section) => {
+    const secType = section.getAttribute('sec-type');
+    const secCat = (0, exports.chooseSectionCategoryByType)(secType);
+    if (secCat) {
+        return secCat;
+    }
+    else {
+        const titleNode = section.firstElementChild;
+        if (titleNode && titleNode.nodeName === 'title' && titleNode.textContent) {
+            return (0, exports.chooseSectionCategoryFromTitle)(titleNode.textContent.trim().toLowerCase());
+        }
+        return undefined;
+    }
+};
+exports.chooseSectionCategory = chooseSectionCategory;
+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';
+    }
+};
+exports.chooseSectionCategoryFromTitle = chooseSectionCategoryFromTitle;

package/dist/cjs/transformer/serializer.js

@@ -0,0 +1,23 @@
+"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.xmlSerializer = void 0;
+const w3c_xmlserializer_1 = __importDefault(require("w3c-xmlserializer"));
+exports.xmlSerializer = { serializeToString: w3c_xmlserializer_1.default };

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

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSharedData = void 0;
+const loadSharedData = (file) => {
+    var _a;
+    return (_a = `@manuscripts/data/dist/shared/${file}.json`, Promise.resolve().then(() => __importStar(require(_a)))).then((module) => module.default);
+};
+exports.loadSharedData = loadSharedData;

package/dist/cjs/transformer/tei-grobid-importer.js

@@ -0,0 +1,121 @@
+"use strict";
+/*!
+ * © 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTEIGROBIDArticle = exports.parseBack = exports.parseFront = void 0;
+const builders_1 = require("./builders");
+const model_map_1 = require("./model-map");
+const iterateSnapshot = function* (snapshot) {
+    for (let i = 0; i < snapshot.snapshotLength; i++) {
+        yield snapshot.snapshotItem(i);
+    }
+};
+const namespaces = new Map([
+    [null, 'http://www.tei-c.org/ns/1.0'],
+]);
+const namespaceResolver = (prefix) => namespaces.get(prefix) || null;
+const parseFront = (doc, addModel) => {
+    const headerNode = doc.evaluate('/TEI/teiHeader', doc, namespaceResolver, XPathResult.FIRST_ORDERED_NODE_TYPE).singleNodeValue;
+    if (!headerNode) {
+        throw new Error('No header element found!');
+    }
+    const title = doc.evaluate('fileDesc/titleStmt/title', headerNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+    const manuscript = (0, builders_1.buildManuscript)(title);
+    addModel(manuscript);
+    const affiliationsMap = new Map();
+    const authorNodes = doc.evaluate('fileDesc/sourceDesc/biblStruct/analytic/author', headerNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+    for (const authorNode of iterateSnapshot(authorNodes)) {
+        const name = (0, builders_1.buildBibliographicName)({});
+        name.given = doc.evaluate('persName/forename', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        name.family = doc.evaluate('persName/surname', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        const contributor = (0, builders_1.buildContributor)(name, 'author', 1);
+        contributor.affiliations = [];
+        const affiliationNodes = doc.evaluate('affiliation', authorNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+        for (const affiliationNode of iterateSnapshot(affiliationNodes)) {
+            const key = affiliationNode.getAttribute('key');
+            if (key) {
+                const affiliation = affiliationsMap.get(key);
+                if (affiliation) {
+                    contributor.affiliations.push(affiliation._id);
+                }
+                else {
+                    const affiliation = (0, builders_1.buildAffiliation)('', 1);
+                    affiliation.institution = doc.evaluate('orgName[@type="institution"]', affiliationNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+                    affiliation.department = doc.evaluate('orgName[@type="department"]', affiliationNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+                    addModel(affiliation);
+                    affiliationsMap.set(key, affiliation);
+                    contributor.affiliations.push(affiliation._id);
+                }
+            }
+        }
+        addModel(contributor);
+    }
+};
+exports.parseFront = parseFront;
+const chooseBibliographyItemType = (publicationType) => {
+    switch (publicationType) {
+        case 'book':
+        case 'thesis':
+            return publicationType;
+        case 'journal':
+        default:
+            return 'article-journal';
+    }
+};
+const parseBack = (doc, addModel) => {
+    const backNode = doc.evaluate('/TEI/text/back', doc, namespaceResolver, XPathResult.FIRST_ORDERED_NODE_TYPE).singleNodeValue;
+    if (!backNode) {
+        return;
+    }
+    const referenceNodes = doc.evaluate('div[@type="references"]/listBibl/biblStruct', backNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+    for (const referenceNode of iterateSnapshot(referenceNodes)) {
+        const bibliographyItem = (0, builders_1.buildBibliographyItem)({
+            type: chooseBibliographyItemType(null),
+        });
+        bibliographyItem.title = doc.evaluate('analytic/title', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        bibliographyItem.source = doc.evaluate('monogr/title', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        bibliographyItem.volume = doc.evaluate('monogr/imprint/biblScope[unit="volume"]', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        const fpage = doc.evaluate('monogr/imprint/biblScope[unit="page"]/@from', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        const lpage = doc.evaluate('monogr/imprint/biblScope[unit="page"]/@to', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        if (fpage) {
+            bibliographyItem.page = lpage ? `${fpage}-${lpage}` : fpage;
+        }
+        const date = doc.evaluate('monogr/imprint/date[type="published"]/@when', referenceNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+        if (date) {
+            bibliographyItem.issued = (0, builders_1.buildBibliographicDate)({
+                'date-parts': [date.split(/-/)],
+            });
+        }
+        const authorNodes = doc.evaluate('analytic/author', referenceNode, namespaceResolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE);
+        bibliographyItem.author = [];
+        for (const authorNode of iterateSnapshot(authorNodes)) {
+            const name = (0, builders_1.buildBibliographicName)({});
+            name.given = doc.evaluate('persName/forename', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+            name.family = doc.evaluate('persName/surname', authorNode, namespaceResolver, XPathResult.STRING_TYPE).stringValue;
+            bibliographyItem.author.push(name);
+        }
+        addModel(bibliographyItem);
+    }
+};
+exports.parseBack = parseBack;
+const parseTEIGROBIDArticle = (doc) => {
+    const modelMap = new Map();
+    const addModel = (0, model_map_1.addModelToMap)(modelMap);
+    (0, exports.parseFront)(doc, addModel);
+    (0, exports.parseBack)(doc, addModel);
+    return [...modelMap.values()];
+};
+exports.parseTEIGROBIDArticle = parseTEIGROBIDArticle;

package/dist/cjs/transformer/timestamp.js

@@ -0,0 +1,20 @@
+"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.timestamp = void 0;
+const timestamp = () => Math.floor(Date.now() / 1000);
+exports.timestamp = timestamp;

package/dist/cjs/transformer/update-identifiers.js

@@ -0,0 +1,93 @@
+"use strict";
+/*!
+ * © 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAttachments = exports.updateAttachmentPath = exports.updateIdentifiers = void 0;
+const id_1 = require("./id");
+const updateIdentifiers = async (data) => {
+    const idMap = new Map();
+    const updateIDs = (model) => {
+        const { _id, objectType } = model;
+        if (!objectType || !_id || !_id.match(/^MP.+:.+/)) {
+            return;
+        }
+        if (idMap.has(_id)) {
+            model._id = idMap.get(_id);
+        }
+        else {
+            model._id = (0, id_1.generateID)(objectType);
+            idMap.set(_id, model._id);
+        }
+        for (const value of Object.values(model)) {
+            if (Array.isArray(value)) {
+                value.forEach(updateIDs);
+            }
+            else {
+                updateIDs(value);
+            }
+        }
+    };
+    const replaceContent = (content) => {
+        content = content.replace(/MP\w+:[\w-]+/g, (match) => {
+            const value = idMap.get(match);
+            return value !== null && value !== void 0 ? value : match;
+        });
+        content = content.replace(/MP\w+_[\w-]+/g, (match) => {
+            const value = idMap.get(match.replace('_', ':'));
+            return value ? value.replace(':', '_') : match;
+        });
+        return content;
+    };
+    const updateContent = (model) => {
+        for (const [key, value] of Object.entries(model)) {
+            if (typeof value === 'object') {
+                updateContent(value);
+            }
+            else if (typeof value === 'string') {
+                model[key] = replaceContent(value);
+            }
+        }
+    };
+    for (const item of data) {
+        updateIDs(item);
+    }
+    for (const item of data) {
+        updateContent(item);
+    }
+    return { data, idMap };
+};
+exports.updateIdentifiers = updateIdentifiers;
+const updateAttachmentPath = (oldPath, idMap) => {
+    const matches = oldPath.match(/^Data\/([^.]+)(.*)/);
+    if (matches) {
+        const [, prefix, suffix] = matches;
+        const id = idMap.get(prefix.replace('_', ':'));
+        if (id) {
+            const newPrefix = id.replace(':', '_');
+            return `Data/${newPrefix}${suffix}`;
+        }
+    }
+};
+exports.updateAttachmentPath = updateAttachmentPath;
+const updateAttachments = async (zip, idMap) => {
+    for (const [oldPath, entry] of Object.entries(zip.files)) {
+        const newPath = (0, exports.updateAttachmentPath)(oldPath, idMap);
+        if (newPath) {
+            zip.file(newPath, await entry.async('blob')).remove(oldPath);
+        }
+    }
+};
+exports.updateAttachments = updateAttachments;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/es/errors.js

@@ -0,0 +1,12 @@
+export class MissingElement extends Error {
+    constructor(elementID) {
+        super(`${elementID} not found in the manuscripts data`);
+        this.name = 'MissingElement';
+    }
+}
+export class InvalidInput extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidInput';
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,9 @@
+export * from './lib/table-cell-styles';
+export * from './lib/utils';
+export * from './mathjax';
+export * from './schema';
+export * from './transformer';
+export * from './jats';
+export * from './types';
+export * from './errors';
+export { isSectionLabelNode } from './schema/nodes/section_label';

package/dist/es/jats/importer/index.js

@@ -0,0 +1,16 @@
+/*!
+ * © 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.
+ */
+export { parseJATSFront, parseJATSBody, parseJATSReferences, parseJATSArticle, getElementsOrder, } from './parse-jats-article';