@adobe/helix-docx2md 1.3.14 → 1.4.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.4.1](https://github.com/adobe/helix-docx2md/compare/v1.4.0...v1.4.1) (2023-03-27)
+
+
+### Bug Fixes
+
+* convert multi line inline code to code block ([#213](https://github.com/adobe/helix-docx2md/issues/213)) ([9c7d34f](https://github.com/adobe/helix-docx2md/commit/9c7d34fae02377eef39ee865f89924698a6e867f)), closes [#210](https://github.com/adobe/helix-docx2md/issues/210)
+
+# [1.4.0](https://github.com/adobe/helix-docx2md/compare/v1.3.14...v1.4.0) (2023-02-16)
+
+
+### Features
+
+* detect _top bookmark ([#197](https://github.com/adobe/helix-docx2md/issues/197)) ([029df1e](https://github.com/adobe/helix-docx2md/commit/029df1eafe74f918ca39b1a06fe6cc119e742a32))
+
 ## [1.3.14](https://github.com/adobe/helix-docx2md/compare/v1.3.13...v1.3.14) (2023-02-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/helix-docx2md",
-  "version": "1.3.14",
+  "version": "1.4.1",
   "description": "Helix library that converts word documents to markdown",
   "type": "module",
   "main": "./src/index.js",
@@ -51,20 +51,20 @@
     "yauzl": "2.10.0"
   },
   "devDependencies": {
-    "@adobe/eslint-config-helix": "2.0.1",
-    "@adobe/helix-mediahandler": "2.0.5",
-    "@semantic-release/changelog": "6.0.2",
+    "@adobe/eslint-config-helix": "2.0.2",
+    "@adobe/helix-mediahandler": "2.0.17",
+    "@semantic-release/changelog": "6.0.3",
     "@semantic-release/exec": "6.0.3",
     "@semantic-release/git": "10.0.1",
-    "c8": "7.12.0",
+    "c8": "7.13.0",
     "dotenv": "16.0.3",
-    "eslint": "8.32.0",
+    "eslint": "8.36.0",
     "husky": "8.0.3",
     "junit-report-builder": "3.0.1",
-    "lint-staged": "13.1.0",
+    "lint-staged": "13.2.0",
     "mocha": "10.2.0",
     "mocha-multi-reporters": "1.5.1",
-    "semantic-release": "19.0.5",
+    "semantic-release": "20.1.3",
     "unist-util-inspect": "7.0.2"
   },
   "lint-staged": {

package/src/dast2mdast/dast2mdast.js

@@ -104,11 +104,13 @@ export default async function dast2mdast(tree, opts = {}) {
   const slugger = new IDSlugger();
   for (const bm of bookmarks) {
     if (!bm.target) {
-      // eslint-disable-next-line no-continue
-      continue;
-    }
-    // if heading, create an ID from its text
-    if (bm.target.type === 'heading') {
+      if (bm.name !== '_top') {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      bm.id = '';
+    } else if (bm.target.type === 'heading') {
+      // if heading, create an ID from its text
       const text = toString(bm.target).trim();
       bm.id = slugger.slug(text || 'heading');
       bm.target.id = bm.id;

package/src/dast2mdast/handlers/paragraph.js

@@ -73,6 +73,103 @@ function isBlockquote(node) {
   return styleName && styleName.toLowerCase() === 'quote';
 }
 
+function findFrom(nodes, start, pred) {
+  let idx = start;
+  while (idx < nodes.length) {
+    if (pred(nodes[idx])) {
+      return idx;
+    }
+    idx += 1;
+  }
+  return -1;
+}
+
+/**
+ * For each paragraph, check if there is an (inlinecode br+ inlincode) sequence and promote them
+ * to codeblocks at the container level.
+ * @param ret
+ */
+function collapseInlineCode(ret, prev) {
+  for (let p = 0; p < ret.length; p += 1) {
+    const { type, children } = ret[p];
+    if (type === 'paragraph') {
+      for (let i = 0; i < children.length; i += 1) {
+        const next = findFrom(children, i, (n) => n.type === 'inlineCode');
+        if (next < 0) {
+          break;
+        }
+        // there should be at least 3 nodes remaining, otherwise we keep the inline code
+        if (children.length - next < 3) {
+          break;
+        }
+        // if previous node is a break, this is might be the start of a code block
+        if (next === 0 || children[next - 1].type === 'break') {
+          // find first non codeish
+          const last = findFrom(children, next + 1, (n) => n.type !== 'inlineCode' && n.type !== 'break');
+          if (last < 0 || children[last - 1].type === 'break') {
+            // detected a codeblock... split the paragraph
+            if (next > 0) {
+              // move first chunk to new paragraph
+              const kids = children.splice(0, next);
+              while (kids[kids.length - 1].type === 'break') {
+                kids.pop();
+              }
+              ret.splice(p, 0, {
+                type: 'paragraph',
+                children: kids,
+              });
+              p += 1;
+            }
+            if (last < 0) {
+              // entire paragraph is code block
+              ret.splice(p, 1, {
+                type: 'code',
+                value: toString(ret[p]).trimEnd(),
+              });
+              break;
+            }
+            // create code block
+            const codeblock = last < 0 ? children : children.splice(0, last - next);
+            ret.splice(p, 0, {
+              type: 'code',
+              value: toString({ children: codeblock }).trimEnd(),
+            });
+            p += 1;
+            i = -1;
+          } else {
+            // look for more
+            i = last;
+          }
+        } else {
+          // otherwise look for more
+          i = next;
+        }
+      }
+
+      // merge with previous if needed
+      if (children.length && children.findIndex((n) => n.type !== 'inlineCode' && n.type !== 'break') < 0) {
+        // eslint-disable-next-line no-param-reassign
+        ret[p].singleLineCode = true;
+        if (p === 0 && prev.singleLineCode) {
+          if (prev.type === 'paragraph') {
+            // eslint-disable-next-line no-param-reassign
+            prev.type = 'code';
+            // eslint-disable-next-line no-param-reassign
+            prev.value = `${toString(prev)}\n${toString(ret[p])}`;
+            // eslint-disable-next-line no-param-reassign
+            delete prev.children;
+          } else {
+            // eslint-disable-next-line no-param-reassign
+            prev.value += `\n${toString(ret[p])}`;
+          }
+          ret.splice(p, 1);
+          p -= 1;
+        }
+      }
+    }
+  }
+}
+
 export default function paragraph(h, node, parent, siblings) {
   const { children } = node;
   const nodes = all(h, node);
@@ -184,12 +281,13 @@ export default function paragraph(h, node, parent, siblings) {
   }
 
   // check for codeblock
+  const prev = siblings.length > 0 ? siblings[siblings.length - 1] : {};
   if (isCodeBlock(node)) {
     const text = toString({ children: nodes });
     // check if previous sibling was code block
-    if (siblings.length > 0 && siblings[siblings.length - 1].type === 'code') {
+    if (prev.type === 'code') {
       // eslint-disable-next-line no-param-reassign
-      siblings[siblings.length - 1].value += `\n${text}`;
+      prev.value += `\n${text}`;
       return undefined;
     }
     return h('code', text);
@@ -257,6 +355,9 @@ export default function paragraph(h, node, parent, siblings) {
     ret.push(h('paragraph', nodes));
   }
 
+  // for each paragraph, find groups of inline code that could form a code block
+  collapseInlineCode(ret, prev);
+
   // check for block quote
   if (isBlockquote(node)) {
     return h('blockquote', ret);

package/src/dast2mdast/handlers/run.js

@@ -50,17 +50,15 @@ export default function run(h, node, parent, siblings) {
   }
 
   if (isInlineCode(node)) {
-    const isBreak = nodes.find((n) => n.type === 'break');
     const text = toString({ children: nodes });
+    const lines = text.split(/(\n)/);
     const prev = siblings.length > 0 ? siblings[siblings.length - 1] : {};
-    if (prev.type === 'inlineCode' || prev.type === 'code') {
-      if (isBreak) {
-        prev.type = 'code';
-      }
-      prev.value += text;
-      return undefined;
+    while (lines.length > 0 && lines[0] !== '\n' && prev.type === 'inlineCode') {
+      prev.value += lines.shift();
     }
-    return h('inlineCode', { value: text });
+    return lines
+      .filter((value) => !!value)
+      .map((value) => ({ type: value === '\n' ? 'break' : 'inlineCode', value }));
   }
 
   let result = nodes;