@manuscripts/transform 4.5.7 → 4.6.0

package/src/jats/__tests__/jats-importer.test.ts

@@ -68,6 +68,43 @@ describe('JATS importer', () => {
       expect(contributorsNode).toHaveLength(0)
     })
   })
+  describe('bio', () => {
+    it('should parse bio with graphic and paragraph into the contributor node', async () => {
+      const jats = await readAndParseFixture('jats-import.xml')
+      const node = parseJATSArticle(jats, sectionCategories)
+      changeIDs(node)
+      const [contributor] = findNodesByType(node, schema.nodes.contributor)
+
+      expect(contributor.childCount).toBe(1)
+      const bio = contributor.firstChild!
+      expect(bio.type).toBe(schema.nodes.bio)
+      expect(bio.childCount).toBe(2)
+
+      const image = findNodeByType(bio, schema.nodes.image_element)
+      expect(findNodeByType(image, schema.nodes.figure).attrs.src).toBe(
+        'agnete-hornnes.png'
+      )
+      expect(findNodeByType(image, schema.nodes.alt_text).textContent).toBe(
+        'Headshot of Agnete Hviid Hornnes'
+      )
+
+      // exact paragraph text proves name/email/xref metadata did not leak into the bio
+      const paragraph = bio.lastChild!
+      expect(paragraph.type).toBe(schema.nodes.paragraph)
+      expect(paragraph.textContent).toBe(
+        'Agnete is a Professor of Neurology at Herlev og Gentofte Hospital, specializing in stroke research.'
+      )
+      expect(bio).toMatchSnapshot()
+    })
+    it('should not add bio content to contributors without a bio element', async () => {
+      const jats = await readAndParseFixture('jats-import.xml')
+      const node = parseJATSArticle(jats, sectionCategories)
+      const [, contributor] = findNodesByType(node, schema.nodes.contributor)
+
+      expect(contributor.childCount).toBe(0)
+      expect(findNodesByType(node, schema.nodes.bio)).toHaveLength(1)
+    })
+  })
   describe('affiliations', () => {
     it('should correctly parse affiliation nodes', async () => {
       const jats = await readAndParseFixture('jats-import.xml')

package/src/jats/__tests__/jats-roundtrip.test.ts

@@ -15,6 +15,7 @@
  */
 
 import { parseXml } from 'libxmljs2'
+import serializeToXML from 'w3c-xmlserializer'
 
 import { JATSExporter } from '../exporter/jats-exporter'
 import { parseJATSArticle } from '../importer/parse-jats-article'
@@ -36,9 +37,10 @@ const roundtrip = async (filename: string) => {
   const node = parseJATSArticle(doc, sectionCategories)
 
   const exporter = new JATSExporter()
-  return await exporter.serializeToJATS(node, {
+  const document = await exporter.export(node, {
     csl: DEFAULT_CSL_OPTIONS,
   })
+  return serializeToXML(document)
 }
 
 describe('JATS roundtrip', () => {

package/src/jats/exporter/JATSExporterBase.ts

@@ -0,0 +1,164 @@
+/*!
+ * © 2026 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 { DOMSerializer, type NodeType } from 'prosemirror-model'
+import { findChildrenByAttr, findChildrenByType } from 'prosemirror-utils'
+
+import { isNodeOfType, ManuscriptNode, ManuscriptNodeType } from '../../schema'
+import { normalizeID } from './lib'
+
+export class JATSExporterBase {
+  private nodesMap: Map<NodeType, ManuscriptNode[]> = new Map()
+  protected manuscriptNode: ManuscriptNode
+  protected document: Document
+  protected serializer: DOMSerializer
+
+  public isChildOfNodeType(targetID: string, type: NodeType, descend = false) {
+    const nodes = this.getChildrenOfType(type)
+    return nodes.some((node) => {
+      const result = findChildrenByAttr(
+        node,
+        (attrs) => attrs.id === targetID,
+        descend
+      )[0]
+      return !!result
+    })
+  }
+
+  protected populateNodesMap = () => {
+    this.manuscriptNode.descendants((node) => {
+      const type = node.type
+      const nodes = this.nodesMap.get(type) ?? []
+      nodes.push(node)
+      this.nodesMap.set(type, nodes)
+    })
+  }
+
+  public getChildrenOfType<T extends ManuscriptNode>(
+    type: NodeType,
+    node?: ManuscriptNode
+  ): T[] {
+    const nodes = node
+      ? findChildrenByType(node, type).map(({ node }) => node)
+      : this.nodesMap.get(type)
+    return (nodes ?? []).filter((n): n is T => isNodeOfType<T>(n, type))
+  }
+
+  public getFirstChildOfType<T extends ManuscriptNode>(
+    type: NodeType,
+    node?: ManuscriptNode
+  ): T | undefined {
+    return this.getChildrenOfType<T>(type, node)[0]
+  }
+
+  protected fillEmptyElements(
+    $article: Element,
+    selector: string,
+    tagName = 'p'
+  ) {
+    const $empty = Array.from($article.querySelectorAll(selector)).filter(
+      ($el) => !$el.innerHTML
+    )
+    $empty.forEach(($element) =>
+      $element.appendChild(this.createElement(tagName))
+    )
+  }
+
+  protected createElement = (
+    tag: string,
+    content?: string,
+    attrs?: Record<string, string | undefined>
+  ) => {
+    const $element = this.document.createElement(tag)
+    if (content) {
+      $element.textContent = content
+    }
+    if (attrs) {
+      Object.entries(attrs).forEach(([k, v]) => {
+        if (v) {
+          $element.setAttribute(k, v)
+        }
+      })
+    }
+    return $element
+  }
+
+  protected appendElement = (
+    $parent: Element,
+    tag: string,
+    content?: string,
+    attrs?: Record<string, string | undefined>
+  ) => {
+    const $element = this.createElement(tag, content, attrs)
+    $parent.appendChild($element)
+    return $element
+  }
+
+  protected changeTag = ($node: Element, tag: string) => {
+    const $clone = this.createElement(tag)
+    for (const attr of $node.attributes) {
+      $clone.setAttributeNS(null, attr.name, attr.value)
+    }
+    while ($node.firstChild) {
+      $clone.appendChild($node.firstChild)
+    }
+    $node.replaceWith($clone)
+    return $clone
+  }
+
+  protected createElementWithID(node: ManuscriptNode, nodeName: string) {
+    const $element = this.createElement(nodeName)
+    $element.setAttribute('id', normalizeID(node.attrs.id))
+    return $element
+  }
+
+  protected serializeNode(node: ManuscriptNode) {
+    return this.serializer.serializeNode(node, {
+      document: this.document,
+    })
+  }
+
+  protected appendChildIfPresent(
+    $parent: Element,
+    tagName: string,
+    textContent: string
+  ) {
+    if (!textContent) {
+      return
+    }
+    const $element = this.createElement(tagName)
+    $element.textContent = textContent
+    $parent.appendChild($element)
+  }
+
+  protected processChildNodes = (
+    $element: Element,
+    node: ManuscriptNode,
+    contentNodeType: ManuscriptNodeType
+  ) => {
+    node.forEach((childNode) => {
+      if (childNode.type === contentNodeType) {
+        if (childNode.attrs.id) {
+          $element.appendChild(this.serializeNode(childNode))
+        }
+      } else if (childNode.type === node.type.schema.nodes.paragraph) {
+        $element.appendChild(this.serializeNode(childNode))
+      } else if (childNode.type === node.type.schema.nodes.missing_figure) {
+        $element.appendChild(this.serializeNode(childNode))
+      }
+    })
+  }
+}