@manuscripts/transform 1.5.7 → 1.5.8-LEAN-3030

package/dist/es/transformer/encode.js

@@ -15,10 +15,11 @@
  */
 import { DOMSerializer } from 'prosemirror-model';
 import serializeToXML from 'w3c-xmlserializer';
-import { iterateChildren } from '../lib/utils';
-import { hasGroup, isHighlightMarkerNode, isSectionNode, schema, } from '../schema';
-import { buildAttribution } from './builders';
+import { iterateChildren, modelsEqual } from '../lib/utils';
+import { hasGroup, isHighlightMarkerNode, isManuscriptNode, isSectionNode, schema, } from '../schema';
+import { auxiliaryObjectTypes, buildAttribution, buildElementsOrder, } from './builders';
 import { extractHighlightMarkers, isHighlightableModel, } from './highlight-markers';
+import { generateID } from './id';
 import { nodeTypesMap } from './node-types';
 import { buildSectionCategory } from './section-category';
 const serializer = DOMSerializer.fromSchema(schema);
@@ -420,34 +421,9 @@ const encoders = {
         elementType: 'div',
         paragraphStyle: node.attrs.paragraphStyle || undefined,
     }),
-    keywords_group: (node) => ({
+    keyword_group: (node) => ({
         type: node.attrs.type,
     }),
-    keywords_section: (node, parent, path, priority) => ({
-        category: 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),
-    }),
-    affiliations_section: (node, parent, path, priority) => ({
-        category: buildSectionCategory(node),
-        priority: priority.value++,
-        path: path.concat([node.attrs.id]),
-        elementIDs: childElements(node)
-            .map((childNode) => childNode.attrs.id)
-            .filter((id) => id),
-    }),
-    contributors_section: (node, parent, path, priority) => ({
-        category: buildSectionCategory(node),
-        priority: priority.value++,
-        path: path.concat([node.attrs.id]),
-        elementIDs: childElements(node)
-            .map((childNode) => childNode.attrs.id)
-            .filter((id) => id),
-    }),
     missing_figure: (node) => ({
         position: node.attrs.position || undefined,
     }),
@@ -568,28 +544,48 @@ export const modelFromNode = (node, parent, path, priority) => {
     const comments = [...commentAnnotationsMap.values()];
     return { model, comments };
 };
-export const encode = (node) => {
+const containerTypes = [
+    schema.nodes.affiliations,
+    schema.nodes.contributors,
+    schema.nodes.affiliations,
+    schema.nodes.keywords,
+    schema.nodes.abstracts,
+    schema.nodes.body,
+    schema.nodes.backmatter,
+    schema.nodes.comments,
+];
+export const encode = (node, preserveWithRepeatedID = false) => {
     const models = new Map();
     const priority = {
         value: 1,
     };
     const placeholders = ['placeholder', 'placeholder_element'];
-    const addModel = (path, parent) => (child) => {
+    const processNode = (path, parent) => (child) => {
+        if (containerTypes.includes(child.type)) {
+            child.forEach(processNode([], child));
+            return;
+        }
         if (!child.attrs.id) {
             return;
         }
         if (isHighlightMarkerNode(child)) {
             return;
         }
-        if (child.type === schema.nodes.meta_section) {
+        if (placeholders.includes(child.type.name)) {
             return;
         }
-        if (placeholders.includes(child.type.name)) {
+        if (parent.type === schema.nodes.paragraph) {
             return;
         }
         const { model, comments } = modelFromNode(child, parent, path, priority);
-        if (models.has(model._id)) {
-            throw Error(`Encountered duplicate ids in models map while encoding: ${model._id}`);
+        const existingModel = models.get(model._id);
+        if (existingModel) {
+            if (preserveWithRepeatedID && !modelsEqual(model, existingModel)) {
+                model._id = generateID(model.objectType);
+            }
+            else {
+                throw Error(`Encountered duplicate ids in models map while encoding: ${model._id}`);
+            }
         }
         comments.forEach((comment) => {
             const proseMirrorComment = models.get(comment._id);
@@ -600,22 +596,35 @@ export const encode = (node) => {
             }
         });
         models.set(model._id, model);
-        child.forEach(addModel(path.concat(child.attrs.id), child));
+        child.forEach(processNode(path.concat(child.attrs.id), child));
     };
-    node.forEach((cNode) => {
-        if (cNode.type === schema.nodes.meta_section) {
-            processMetaSectionNode(cNode, models, priority);
-        }
-    });
-    node.forEach(addModel([], node));
+    node.forEach(processNode([], node));
+    if (isManuscriptNode(node)) {
+        auxiliaryObjectTypes.forEach((t) => {
+            const order = generateElementOrder(node, t);
+            if (order) {
+                models.set(order._id, order);
+            }
+        });
+    }
     return models;
 };
-const processMetaSectionNode = (node, models, priority) => {
-    node.descendants((child) => {
-        if ((!child.content || child.content.size === 0) &&
-            nodeTypesMap.get(child.type)) {
-            const { model } = modelFromNode(child, node, [], priority);
-            models.set(model._id, model);
+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 = nodeTypesMap.get(nodeType);
+    if (!type) {
+        return undefined;
+    }
+    const order = buildElementsOrder(type);
+    order.elements = ids;
+    return order;
 };

package/dist/es/transformer/highlight-markers.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { buildComment } from './builders';
-const highlightableFields = [
+export const highlightableFields = [
     'caption',
     'contents',
     'title',

package/dist/es/transformer/html.js

@@ -194,11 +194,9 @@ export class HTMLTransformer {
                 const citationNode = node;
                 const element = this.document.createElement('span');
                 element.setAttribute('class', 'citation');
-                const citation = getModel(citationNode.attrs.rid);
-                if (citation) {
-                    element.setAttribute('data-reference-ids', citation.embeddedCitationItems
-                        .map((item) => item.bibliographyItem)
-                        .join(' '));
+                const rids = citationNode.attrs.rids;
+                if (rids.length) {
+                    element.setAttribute('data-reference-ids', rids.join(' '));
                 }
                 if (citationNode.attrs.contents) {
                     element.innerHTML = citationNode.attrs.contents;
@@ -209,20 +207,7 @@ export class HTMLTransformer {
                 const crossReferenceNode = node;
                 const element = this.document.createElement('a');
                 element.classList.add('cross-reference');
-                const auxiliaryObjectReference = getModel(crossReferenceNode.attrs.rid);
-                if (auxiliaryObjectReference &&
-                    auxiliaryObjectReference.referencedObject) {
-                    if (auxiliaryObjectReference.referencedObject.startsWith('MPFigureElement')) {
-                        const model = getModel(auxiliaryObjectReference.referencedObject);
-                        if (model && model.containedObjectIDs.length > 0) {
-                            element.setAttribute('href', `#${model.containedObjectIDs[0]}`);
-                        }
-                    }
-                    else {
-                        element.setAttribute('href', `#${auxiliaryObjectReference.referencedObject}`);
-                    }
-                    element.setAttribute('data-reference-ids', crossReferenceNode.attrs.rid);
-                }
+                element.setAttribute('data-reference-ids', crossReferenceNode.attrs.rids.join(' '));
                 element.textContent =
                     crossReferenceNode.attrs.customLabel || crossReferenceNode.attrs.label;
                 return element;
@@ -256,7 +241,7 @@ export class HTMLTransformer {
                 };
                 return ['span', attrs];
             };
-            nodes.meta_section = () => '';
+            nodes.comments = () => '';
             const serializer = new DOMSerializer(nodes, marks);
             return serializer.serializeFragment(fragment, { document });
         };

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

@@ -35,6 +35,6 @@ export const nodeNames = new Map([
     [schema.nodes.table_element, 'Table'],
     [schema.nodes.blockquote_element, 'Block Quote'],
     [schema.nodes.pullquote_element, 'Pull Quote'],
-    [schema.nodes.keywords_section, 'Section'],
+    [schema.nodes.keywords, 'Section'],
     [schema.nodes.toc_section, 'Section'],
 ]);

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

@@ -47,7 +47,7 @@ export const nodeTitle = (node) => {
         case nodes.section:
         case nodes.bibliography_section:
         case nodes.footnotes_section:
-        case nodes.keywords_section:
+        case nodes.keywords:
         case nodes.toc_section:
         case nodes.graphical_abstract_section:
             return snippetOfNodeType(node, nodes.section_title);

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

@@ -16,6 +16,9 @@
 import { ObjectTypes } from '@manuscripts/json-schema';
 import { GROUP_ELEMENT, GROUP_EXECUTABLE, GROUP_SECTION, hasGroup, schema, } from '../schema';
 export const nodeTypesMap = new Map([
+    [schema.nodes.abstracts, ObjectTypes.Section],
+    [schema.nodes.body, ObjectTypes.Section],
+    [schema.nodes.backmatter, ObjectTypes.Section],
     [schema.nodes.comment, ObjectTypes.CommentAnnotation],
     [schema.nodes.bibliography_item, ObjectTypes.BibliographyItem],
     [schema.nodes.bibliography_element, ObjectTypes.BibliographyElement],
@@ -23,7 +26,6 @@ export const nodeTypesMap = new Map([
     [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],
@@ -37,8 +39,8 @@ export const nodeTypesMap = new Map([
     [schema.nodes.inline_equation, ObjectTypes.InlineMathFragment],
     [schema.nodes.keyword, ObjectTypes.Keyword],
     [schema.nodes.keywords_element, ObjectTypes.KeywordsElement],
-    [schema.nodes.keywords_section, ObjectTypes.Section],
-    [schema.nodes.keywords_group, ObjectTypes.KeywordGroup],
+    [schema.nodes.keywords, ObjectTypes.Section],
+    [schema.nodes.keyword_group, ObjectTypes.KeywordGroup],
     [schema.nodes.listing, ObjectTypes.Listing],
     [schema.nodes.listing_element, ObjectTypes.ListingElement],
     [schema.nodes.manuscript, ObjectTypes.Manuscript],
@@ -50,13 +52,12 @@ export const nodeTypesMap = new Map([
     [schema.nodes.table_element, ObjectTypes.TableElement],
     [schema.nodes.toc_element, ObjectTypes.TOCElement],
     [schema.nodes.toc_section, ObjectTypes.Section],
-    [schema.nodes.meta_section, ObjectTypes.MetaSection],
     [schema.nodes.affiliation, ObjectTypes.Affiliation],
     [schema.nodes.contributor, ObjectTypes.Contributor],
     [schema.nodes.table_element_footer, ObjectTypes.TableElementFooter],
+    [schema.nodes.contributors, ObjectTypes.Section],
+    [schema.nodes.affiliations, ObjectTypes.Section],
     [schema.nodes.title, ObjectTypes.Titles],
-    [schema.nodes.contributors_section, ObjectTypes.Section],
-    [schema.nodes.affiliations_section, ObjectTypes.Section],
 ]);
 export const isExecutableNodeType = (type) => hasGroup(type, GROUP_EXECUTABLE);
 export const isElementNodeType = (type) => hasGroup(type, GROUP_ELEMENT);

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

@@ -48,6 +48,5 @@ export const hasObjectType = (objectType) => (model) => model.objectType === obj
 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);
 export const isKeyword = hasObjectType(ObjectTypes.Keyword);

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

@@ -14,22 +14,14 @@
  * limitations under the License.
  */
 import { ObjectTypes } from '@manuscripts/json-schema';
-import { coreSectionCategories } from '../lib/core-section-categories';
 import { schema } from '../schema';
 const sectionNodeTypes = [
     schema.nodes.bibliography_section,
     schema.nodes.footnotes_section,
-    schema.nodes.keywords_section,
+    schema.nodes.keywords,
     schema.nodes.section,
     schema.nodes.toc_section,
 ];
-export const getCoreSectionTitles = (sectionCategory) => {
-    const category = coreSectionCategories.find((section) => section._id === sectionCategory);
-    if (category) {
-        return category.titles.length ? category.titles : [' '];
-    }
-    throw new Error(`${sectionCategory} not found in core sections`);
-};
 export const isAnySectionNode = (node) => sectionNodeTypes.includes(node.type);
 export const chooseSectionNodeType = (category) => {
     switch (category) {
@@ -40,11 +32,11 @@ export const chooseSectionNodeType = (category) => {
         case 'MPSectionCategory:endnotes':
             return schema.nodes.footnotes_section;
         case 'MPSectionCategory:keywords':
-            return schema.nodes.keywords_section;
+            return schema.nodes.keywords;
         case 'MPSectionCategory:affiliations':
-            return schema.nodes.affiliations_section;
+            return schema.nodes.affiliations;
         case 'MPSectionCategory:contributors':
-            return schema.nodes.contributors_section;
+            return schema.nodes.contributors;
         case 'MPSectionCategory:toc':
             return schema.nodes.toc_section;
         default:
@@ -82,15 +74,15 @@ export const buildSectionCategory = (node) => {
             return 'MPSectionCategory:bibliography';
         case schema.nodes.footnotes_section:
             return 'MPSectionCategory:endnotes';
-        case schema.nodes.keywords_section:
+        case schema.nodes.keywords:
             return 'MPSectionCategory:keywords';
         case schema.nodes.toc_section:
             return 'MPSectionCategory:toc';
         case schema.nodes.graphical_abstract_section:
             return 'MPSectionCategory:abstract-graphical';
-        case schema.nodes.affiliations_section:
+        case schema.nodes.affiliations:
             return 'MPSectionCategory:affiliations';
-        case schema.nodes.contributors_section:
+        case schema.nodes.contributors:
             return 'MPSectionCategory:contributors';
         default:
             return node.attrs.category || undefined;
@@ -117,6 +109,32 @@ export const chooseSecType = (sectionCategory) => {
             return suffix;
     }
 };
+export const chooseCoreSectionBySection = (section) => {
+    switch (section) {
+        case 'MPSectionCategory:abstract':
+        case 'MPSectionCategory:abstract-teaser':
+        case 'MPSectionCategory:abstract-graphical':
+            return 'MPSectionCategory:abstracts';
+        case 'MPSectionCategory:acknowledgement':
+        case 'MPSectionCategory:availability':
+        case 'MPSectionCategory:conclusions':
+        case 'MPSectionCategory:bibliography':
+        case 'MPSectionCategory:discussion':
+        case 'MPSectionCategory:endnotes':
+        case 'MPSectionCategory:appendices':
+        case 'MPSectionCategory:competing-interests':
+        case 'MPSectionCategory:con':
+        case 'MPSectionCategory:deceased':
+        case 'MPSectionCategory:ethics-statement':
+        case 'MPSectionCategory:financial-disclosure':
+        case 'MPSectionCategory:supplementary-material':
+        case 'MPSectionCategory:supported-by':
+        case 'MPSectionCategory:abbreviations':
+        case 'MPSectionCategory:results':
+            return 'MPSectionCategory:backmatter';
+    }
+    return 'MPSectionCategory:body';
+};
 export const chooseSectionCategoryByType = (secType) => {
     switch (secType) {
         case 'abstract':

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export * from './lib/core-section-categories';
+export * from './lib/section-group-type';
 export * from './lib/table-cell-styles';
 export * from './lib/utils';
 export * from './mathjax';

package/dist/types/jats/importer/index.d.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { parseJATSFront, parseJATSBody, parseJATSReferences, parseJATSArticle, getElementsOrder, } from './parse-jats-article';
+export { parseJATSFront, parseJATSBody, parseJATSArticle, } from './parse-jats-article';

package/dist/types/jats/importer/jats-body-transformations.d.ts

@@ -13,29 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Affiliation, BibliographyItem, Contributor } from '@manuscripts/json-schema';
-import { Build } from '../../transformer';
 export declare const jatsBodyTransformations: {
     ensureSection(body: Element, createElement: (tagName: string) => HTMLElement): void;
-    createAbstract(abstractNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
-    createAcknowledgments(ackNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
-    createBibliography(doc: Document, references: BibliographyItem[], createElement: (tagName: string) => HTMLElement): HTMLElement;
-    createFootnotes(footnoteGroups: Element[], createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createAbstractSection(abstractNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createAcknowledgmentsSection(ackNode: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    createFootnotesSection(footnoteGroups: Element[], createElement: (tagName: string) => HTMLElement): HTMLElement;
     createAppendixSection(app: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
-    createFloatsGroupSection(floatsGroup: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
-    moveAbstractsIntoContainer(doc: Document, abstractsContainer: Element, createElement: (tagName: string) => HTMLElement): void;
-    wrapBodySections(doc: Document, bodyContainer: Element): void;
-    moveBackSectionsIntoContainer(doc: Document, backmatterContainer: Element): void;
-    moveAcknowledgmentsIntoContainer(doc: Document, backmatterContainer: Element, createElement: (tagName: string) => HTMLElement): void;
-    moveAppendicesIntoContainer(doc: Document, backmatterContainer: Element, createElement: (tagName: string) => HTMLElement): void;
-    moveBibliographyIntoContainer(doc: Document, backmatterContainer: Element, references: BibliographyItem[] | null, createElement: (tagName: string) => HTMLElement): void;
-    moveSectionsToBody(doc: Document, body: Element, references: BibliographyItem[] | null, createElement: (tagName: string) => HTMLElement): void;
-    mapFootnotesToSections(doc: Document, backmatterContainer: Element, createElement: (tagName: string) => HTMLElement): void;
+    createFloatsGroupSection(group: Element, createElement: (tagName: string) => HTMLElement): HTMLElement;
+    moveAbstracts(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
+    wrapBodySections(doc: Document, group: Element): void;
+    moveBackSections(doc: Document, group: Element): void;
+    moveAcknowledgments(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
+    moveAppendices(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
+    createBody(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+    createAbstracts(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+    createBackmatter(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+    moveSpecialFootnotes(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
+    moveFootnotes(doc: Document, group: Element, createElement: (tagName: string) => HTMLElement): void;
     moveCaptionsToEnd(body: Element): void;
+    fixTables(body: Element, createElement: (tagName: string) => HTMLElement): void;
     moveTableFooterToEnd(body: Element): void;
-    moveAffiliationsToBody(doc: Document, affiliations: Build<Affiliation>[] | undefined, body: Element, createElement: (tagName: string) => HTMLElement): void;
-    moveAuthorsToBody(doc: Document, authors: Build<Contributor>[] | undefined, body: Element, createElement: (tagName: string) => HTMLElement): void;
     moveFloatsGroupToBody(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
-    moveBlockNodesFromParagraph(doc: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
-    moveKeywordsToBody(document: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
+    createKeywords(document: Document, body: Element, createElement: (tagName: string) => HTMLElement): void;
 };

package/dist/types/jats/importer/jats-comments.d.ts

@@ -13,14 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BibliographyItem, CommentAnnotation, Model } from '@manuscripts/json-schema';
-import { Build } from '../../transformer';
-type ProcessingInstruction = {
+import { CommentAnnotation, Model } from '@manuscripts/json-schema';
+import { References } from './jats-references';
+export type JATSComment = {
     id: string;
-    queryText: string;
+    text: string;
 };
-export declare const parseProcessingInstruction: (node: Node) => ProcessingInstruction | undefined;
-export declare const markProcessingInstructions: (doc: Document) => Map<string, string>;
-export declare const createComments: (authorQueriesMap: Map<string, string>, manuscriptModels: Array<Model>) => Build<CommentAnnotation>[];
-export declare const createReferenceComments: (referenceQueriesMap: Map<string, string[]>, references: Array<BibliographyItem>) => Build<CommentAnnotation>[];
-export {};
+export type JATSCommentMark = {
+    token: string;
+    comment: JATSComment;
+};
+export declare const isJATSComment: (node: Node) => boolean;
+export declare const parseJATSComment: (node: Node) => JATSComment | undefined;
+export declare const markComments: (doc: Document) => JATSCommentMark[];
+export declare const createComments: (models: Model[], marks: JATSCommentMark[]) => CommentAnnotation[];
+export declare const createReferenceComments: (references: References) => CommentAnnotation[];

package/dist/types/jats/importer/jats-front-parser.d.ts

@@ -13,20 +13,43 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Journal } from '@manuscripts/json-schema';
 export declare const jatsFrontParser: {
-    parseCounts(counts: Element | null | undefined): {
+    parseTitles(element: Element | null, createElement: (tagName: string) => HTMLElement): import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Titles>;
+    parseCounts(counts: Element | null): {
         wordCount: number | undefined;
         figureCount: number | undefined;
         tableCount: number | undefined;
         equationCount: number | undefined;
         referencesCount: number | undefined;
         genericCounts: {
-            count: number;
+            count: number | undefined;
             countType: string;
         }[] | undefined;
     } | undefined;
-    parseJournal(journalMeta: Element | null): Partial<Journal>;
+    parseJournal(element: Element | null): {
+        title: string | undefined;
+        templateID?: string | undefined;
+        ISSNs: {
+            [k: string]: any;
+            ISSN: string;
+            publicationType?: string | undefined;
+        }[];
+        abbreviatedTitles: {
+            [k: string]: any;
+            abbreviatedTitle: string;
+            abbrevType?: string | undefined;
+        }[];
+        journalIdentifiers: {
+            [k: string]: any;
+            journalID: string;
+            journalIDType?: string | undefined;
+        }[];
+        submittable?: boolean | undefined;
+        publisherName: string | undefined;
+        _id: string;
+        objectType: string;
+        contributions?: import("@manuscripts/json-schema/dist/types").Contribution[] | undefined;
+    };
     parseDates(historyNode: Element | null): {
         acceptanceDate?: number | undefined;
         correctionDate?: number | undefined;
@@ -35,18 +58,18 @@ export declare const jatsFrontParser: {
         revisionReceiveDate?: number | undefined;
         receiveDate?: number | undefined;
     } | undefined;
-    parseSupplements(supplementNodes: Element[] | null): import("../../transformer").Build<import("@manuscripts/json-schema").Supplement>[];
-    parseAffiliationNodes(affiliationNodes: Element[]): {
-        affiliations: import("../../transformer").Build<import("@manuscripts/json-schema").Affiliation>[];
+    parseSupplements(elements: Element[] | null): import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Supplement>[];
+    parseAffiliations(elements: Element[]): {
+        affiliations: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Affiliation>[];
         affiliationIDs: Map<string, string>;
     };
-    parseFootnoteNodes(footnoteNodes: Element[]): {
-        footnotes: import("../../transformer").Build<import("@manuscripts/json-schema").Footnote>[];
+    parseAuthorNotes(elements: Element[]): {
+        footnotes: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Footnote>[];
         footnoteIDs: Map<string, string>;
     };
-    parseCorrespNodes(correspNodes: Element[]): {
-        correspondingList: import("../../transformer").Build<import("@manuscripts/json-schema").Corresponding>[];
+    parseCorresp(elements: Element[]): {
+        correspondingList: import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Corresponding>[];
         correspondingIDs: Map<string, string>;
     };
-    parseAuthorNodes(authorNodes: Element[], affiliationIDs: Map<string, string>, footnoteIDs: Map<string, string>, correspondingIDs: Map<string, string>): import("../../transformer").Build<import("@manuscripts/json-schema").Contributor>[];
+    parseContributors(elements: Element[], affiliationIDs: Map<string, string>, footnoteIDs: Map<string, string>, correspondingIDs: Map<string, string>): import("../../transformer").Build<import("@manuscripts/json-schema/dist/types").Contributor>[];
 };

package/dist/types/jats/importer/jats-journal-meta-parser.d.ts

@@ -25,10 +25,10 @@ export type JournalIdentifier = {
     journalID: string;
     journalIDType?: string;
 };
-export declare const parseJournalIdentifiers: (journalMeta: Element) => Array<JournalIdentifier>;
-export declare const parseJournalAbbreviatedTitles: (journalMeta: Element) => Array<AbbreviatedTitle>;
-export declare const parseJournalISSNs: (journalMeta: Element) => Array<ISSN>;
-export declare const parseJournalMeta: (journalMeta: Element) => {
+export declare const parseJournalIdentifiers: (element: Element | null) => JournalIdentifier[];
+export declare const parseJournalAbbreviatedTitles: (element: Element | null) => AbbreviatedTitle[];
+export declare const parseJournalISSNs: (element: Element | null) => ISSN[];
+export declare const parseJournalMeta: (element: Element | null) => {
     abbreviatedTitles: AbbreviatedTitle[];
     journalIdentifiers: JournalIdentifier[];
     ISSNs: ISSN[];

package/dist/types/jats/importer/jats-parser-utils.d.ts

@@ -13,11 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Model } from '@manuscripts/json-schema';
 import { ManuscriptNode } from '../../schema';
-export declare function flatten<T>(arrays: T[][]): T[];
-export declare const fixBodyPMNode: (output: ManuscriptNode, models: Model[], referenceIdsMap?: Map<string, string>) => {
-    warnings: string[];
-    replacements: Map<string, string>;
-};
+export declare const updateDocumentIDs: (node: ManuscriptNode, replacements: Map<string, string>) => string[];
 export declare const htmlFromJatsNode: (element: Element | undefined | null, createElement: (tagName: string) => HTMLElement) => string | undefined;

package/dist/types/jats/importer/jats-reference-parser.d.ts

@@ -13,11 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { References } from './jats-references';
 export declare const jatsReferenceParser: {
-    parseReferences(referenceNodes: Element[], createElement: (tagName: string) => HTMLElement): {
-        references: import("../../transformer/builders").Build<import("@manuscripts/json-schema").BibliographyItem>[];
-        referenceIDs: Map<string, string>;
-        referenceQueries: Map<string, string[]>;
-    };
-    parseCrossReferences(crossReferenceNodes: Element[], referenceIDs: Map<string, string>): (import("../../transformer/builders").Build<import("@manuscripts/json-schema").AuxiliaryObjectReference> | import("../../transformer/builders").Build<import("@manuscripts/json-schema").Citation>)[];
+    parseReferences(elements: Element[], createElement: (tagName: string) => HTMLElement): References;
 };

package/dist/types/jats/importer/jats-references.d.ts

@@ -0,0 +1,12 @@
+import { BibliographyItem } from '@manuscripts/json-schema';
+import { JATSComment } from './jats-comments';
+export declare class References {
+    items: Map<string, BibliographyItem>;
+    IDs: Map<string, string>;
+    comments: Map<string, JATSComment[]>;
+    constructor();
+    add(item: BibliographyItem, id: string | null, comments: JATSComment[]): void;
+    getBibliographyItems(): BibliographyItem[];
+    getComments(id: string): JATSComment[];
+    private getValue;
+}

package/dist/types/jats/importer/parse-jats-article.d.ts

@@ -13,20 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Affiliation, BibliographyItem, Contributor, ElementsOrder, FootnotesOrder, Model } from '@manuscripts/json-schema';
-import { ManuscriptNode } from '../../schema';
-import { Build } from '../../transformer/builders';
-export declare const parseJATSFront: (front: Element) => Promise<{
-    models: Model[];
-    authors: Build<Contributor>[];
-    affiliations: Build<Affiliation>[];
-}>;
-export declare const parseJATSReferences: (back: Element | null, body: Element | null, createElement: (tagName: string) => HTMLElement) => {
-    references: Model[];
-    crossReferences: Model[];
-    referenceQueriesMap: Map<string, string[]> | undefined;
-    referenceIdsMap: Map<string, string> | undefined;
-};
-export declare const parseJATSBody: (document: Document, body: Element, bibliographyItems: BibliographyItem[] | null, authors: Build<Contributor>[], affiliations: Build<Affiliation>[], refModels: Model[], referenceIdsMap: Map<string, string> | undefined, footnotesOrder?: FootnotesOrder) => ManuscriptNode;
-export declare const parseJATSArticle: (doc: Document) => Promise<Model[]>;
-export declare const getElementsOrder: (node: ManuscriptNode) => ElementsOrder[];
+import { Model } from '@manuscripts/json-schema';
+import { References } from './jats-references';
+export declare const parseJATSFront: (doc: Document, front: Element) => Model[];
+export declare const parseJATSBody: (doc: Document, body: Element, references?: References) => IterableIterator<Model>;
+export declare const parseJATSArticle: (doc: Document) => Model[];

package/dist/types/jats/index.d.ts

@@ -13,6 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { parseJATSFront, parseJATSReferences, parseJATSBody, parseJATSArticle, getElementsOrder, } from './importer';
+export { parseJATSFront, parseJATSBody, parseJATSArticle, } from './importer';
 export * from './jats-exporter';
 export * from './jats-versions';